diff --git a/Documentation/LibWebPatterns.md b/Documentation/LibWebPatterns.md
index 673b4a60df8..b0734684817 100644
--- a/Documentation/LibWebPatterns.md
+++ b/Documentation/LibWebPatterns.md
@@ -36,7 +36,7 @@ This is the most common and at the same time most broad error type in LibWeb. In
 variant of supported errors:
 
 -   `SimpleException`
--   `JS::NonnullGCPtr<DOMException>`
+-   `GC::Ref<DOMException>`
 -   `JS::Completion` (from `JS::ThrowCompletionOr<T>`, assumed to be of `Type::Throw`)
 
 Use this error type for anything that needs to interact with the JS bindings, which will generally
@@ -86,7 +86,7 @@ must have:
 
     ```cpp
     // https://fetch.spec.whatwg.org/#concept-fetch
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS::Realm& realm, Infrastructure::Request& request, Infrastructure::FetchAlgorithms const& algorithms, UseParallelQueue use_parallel_queue)
+    WebIDL::ExceptionOr<GC::Ref<Infrastructure::FetchController>> fetch(JS::Realm& realm, Infrastructure::Request& request, Infrastructure::FetchAlgorithms const& algorithms, UseParallelQueue use_parallel_queue)
     {
         // ...
     }
@@ -99,7 +99,7 @@ must have:
     VERIFY(request.mode() == Infrastructure::Request::Mode::Navigate || !algorithms.process_early_hints_response().has_value());
 
     // 2. Let taskDestination be null.
-    JS::GCPtr<JS::Object> task_destination;
+    GC::Ptr<JS::Object> task_destination;
 
     // ...
     ```
diff --git a/Libraries/LibJS/Heap/BlockAllocator.cpp b/Libraries/LibGC/BlockAllocator.cpp
similarity index 96%
rename from Libraries/LibJS/Heap/BlockAllocator.cpp
rename to Libraries/LibGC/BlockAllocator.cpp
index af0a0d27938..0c890619eae 100644
--- a/Libraries/LibJS/Heap/BlockAllocator.cpp
+++ b/Libraries/LibGC/BlockAllocator.cpp
@@ -7,8 +7,8 @@
 #include <AK/Platform.h>
 #include <AK/Random.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/BlockAllocator.h>
-#include <LibJS/Heap/HeapBlock.h>
+#include <LibGC/BlockAllocator.h>
+#include <LibGC/HeapBlock.h>
 #include <sys/mman.h>
 
 #ifdef HAS_ADDRESS_SANITIZER
@@ -20,7 +20,7 @@
 #    define USE_FALLBACK_BLOCK_DEALLOCATION
 #endif
 
-namespace JS {
+namespace GC {
 
 BlockAllocator::~BlockAllocator()
 {
diff --git a/Libraries/LibJS/Heap/BlockAllocator.h b/Libraries/LibGC/BlockAllocator.h
similarity index 89%
rename from Libraries/LibJS/Heap/BlockAllocator.h
rename to Libraries/LibGC/BlockAllocator.h
index 7d4ab54700f..e3a5dfa28fb 100644
--- a/Libraries/LibJS/Heap/BlockAllocator.h
+++ b/Libraries/LibGC/BlockAllocator.h
@@ -7,9 +7,9 @@
 #pragma once
 
 #include <AK/Vector.h>
-#include <LibJS/Forward.h>
+#include <LibGC/Forward.h>
 
-namespace JS {
+namespace GC {
 
 class BlockAllocator {
 public:
diff --git a/Libraries/LibGC/CMakeLists.txt b/Libraries/LibGC/CMakeLists.txt
new file mode 100644
index 00000000000..be7c1d07aa7
--- /dev/null
+++ b/Libraries/LibGC/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(SOURCES
+    BlockAllocator.cpp
+    Cell.cpp
+    CellAllocator.cpp
+    ConservativeVector.cpp
+    Root.cpp
+    Heap.cpp
+    HeapBlock.cpp
+    MarkedVector.cpp
+    WeakContainer.cpp
+)
+
+serenity_lib(LibGC gc)
+target_link_libraries(LibGC PRIVATE LibCore)
diff --git a/Libraries/LibJS/Heap/CellImpl.cpp b/Libraries/LibGC/Cell.cpp
similarity index 55%
rename from Libraries/LibJS/Heap/CellImpl.cpp
rename to Libraries/LibGC/Cell.cpp
index 13673de8f57..328200f5c80 100644
--- a/Libraries/LibJS/Heap/CellImpl.cpp
+++ b/Libraries/LibGC/Cell.cpp
@@ -4,12 +4,12 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/NanBoxedValue.h>
+#include <LibGC/Cell.h>
+#include <LibGC/NanBoxedValue.h>
 
-namespace JS {
+namespace GC {
 
-void JS::CellImpl::Visitor::visit(NanBoxedValue const& value)
+void GC::Cell::Visitor::visit(NanBoxedValue const& value)
 {
     if (value.is_cell())
         visit_impl(value.as_cell());
diff --git a/Libraries/LibJS/Heap/CellImpl.h b/Libraries/LibGC/Cell.h
similarity index 85%
rename from Libraries/LibJS/Heap/CellImpl.h
rename to Libraries/LibGC/Cell.h
index 14c42add160..85eadf0459e 100644
--- a/Libraries/LibJS/Heap/CellImpl.h
+++ b/Libraries/LibGC/Cell.h
@@ -13,11 +13,11 @@
 #include <AK/Noncopyable.h>
 #include <AK/StringView.h>
 #include <AK/Weakable.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Internals.h>
+#include <LibGC/Forward.h>
+#include <LibGC/Internals.h>
+#include <LibGC/Ptr.h>
 
-namespace JS {
+namespace GC {
 
 // This instrumentation tells analysis tooling to ignore a potentially mis-wrapped GC-allocated member variable
 // It should only be used when the lifetime of the GC-allocated member is always longer than the object
@@ -27,21 +27,21 @@ namespace JS {
 #    define IGNORE_GC
 #endif
 
-#define JS_CELL(class_, base_class)                \
+#define GC_CELL(class_, base_class)                \
 public:                                            \
     using Base = base_class;                       \
     virtual StringView class_name() const override \
     {                                              \
         return #class_##sv;                        \
     }                                              \
-    friend class JS::Heap;
+    friend class GC::Heap;
 
-class CellImpl : public Weakable<CellImpl> {
-    AK_MAKE_NONCOPYABLE(CellImpl);
-    AK_MAKE_NONMOVABLE(CellImpl);
+class Cell : public Weakable<Cell> {
+    AK_MAKE_NONCOPYABLE(Cell);
+    AK_MAKE_NONMOVABLE(Cell);
 
 public:
-    virtual ~CellImpl() = default;
+    virtual ~Cell() = default;
 
     bool is_marked() const { return m_mark; }
     void set_marked(bool b) { m_mark = b; }
@@ -58,36 +58,36 @@ public:
 
     class Visitor {
     public:
-        void visit(CellImpl* cell)
+        void visit(Cell* cell)
         {
             if (cell)
                 visit_impl(*cell);
         }
 
-        void visit(CellImpl& cell)
+        void visit(Cell& cell)
         {
             visit_impl(cell);
         }
 
-        void visit(CellImpl const* cell)
+        void visit(Cell const* cell)
         {
-            visit(const_cast<CellImpl*>(cell));
+            visit(const_cast<Cell*>(cell));
         }
 
-        void visit(CellImpl const& cell)
+        void visit(Cell const& cell)
         {
-            visit(const_cast<CellImpl&>(cell));
+            visit(const_cast<Cell&>(cell));
         }
 
         template<typename T>
-        void visit(GCPtr<T> cell)
+        void visit(Ptr<T> cell)
         {
             if (cell)
                 visit_impl(const_cast<RemoveConst<T>&>(*cell.ptr()));
         }
 
         template<typename T>
-        void visit(NonnullGCPtr<T> cell)
+        void visit(Ref<T> cell)
         {
             visit_impl(const_cast<RemoveConst<T>&>(*cell.ptr()));
         }
@@ -161,7 +161,7 @@ public:
         virtual void visit_possible_values(ReadonlyBytes) = 0;
 
     protected:
-        virtual void visit_impl(CellImpl&) = 0;
+        virtual void visit_impl(Cell&) = 0;
         virtual ~Visitor() = default;
     };
 
@@ -180,7 +180,7 @@ public:
     ALWAYS_INLINE Heap& heap() const { return HeapBlockBase::from_cell(this)->heap(); }
 
 protected:
-    CellImpl() = default;
+    Cell() = default;
 
     ALWAYS_INLINE void* private_data() const { return bit_cast<HeapBase*>(&heap())->private_data(); }
 
@@ -195,8 +195,8 @@ private:
 }
 
 template<>
-struct AK::Formatter<JS::CellImpl> : AK::Formatter<FormatString> {
-    ErrorOr<void> format(FormatBuilder& builder, JS::CellImpl const* cell)
+struct AK::Formatter<GC::Cell> : AK::Formatter<FormatString> {
+    ErrorOr<void> format(FormatBuilder& builder, GC::Cell const* cell)
     {
         if (!cell)
             return builder.put_string("Cell{nullptr}"sv);
diff --git a/Libraries/LibJS/Heap/CellAllocator.cpp b/Libraries/LibGC/CellAllocator.cpp
similarity index 87%
rename from Libraries/LibJS/Heap/CellAllocator.cpp
rename to Libraries/LibGC/CellAllocator.cpp
index fe8d00578dc..78433a2cc86 100644
--- a/Libraries/LibJS/Heap/CellAllocator.cpp
+++ b/Libraries/LibGC/CellAllocator.cpp
@@ -5,12 +5,12 @@
  */
 
 #include <AK/Badge.h>
-#include <LibJS/Heap/BlockAllocator.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/HeapBlock.h>
+#include <LibGC/BlockAllocator.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/Heap.h>
+#include <LibGC/HeapBlock.h>
 
-namespace JS {
+namespace GC {
 
 CellAllocator::CellAllocator(size_t cell_size, char const* class_name)
     : m_class_name(class_name)
@@ -18,7 +18,7 @@ CellAllocator::CellAllocator(size_t cell_size, char const* class_name)
 {
 }
 
-CellImpl* CellAllocator::allocate_cell(Heap& heap)
+Cell* CellAllocator::allocate_cell(Heap& heap)
 {
     if (!m_list_node.is_in_list())
         heap.register_cell_allocator({}, *this);
diff --git a/Libraries/LibJS/Heap/CellAllocator.h b/Libraries/LibGC/CellAllocator.h
similarity index 84%
rename from Libraries/LibJS/Heap/CellAllocator.h
rename to Libraries/LibGC/CellAllocator.h
index beece07829f..8a73436901e 100644
--- a/Libraries/LibJS/Heap/CellAllocator.h
+++ b/Libraries/LibGC/CellAllocator.h
@@ -9,17 +9,17 @@
 #include <AK/IntrusiveList.h>
 #include <AK/NeverDestroyed.h>
 #include <AK/NonnullOwnPtr.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/BlockAllocator.h>
-#include <LibJS/Heap/HeapBlock.h>
+#include <LibGC/BlockAllocator.h>
+#include <LibGC/Forward.h>
+#include <LibGC/HeapBlock.h>
 
-#define JS_DECLARE_ALLOCATOR(ClassName) \
-    static JS::TypeIsolatingCellAllocator<ClassName> cell_allocator
+#define GC_DECLARE_ALLOCATOR(ClassName) \
+    static GC::TypeIsolatingCellAllocator<ClassName> cell_allocator
 
-#define JS_DEFINE_ALLOCATOR(ClassName) \
-    JS::TypeIsolatingCellAllocator<ClassName> ClassName::cell_allocator { #ClassName }
+#define GC_DEFINE_ALLOCATOR(ClassName) \
+    GC::TypeIsolatingCellAllocator<ClassName> ClassName::cell_allocator { #ClassName }
 
-namespace JS {
+namespace GC {
 
 class CellAllocator {
 public:
@@ -28,7 +28,7 @@ public:
 
     size_t cell_size() const { return m_cell_size; }
 
-    CellImpl* allocate_cell(Heap&);
+    Cell* allocate_cell(Heap&);
 
     template<typename Callback>
     IterationDecision for_each_block(Callback callback)
diff --git a/Libraries/LibJS/Heap/ConservativeVector.cpp b/Libraries/LibGC/ConservativeVector.cpp
similarity index 80%
rename from Libraries/LibJS/Heap/ConservativeVector.cpp
rename to Libraries/LibGC/ConservativeVector.cpp
index b9ef2f26b97..33e6f1a3aaa 100644
--- a/Libraries/LibJS/Heap/ConservativeVector.cpp
+++ b/Libraries/LibGC/ConservativeVector.cpp
@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/ConservativeVector.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/ConservativeVector.h>
+#include <LibGC/Heap.h>
 
-namespace JS {
+namespace GC {
 
 ConservativeVectorBase::ConservativeVectorBase(Heap& heap)
     : m_heap(&heap)
diff --git a/Libraries/LibJS/Heap/ConservativeVector.h b/Libraries/LibGC/ConservativeVector.h
similarity index 94%
rename from Libraries/LibJS/Heap/ConservativeVector.h
rename to Libraries/LibGC/ConservativeVector.h
index 066dcf37edd..150525a7cea 100644
--- a/Libraries/LibJS/Heap/ConservativeVector.h
+++ b/Libraries/LibGC/ConservativeVector.h
@@ -9,11 +9,11 @@
 #include <AK/HashMap.h>
 #include <AK/IntrusiveList.h>
 #include <AK/Vector.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/HeapRoot.h>
+#include <LibGC/Cell.h>
+#include <LibGC/Forward.h>
+#include <LibGC/HeapRoot.h>
 
-namespace JS {
+namespace GC {
 
 class ConservativeVectorBase {
 public:
diff --git a/Libraries/LibJS/Heap/DeferGC.h b/Libraries/LibGC/DeferGC.h
similarity index 88%
rename from Libraries/LibJS/Heap/DeferGC.h
rename to Libraries/LibGC/DeferGC.h
index 3c2ab1ea11a..addeed7a53a 100644
--- a/Libraries/LibJS/Heap/DeferGC.h
+++ b/Libraries/LibGC/DeferGC.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 
-namespace JS {
+namespace GC {
 
 class DeferGC {
 public:
diff --git a/Libraries/LibGC/Forward.h b/Libraries/LibGC/Forward.h
new file mode 100644
index 00000000000..98cf257c9cf
--- /dev/null
+++ b/Libraries/LibGC/Forward.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2024, Shannon Booth <shannon@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+namespace GC {
+
+class Cell;
+class CellAllocator;
+class DeferGC;
+class RootImpl;
+class Heap;
+class HeapBlock;
+class NanBoxedValue;
+class WeakContainer;
+
+template<typename T>
+class Function;
+
+template<class T>
+class Root;
+
+template<class T, size_t inline_capacity = 0>
+class ConservativeVector;
+
+template<class T, size_t inline_capacity = 0>
+class MarkedVector;
+
+}
diff --git a/Libraries/LibGC/Function.h b/Libraries/LibGC/Function.h
new file mode 100644
index 00000000000..047ea765cc5
--- /dev/null
+++ b/Libraries/LibGC/Function.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023, Andreas Kling <andreas@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Function.h>
+#include <LibGC/Cell.h>
+#include <LibGC/Heap.h>
+
+namespace GC {
+
+template<typename T>
+class Function final : public Cell {
+    GC_CELL(Function, Cell);
+
+public:
+    static Ref<Function> create(Heap& heap, AK::Function<T> function)
+    {
+        return heap.allocate<Function>(move(function));
+    }
+
+    virtual ~Function() override = default;
+
+    [[nodiscard]] AK::Function<T> const& function() const { return m_function; }
+
+private:
+    Function(AK::Function<T> function)
+        : m_function(move(function))
+    {
+    }
+
+    virtual void visit_edges(Visitor& visitor) override
+    {
+        Base::visit_edges(visitor);
+        visitor.visit_possible_values(m_function.raw_capture_range());
+    }
+
+    AK::Function<T> m_function;
+};
+
+template<typename Callable, typename T = EquivalentFunctionType<Callable>>
+static Ref<Function<T>> create_function(Heap& heap, Callable&& function)
+{
+    return Function<T>::create(heap, AK::Function<T> { forward<Callable>(function) });
+}
+
+}
diff --git a/Libraries/LibJS/Heap/Heap.cpp b/Libraries/LibGC/Heap.cpp
similarity index 89%
rename from Libraries/LibJS/Heap/Heap.cpp
rename to Libraries/LibGC/Heap.cpp
index e7d2698267e..f6be03c1bd3 100644
--- a/Libraries/LibJS/Heap/Heap.cpp
+++ b/Libraries/LibGC/Heap.cpp
@@ -15,20 +15,20 @@
 #include <AK/StackInfo.h>
 #include <AK/TemporaryChange.h>
 #include <LibCore/ElapsedTimer.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/HeapBlock.h>
-#include <LibJS/Heap/NanBoxedValue.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/Heap.h>
+#include <LibGC/HeapBlock.h>
+#include <LibGC/NanBoxedValue.h>
+#include <LibGC/Root.h>
 #include <setjmp.h>
 
 #ifdef HAS_ADDRESS_SANITIZER
 #    include <sanitizer/asan_interface.h>
 #endif
 
-namespace JS {
+namespace GC {
 
-Heap::Heap(void* private_data, Function<void(HashMap<CellImpl*, JS::HeapRoot>&)> gather_embedder_roots)
+Heap::Heap(void* private_data, AK::Function<void(HashMap<Cell*, GC::HeapRoot>&)> gather_embedder_roots)
     : HeapBase(private_data)
     , m_gather_embedder_roots(move(gather_embedder_roots))
 {
@@ -100,7 +100,7 @@ static void for_each_cell_among_possible_pointers(HashTable<HeapBlock*> const& a
     for (auto possible_pointer : possible_pointers.keys()) {
         if (!possible_pointer)
             continue;
-        auto* possible_heap_block = HeapBlock::from_cell(reinterpret_cast<CellImpl const*>(possible_pointer));
+        auto* possible_heap_block = HeapBlock::from_cell(reinterpret_cast<Cell const*>(possible_pointer));
         if (!all_live_heap_blocks.contains(possible_heap_block))
             continue;
         if (auto* cell = possible_heap_block->cell_from_possible_pointer(possible_pointer)) {
@@ -109,9 +109,9 @@ static void for_each_cell_among_possible_pointers(HashTable<HeapBlock*> const& a
     }
 }
 
-class GraphConstructorVisitor final : public CellImpl::Visitor {
+class GraphConstructorVisitor final : public Cell::Visitor {
 public:
-    explicit GraphConstructorVisitor(Heap& heap, HashMap<CellImpl*, HeapRoot> const& roots)
+    explicit GraphConstructorVisitor(Heap& heap, HashMap<Cell*, HeapRoot> const& roots)
         : m_heap(heap)
     {
         m_heap.find_min_and_max_block_addresses(m_min_block_address, m_max_block_address);
@@ -129,7 +129,7 @@ public:
         }
     }
 
-    virtual void visit_impl(CellImpl& cell) override
+    virtual void visit_impl(Cell& cell) override
     {
         if (m_node_being_visited)
             m_node_being_visited->edges.set(reinterpret_cast<FlatPtr>(&cell));
@@ -148,7 +148,7 @@ public:
         for (size_t i = 0; i < (bytes.size() / sizeof(FlatPtr)); ++i)
             add_possible_value(possible_pointers, raw_pointer_sized_values[i], HeapRoot { .type = HeapRoot::Type::HeapFunctionCapturedPointer }, m_min_block_address, m_max_block_address);
 
-        for_each_cell_among_possible_pointers(m_all_live_heap_blocks, possible_pointers, [&](CellImpl* cell, FlatPtr) {
+        for_each_cell_among_possible_pointers(m_all_live_heap_blocks, possible_pointers, [&](Cell* cell, FlatPtr) {
             if (m_node_being_visited)
                 m_node_being_visited->edges.set(reinterpret_cast<FlatPtr>(cell));
 
@@ -183,8 +183,8 @@ public:
                 auto type = it.value.root_origin->type;
                 auto location = it.value.root_origin->location;
                 switch (type) {
-                case HeapRoot::Type::Handle:
-                    node.set("root"sv, ByteString::formatted("Handle {} {}:{}", location->function_name(), location->filename(), location->line_number()));
+                case HeapRoot::Type::Root:
+                    node.set("root"sv, ByteString::formatted("Root {} {}:{}", location->function_name(), location->filename(), location->line_number()));
                     break;
                 case HeapRoot::Type::MarkedVector:
                     node.set("root"sv, "MarkedVector");
@@ -218,7 +218,7 @@ private:
     };
 
     GraphNode* m_node_being_visited { nullptr };
-    Vector<NonnullGCPtr<CellImpl>> m_work_queue;
+    Vector<Ref<Cell>> m_work_queue;
     HashMap<FlatPtr, GraphNode> m_graph;
 
     Heap& m_heap;
@@ -229,7 +229,7 @@ private:
 
 AK::JsonObject Heap::dump_graph()
 {
-    HashMap<CellImpl*, HeapRoot> roots;
+    HashMap<Cell*, HeapRoot> roots;
     gather_roots(roots);
     GraphConstructorVisitor visitor(*this, roots);
     visitor.visit_all_cells();
@@ -250,7 +250,7 @@ void Heap::collect_garbage(CollectionType collection_type, bool print_report)
             m_should_gc_when_deferral_ends = true;
             return;
         }
-        HashMap<CellImpl*, HeapRoot> roots;
+        HashMap<Cell*, HeapRoot> roots;
         gather_roots(roots);
         mark_live_cells(roots);
     }
@@ -258,13 +258,13 @@ void Heap::collect_garbage(CollectionType collection_type, bool print_report)
     sweep_dead_cells(print_report, collection_measurement_timer);
 }
 
-void Heap::gather_roots(HashMap<CellImpl*, HeapRoot>& roots)
+void Heap::gather_roots(HashMap<Cell*, HeapRoot>& roots)
 {
     m_gather_embedder_roots(roots);
     gather_conservative_roots(roots);
 
-    for (auto& handle : m_handles)
-        roots.set(handle.cell(), HeapRoot { .type = HeapRoot::Type::Handle, .location = &handle.source_location() });
+    for (auto& root : m_roots)
+        roots.set(root.cell(), HeapRoot { .type = HeapRoot::Type::Root, .location = &root.source_location() });
 
     for (auto& vector : m_marked_vectors)
         vector.gather_roots(roots);
@@ -298,7 +298,7 @@ void Heap::gather_asan_fake_stack_roots(HashMap<FlatPtr, HeapRoot>&, FlatPtr, Fl
 }
 #endif
 
-NO_SANITIZE_ADDRESS void Heap::gather_conservative_roots(HashMap<CellImpl*, HeapRoot>& roots)
+NO_SANITIZE_ADDRESS void Heap::gather_conservative_roots(HashMap<Cell*, HeapRoot>& roots)
 {
     FlatPtr dummy;
 
@@ -337,8 +337,8 @@ NO_SANITIZE_ADDRESS void Heap::gather_conservative_roots(HashMap<CellImpl*, Heap
         return IterationDecision::Continue;
     });
 
-    for_each_cell_among_possible_pointers(all_live_heap_blocks, possible_pointers, [&](CellImpl* cell, FlatPtr possible_pointer) {
-        if (cell->state() == CellImpl::State::Live) {
+    for_each_cell_among_possible_pointers(all_live_heap_blocks, possible_pointers, [&](Cell* cell, FlatPtr possible_pointer) {
+        if (cell->state() == Cell::State::Live) {
             dbgln_if(HEAP_DEBUG, "  ?-> {}", (void const*)cell);
             roots.set(cell, *possible_pointers.get(possible_pointer));
         } else {
@@ -347,9 +347,9 @@ NO_SANITIZE_ADDRESS void Heap::gather_conservative_roots(HashMap<CellImpl*, Heap
     });
 }
 
-class MarkingVisitor final : public CellImpl::Visitor {
+class MarkingVisitor final : public Cell::Visitor {
 public:
-    explicit MarkingVisitor(Heap& heap, HashMap<CellImpl*, HeapRoot> const& roots)
+    explicit MarkingVisitor(Heap& heap, HashMap<Cell*, HeapRoot> const& roots)
         : m_heap(heap)
     {
         m_heap.find_min_and_max_block_addresses(m_min_block_address, m_max_block_address);
@@ -363,7 +363,7 @@ public:
         }
     }
 
-    virtual void visit_impl(CellImpl& cell) override
+    virtual void visit_impl(Cell& cell) override
     {
         if (cell.is_marked())
             return;
@@ -381,10 +381,10 @@ public:
         for (size_t i = 0; i < (bytes.size() / sizeof(FlatPtr)); ++i)
             add_possible_value(possible_pointers, raw_pointer_sized_values[i], HeapRoot { .type = HeapRoot::Type::HeapFunctionCapturedPointer }, m_min_block_address, m_max_block_address);
 
-        for_each_cell_among_possible_pointers(m_all_live_heap_blocks, possible_pointers, [&](CellImpl* cell, FlatPtr) {
+        for_each_cell_among_possible_pointers(m_all_live_heap_blocks, possible_pointers, [&](Cell* cell, FlatPtr) {
             if (cell->is_marked())
                 return;
-            if (cell->state() != CellImpl::State::Live)
+            if (cell->state() != Cell::State::Live)
                 return;
             cell->set_marked(true);
             m_work_queue.append(*cell);
@@ -400,13 +400,13 @@ public:
 
 private:
     Heap& m_heap;
-    Vector<NonnullGCPtr<CellImpl>> m_work_queue;
+    Vector<Ref<Cell>> m_work_queue;
     HashTable<HeapBlock*> m_all_live_heap_blocks;
     FlatPtr m_min_block_address;
     FlatPtr m_max_block_address;
 };
 
-void Heap::mark_live_cells(HashMap<CellImpl*, HeapRoot> const& roots)
+void Heap::mark_live_cells(HashMap<Cell*, HeapRoot> const& roots)
 {
     dbgln_if(HEAP_DEBUG, "mark_live_cells:");
 
@@ -420,7 +420,7 @@ void Heap::mark_live_cells(HashMap<CellImpl*, HeapRoot> const& roots)
     m_uprooted_cells.clear();
 }
 
-bool Heap::cell_must_survive_garbage_collection(CellImpl const& cell)
+bool Heap::cell_must_survive_garbage_collection(Cell const& cell)
 {
     if (!cell.overrides_must_survive_garbage_collection({}))
         return false;
@@ -430,7 +430,7 @@ bool Heap::cell_must_survive_garbage_collection(CellImpl const& cell)
 void Heap::finalize_unmarked_cells()
 {
     for_each_block([&](auto& block) {
-        block.template for_each_cell_in_state<CellImpl::State::Live>([](CellImpl* cell) {
+        block.template for_each_cell_in_state<Cell::State::Live>([](Cell* cell) {
             if (!cell->is_marked() && !cell_must_survive_garbage_collection(*cell))
                 cell->finalize();
         });
@@ -452,7 +452,7 @@ void Heap::sweep_dead_cells(bool print_report, Core::ElapsedTimer const& measure
     for_each_block([&](auto& block) {
         bool block_has_live_cells = false;
         bool block_was_full = block.is_full();
-        block.template for_each_cell_in_state<CellImpl::State::Live>([&](CellImpl* cell) {
+        block.template for_each_cell_in_state<Cell::State::Live>([&](Cell* cell) {
             if (!cell->is_marked() && !cell_must_survive_garbage_collection(*cell)) {
                 dbgln_if(HEAP_DEBUG, "  ~ {}", cell);
                 block.deallocate(cell);
@@ -530,7 +530,7 @@ void Heap::undefer_gc()
     }
 }
 
-void Heap::uproot_cell(CellImpl* cell)
+void Heap::uproot_cell(Cell* cell)
 {
     m_uprooted_cells.append(cell);
 }
diff --git a/Libraries/LibJS/Heap/Heap.h b/Libraries/LibGC/Heap.h
similarity index 79%
rename from Libraries/LibJS/Heap/Heap.h
rename to Libraries/LibGC/Heap.h
index 79851307c45..89e31d998d2 100644
--- a/Libraries/LibJS/Heap/Heap.h
+++ b/Libraries/LibGC/Heap.h
@@ -16,28 +16,28 @@
 #include <AK/Types.h>
 #include <AK/Vector.h>
 #include <LibCore/Forward.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/ConservativeVector.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/HeapRoot.h>
-#include <LibJS/Heap/Internals.h>
-#include <LibJS/Heap/MarkedVector.h>
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/Cell.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/ConservativeVector.h>
+#include <LibGC/Forward.h>
+#include <LibGC/HeapRoot.h>
+#include <LibGC/Internals.h>
+#include <LibGC/MarkedVector.h>
+#include <LibGC/Root.h>
+#include <LibGC/WeakContainer.h>
 
-namespace JS {
+namespace GC {
 
 class Heap : public HeapBase {
     AK_MAKE_NONCOPYABLE(Heap);
     AK_MAKE_NONMOVABLE(Heap);
 
 public:
-    explicit Heap(void* private_data, Function<void(HashMap<CellImpl*, JS::HeapRoot>&)> gather_embedder_roots);
+    explicit Heap(void* private_data, AK::Function<void(HashMap<Cell*, GC::HeapRoot>&)> gather_embedder_roots);
     ~Heap();
 
     template<typename T, typename... Args>
-    NonnullGCPtr<T> allocate(Args&&... args)
+    Ref<T> allocate(Args&&... args)
     {
         auto* memory = allocate_cell<T>();
         defer_gc();
@@ -57,8 +57,8 @@ public:
     bool should_collect_on_every_allocation() const { return m_should_collect_on_every_allocation; }
     void set_should_collect_on_every_allocation(bool b) { m_should_collect_on_every_allocation = b; }
 
-    void did_create_handle(Badge<HandleImpl>, HandleImpl&);
-    void did_destroy_handle(Badge<HandleImpl>, HandleImpl&);
+    void did_create_root(Badge<RootImpl>, RootImpl&);
+    void did_destroy_root(Badge<RootImpl>, RootImpl&);
 
     void did_create_marked_vector(Badge<MarkedVectorBase>, MarkedVectorBase&);
     void did_destroy_marked_vector(Badge<MarkedVectorBase>, MarkedVectorBase&);
@@ -71,7 +71,7 @@ public:
 
     void register_cell_allocator(Badge<CellAllocator>, CellAllocator&);
 
-    void uproot_cell(CellImpl* cell);
+    void uproot_cell(Cell* cell);
 
 private:
     friend class MarkingVisitor;
@@ -81,10 +81,10 @@ private:
     void defer_gc();
     void undefer_gc();
 
-    static bool cell_must_survive_garbage_collection(CellImpl const&);
+    static bool cell_must_survive_garbage_collection(Cell const&);
 
     template<typename T>
-    CellImpl* allocate_cell()
+    Cell* allocate_cell()
     {
         will_allocate(sizeof(T));
         if constexpr (requires { T::cell_allocator.allocator.get().allocate_cell(*this); }) {
@@ -98,10 +98,10 @@ private:
     void will_allocate(size_t);
 
     void find_min_and_max_block_addresses(FlatPtr& min_address, FlatPtr& max_address);
-    void gather_roots(HashMap<CellImpl*, HeapRoot>&);
-    void gather_conservative_roots(HashMap<CellImpl*, HeapRoot>&);
+    void gather_roots(HashMap<Cell*, HeapRoot>&);
+    void gather_conservative_roots(HashMap<Cell*, HeapRoot>&);
     void gather_asan_fake_stack_roots(HashMap<FlatPtr, HeapRoot>&, FlatPtr, FlatPtr min_block_address, FlatPtr max_block_address);
-    void mark_live_cells(HashMap<CellImpl*, HeapRoot> const& live_cells);
+    void mark_live_cells(HashMap<Cell*, HeapRoot> const& live_cells);
     void finalize_unmarked_cells();
     void sweep_dead_cells(bool print_report, Core::ElapsedTimer const&);
 
@@ -134,31 +134,31 @@ private:
     Vector<NonnullOwnPtr<CellAllocator>> m_size_based_cell_allocators;
     CellAllocator::List m_all_cell_allocators;
 
-    HandleImpl::List m_handles;
+    RootImpl::List m_roots;
     MarkedVectorBase::List m_marked_vectors;
     ConservativeVectorBase::List m_conservative_vectors;
     WeakContainer::List m_weak_containers;
 
-    Vector<GCPtr<CellImpl>> m_uprooted_cells;
+    Vector<Ptr<Cell>> m_uprooted_cells;
 
     size_t m_gc_deferrals { 0 };
     bool m_should_gc_when_deferral_ends { false };
 
     bool m_collecting_garbage { false };
     StackInfo m_stack_info;
-    Function<void(HashMap<CellImpl*, JS::HeapRoot>&)> m_gather_embedder_roots;
+    AK::Function<void(HashMap<Cell*, GC::HeapRoot>&)> m_gather_embedder_roots;
 };
 
-inline void Heap::did_create_handle(Badge<HandleImpl>, HandleImpl& impl)
+inline void Heap::did_create_root(Badge<RootImpl>, RootImpl& impl)
 {
-    VERIFY(!m_handles.contains(impl));
-    m_handles.append(impl);
+    VERIFY(!m_roots.contains(impl));
+    m_roots.append(impl);
 }
 
-inline void Heap::did_destroy_handle(Badge<HandleImpl>, HandleImpl& impl)
+inline void Heap::did_destroy_root(Badge<RootImpl>, RootImpl& impl)
 {
-    VERIFY(m_handles.contains(impl));
-    m_handles.remove(impl);
+    VERIFY(m_roots.contains(impl));
+    m_roots.remove(impl);
 }
 
 inline void Heap::did_create_marked_vector(Badge<MarkedVectorBase>, MarkedVectorBase& vector)
diff --git a/Libraries/LibJS/Heap/HeapBlock.cpp b/Libraries/LibGC/HeapBlock.cpp
similarity index 89%
rename from Libraries/LibJS/Heap/HeapBlock.cpp
rename to Libraries/LibGC/HeapBlock.cpp
index f7587cc04ea..61373dc48ea 100644
--- a/Libraries/LibJS/Heap/HeapBlock.cpp
+++ b/Libraries/LibGC/HeapBlock.cpp
@@ -7,8 +7,8 @@
 #include <AK/Assertions.h>
 #include <AK/NonnullOwnPtr.h>
 #include <AK/Platform.h>
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/HeapBlock.h>
+#include <LibGC/Heap.h>
+#include <LibGC/HeapBlock.h>
 #include <stdio.h>
 #include <sys/mman.h>
 
@@ -16,7 +16,7 @@
 #    include <sanitizer/asan_interface.h>
 #endif
 
-namespace JS {
+namespace GC {
 
 size_t HeapBlockBase::block_size = PAGE_SIZE;
 
@@ -37,16 +37,16 @@ HeapBlock::HeapBlock(Heap& heap, CellAllocator& cell_allocator, size_t cell_size
     ASAN_POISON_MEMORY_REGION(m_storage, block_size - sizeof(HeapBlock));
 }
 
-void HeapBlock::deallocate(CellImpl* cell)
+void HeapBlock::deallocate(Cell* cell)
 {
     VERIFY(is_valid_cell_pointer(cell));
     VERIFY(!m_freelist || is_valid_cell_pointer(m_freelist));
-    VERIFY(cell->state() == CellImpl::State::Live);
+    VERIFY(cell->state() == Cell::State::Live);
     VERIFY(!cell->is_marked());
 
-    cell->~CellImpl();
+    cell->~Cell();
     auto* freelist_entry = new (cell) FreelistEntry();
-    freelist_entry->set_state(CellImpl::State::Dead);
+    freelist_entry->set_state(Cell::State::Dead);
     freelist_entry->next = m_freelist;
     m_freelist = freelist_entry;
 
diff --git a/Libraries/LibJS/Heap/HeapBlock.h b/Libraries/LibGC/HeapBlock.h
similarity index 79%
rename from Libraries/LibJS/Heap/HeapBlock.h
rename to Libraries/LibGC/HeapBlock.h
index 44d1c89e682..17afadeb73b 100644
--- a/Libraries/LibJS/Heap/HeapBlock.h
+++ b/Libraries/LibGC/HeapBlock.h
@@ -10,15 +10,15 @@
 #include <AK/Platform.h>
 #include <AK/StringView.h>
 #include <AK/Types.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/Internals.h>
+#include <LibGC/Cell.h>
+#include <LibGC/Forward.h>
+#include <LibGC/Internals.h>
 
 #ifdef HAS_ADDRESS_SANITIZER
 #    include <sanitizer/asan_interface.h>
 #endif
 
-namespace JS {
+namespace GC {
 
 class HeapBlock : public HeapBlockBase {
     AK_MAKE_NONCOPYABLE(HeapBlock);
@@ -32,9 +32,9 @@ public:
     size_t cell_count() const { return (block_size - sizeof(HeapBlock)) / m_cell_size; }
     bool is_full() const { return !has_lazy_freelist() && !m_freelist; }
 
-    ALWAYS_INLINE CellImpl* allocate()
+    ALWAYS_INLINE Cell* allocate()
     {
-        CellImpl* allocated_cell = nullptr;
+        Cell* allocated_cell = nullptr;
         if (m_freelist) {
             VERIFY(is_valid_cell_pointer(m_freelist));
             allocated_cell = exchange(m_freelist, m_freelist->next);
@@ -48,7 +48,7 @@ public:
         return allocated_cell;
     }
 
-    void deallocate(CellImpl*);
+    void deallocate(Cell*);
 
     template<typename Callback>
     void for_each_cell(Callback callback)
@@ -58,7 +58,7 @@ public:
             callback(cell(i));
     }
 
-    template<CellImpl::State state, typename Callback>
+    template<Cell::State state, typename Callback>
     void for_each_cell_in_state(Callback callback)
     {
         for_each_cell([&](auto* cell) {
@@ -67,12 +67,12 @@ public:
         });
     }
 
-    static HeapBlock* from_cell(CellImpl const* cell)
+    static HeapBlock* from_cell(Cell const* cell)
     {
         return static_cast<HeapBlock*>(HeapBlockBase::from_cell(cell));
     }
 
-    CellImpl* cell_from_possible_pointer(FlatPtr pointer)
+    Cell* cell_from_possible_pointer(FlatPtr pointer)
     {
         if (pointer < reinterpret_cast<FlatPtr>(m_storage))
             return nullptr;
@@ -83,7 +83,7 @@ public:
         return cell(cell_index);
     }
 
-    bool is_valid_cell_pointer(CellImpl const* cell)
+    bool is_valid_cell_pointer(Cell const* cell)
     {
         return cell_from_possible_pointer((FlatPtr)cell);
     }
@@ -97,21 +97,21 @@ private:
 
     bool has_lazy_freelist() const { return m_next_lazy_freelist_index < cell_count(); }
 
-    struct FreelistEntry final : public CellImpl {
-        JS_CELL(FreelistEntry, CellImpl);
+    struct FreelistEntry final : public Cell {
+        GC_CELL(FreelistEntry, Cell);
 
-        RawGCPtr<FreelistEntry> next;
+        RawPtr<FreelistEntry> next;
     };
 
-    CellImpl* cell(size_t index)
+    Cell* cell(size_t index)
     {
-        return reinterpret_cast<CellImpl*>(&m_storage[index * cell_size()]);
+        return reinterpret_cast<Cell*>(&m_storage[index * cell_size()]);
     }
 
     CellAllocator& m_cell_allocator;
     size_t m_cell_size { 0 };
     size_t m_next_lazy_freelist_index { 0 };
-    GCPtr<FreelistEntry> m_freelist;
+    Ptr<FreelistEntry> m_freelist;
     alignas(__BIGGEST_ALIGNMENT__) u8 m_storage[];
 
 public:
diff --git a/Libraries/LibJS/Heap/HeapRoot.h b/Libraries/LibGC/HeapRoot.h
similarity index 93%
rename from Libraries/LibJS/Heap/HeapRoot.h
rename to Libraries/LibGC/HeapRoot.h
index 0309062bdbc..f4205185ab5 100644
--- a/Libraries/LibJS/Heap/HeapRoot.h
+++ b/Libraries/LibGC/HeapRoot.h
@@ -8,12 +8,12 @@
 
 #include <AK/SourceLocation.h>
 
-namespace JS {
+namespace GC {
 
 struct HeapRoot {
     enum class Type {
         HeapFunctionCapturedPointer,
-        Handle,
+        Root,
         MarkedVector,
         ConservativeVector,
         RegisterPointer,
diff --git a/Libraries/LibJS/Heap/Internals.h b/Libraries/LibGC/Internals.h
similarity index 89%
rename from Libraries/LibJS/Heap/Internals.h
rename to Libraries/LibGC/Internals.h
index f3ec8a8ee55..234c33baf40 100644
--- a/Libraries/LibJS/Heap/Internals.h
+++ b/Libraries/LibGC/Internals.h
@@ -8,9 +8,9 @@
 #pragma once
 
 #include <AK/Types.h>
-#include <LibJS/Forward.h>
+#include <LibGC/Forward.h>
 
-namespace JS {
+namespace GC {
 
 class HeapBase {
     AK_MAKE_NONCOPYABLE(HeapBase);
@@ -34,7 +34,7 @@ class HeapBlockBase {
 
 public:
     static size_t block_size;
-    static HeapBlockBase* from_cell(CellImpl const* cell)
+    static HeapBlockBase* from_cell(Cell const* cell)
     {
         return reinterpret_cast<HeapBlockBase*>(bit_cast<FlatPtr>(cell) & ~(HeapBlockBase::block_size - 1));
     }
diff --git a/Libraries/LibJS/Heap/MarkedVector.cpp b/Libraries/LibGC/MarkedVector.cpp
similarity index 89%
rename from Libraries/LibJS/Heap/MarkedVector.cpp
rename to Libraries/LibGC/MarkedVector.cpp
index fe269181b32..e03960d3108 100644
--- a/Libraries/LibJS/Heap/MarkedVector.cpp
+++ b/Libraries/LibGC/MarkedVector.cpp
@@ -5,10 +5,10 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/Heap.h>
+#include <LibGC/MarkedVector.h>
 
-namespace JS {
+namespace GC {
 
 MarkedVectorBase::MarkedVectorBase(Heap& heap)
     : m_heap(&heap)
diff --git a/Libraries/LibJS/Heap/MarkedVector.h b/Libraries/LibGC/MarkedVector.h
similarity index 84%
rename from Libraries/LibJS/Heap/MarkedVector.h
rename to Libraries/LibGC/MarkedVector.h
index 4be1bdeafe3..b1e191a28a1 100644
--- a/Libraries/LibJS/Heap/MarkedVector.h
+++ b/Libraries/LibGC/MarkedVector.h
@@ -10,15 +10,15 @@
 #include <AK/HashMap.h>
 #include <AK/IntrusiveList.h>
 #include <AK/Vector.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/HeapRoot.h>
+#include <LibGC/Cell.h>
+#include <LibGC/Forward.h>
+#include <LibGC/HeapRoot.h>
 
-namespace JS {
+namespace GC {
 
 class MarkedVectorBase {
 public:
-    virtual void gather_roots(HashMap<CellImpl*, JS::HeapRoot>&) const = 0;
+    virtual void gather_roots(HashMap<Cell*, GC::HeapRoot>&) const = 0;
 
 protected:
     explicit MarkedVectorBase(Heap&);
@@ -65,10 +65,10 @@ public:
         return *this;
     }
 
-    virtual void gather_roots(HashMap<CellImpl*, JS::HeapRoot>& roots) const override
+    virtual void gather_roots(HashMap<Cell*, GC::HeapRoot>& roots) const override
     {
         for (auto& value : *this) {
-            if constexpr (IsSame<Value, T>) {
+            if constexpr (IsBaseOf<NanBoxedValue, T>) {
                 if (value.is_cell())
                     roots.set(&const_cast<T&>(value).as_cell(), HeapRoot { .type = HeapRoot::Type::MarkedVector });
             } else {
diff --git a/Libraries/LibJS/Heap/NanBoxedValue.h b/Libraries/LibGC/NanBoxedValue.h
similarity index 96%
rename from Libraries/LibJS/Heap/NanBoxedValue.h
rename to Libraries/LibGC/NanBoxedValue.h
index 3bf95351158..989a87efbda 100644
--- a/Libraries/LibJS/Heap/NanBoxedValue.h
+++ b/Libraries/LibGC/NanBoxedValue.h
@@ -8,8 +8,9 @@
 
 #include <AK/BitCast.h>
 #include <AK/Types.h>
+#include <LibGC/Cell.h>
 
-namespace JS {
+namespace GC {
 
 static_assert(sizeof(double) == 8);
 static_assert(sizeof(void*) == sizeof(double) || sizeof(void*) == sizeof(u32));
@@ -72,7 +73,7 @@ public:
         // For AArch64 the top 16 bits of the pointer should be zero.
         // For PPC64: all 64 bits can be used for pointers, however on Linux only
         //            the lower 43 bits are used for user-space addresses, so
-        //            masking off the top 16 bits should match the rest of LibJS.
+        //            masking off the top 16 bits should match the rest of LibGC.
         return static_cast<FlatPtr>(encoded & 0xffff'ffff'ffffULL);
 #else
 #    error "Unknown architecture. Don't know whether pointers need to be sign-extended."
@@ -86,16 +87,16 @@ public:
         return reinterpret_cast<PointerType*>(extract_pointer_bits(m_value.encoded));
     }
 
-    CellImpl& as_cell()
+    Cell& as_cell()
     {
         VERIFY(is_cell());
-        return *extract_pointer<CellImpl>();
+        return *extract_pointer<Cell>();
     }
 
-    CellImpl& as_cell() const
+    Cell& as_cell() const
     {
         VERIFY(is_cell());
-        return *extract_pointer<CellImpl>();
+        return *extract_pointer<Cell>();
     }
 
     bool is_nan() const
diff --git a/Libraries/LibJS/Heap/GCPtr.h b/Libraries/LibGC/Ptr.h
similarity index 68%
rename from Libraries/LibJS/Heap/GCPtr.h
rename to Libraries/LibGC/Ptr.h
index ebe8753f096..fcbbb4b7586 100644
--- a/Libraries/LibJS/Heap/GCPtr.h
+++ b/Libraries/LibGC/Ptr.h
@@ -9,51 +9,51 @@
 #include <AK/Traits.h>
 #include <AK/Types.h>
 
-namespace JS {
+namespace GC {
 
 template<typename T>
-class GCPtr;
+class Ptr;
 
 template<typename T>
-class NonnullGCPtr {
+class Ref {
 public:
-    NonnullGCPtr() = delete;
+    Ref() = delete;
 
-    NonnullGCPtr(T& ptr)
+    Ref(T& ptr)
         : m_ptr(&ptr)
     {
     }
 
     template<typename U>
-    NonnullGCPtr(U& ptr)
+    Ref(U& ptr)
     requires(IsConvertible<U*, T*>)
         : m_ptr(&static_cast<T&>(ptr))
     {
     }
 
     template<typename U>
-    NonnullGCPtr(NonnullGCPtr<U> const& other)
+    Ref(Ref<U> const& other)
     requires(IsConvertible<U*, T*>)
         : m_ptr(other.ptr())
     {
     }
 
     template<typename U>
-    NonnullGCPtr& operator=(NonnullGCPtr<U> const& other)
+    Ref& operator=(Ref<U> const& other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = static_cast<T*>(other.ptr());
         return *this;
     }
 
-    NonnullGCPtr& operator=(T& other)
+    Ref& operator=(T& other)
     {
         m_ptr = &other;
         return *this;
     }
 
     template<typename U>
-    NonnullGCPtr& operator=(U& other)
+    Ref& operator=(U& other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = &static_cast<T&>(other);
@@ -75,88 +75,88 @@ private:
 };
 
 template<typename T>
-class GCPtr {
+class Ptr {
 public:
-    constexpr GCPtr() = default;
+    constexpr Ptr() = default;
 
-    GCPtr(T& ptr)
+    Ptr(T& ptr)
         : m_ptr(&ptr)
     {
     }
 
-    GCPtr(T* ptr)
+    Ptr(T* ptr)
         : m_ptr(ptr)
     {
     }
 
     template<typename U>
-    GCPtr(GCPtr<U> const& other)
+    Ptr(Ptr<U> const& other)
     requires(IsConvertible<U*, T*>)
         : m_ptr(other.ptr())
     {
     }
 
-    GCPtr(NonnullGCPtr<T> const& other)
+    Ptr(Ref<T> const& other)
         : m_ptr(other.ptr())
     {
     }
 
     template<typename U>
-    GCPtr(NonnullGCPtr<U> const& other)
+    Ptr(Ref<U> const& other)
     requires(IsConvertible<U*, T*>)
         : m_ptr(other.ptr())
     {
     }
 
-    GCPtr(nullptr_t)
+    Ptr(nullptr_t)
         : m_ptr(nullptr)
     {
     }
 
     template<typename U>
-    GCPtr& operator=(GCPtr<U> const& other)
+    Ptr& operator=(Ptr<U> const& other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = static_cast<T*>(other.ptr());
         return *this;
     }
 
-    GCPtr& operator=(NonnullGCPtr<T> const& other)
+    Ptr& operator=(Ref<T> const& other)
     {
         m_ptr = other.ptr();
         return *this;
     }
 
     template<typename U>
-    GCPtr& operator=(NonnullGCPtr<U> const& other)
+    Ptr& operator=(Ref<U> const& other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = static_cast<T*>(other.ptr());
         return *this;
     }
 
-    GCPtr& operator=(T& other)
+    Ptr& operator=(T& other)
     {
         m_ptr = &other;
         return *this;
     }
 
     template<typename U>
-    GCPtr& operator=(U& other)
+    Ptr& operator=(U& other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = &static_cast<T&>(other);
         return *this;
     }
 
-    GCPtr& operator=(T* other)
+    Ptr& operator=(T* other)
     {
         m_ptr = other;
         return *this;
     }
 
     template<typename U>
-    GCPtr& operator=(U* other)
+    Ptr& operator=(U* other)
     requires(IsConvertible<U*, T*>)
     {
         m_ptr = static_cast<T*>(other);
@@ -186,34 +186,34 @@ private:
     T* m_ptr { nullptr };
 };
 
-// Non-Owning GCPtr
+// Non-Owning GC::Ptr
 template<typename T>
-using RawGCPtr = GCPtr<T>;
+using RawPtr = Ptr<T>;
 
-// Non-Owning NonnullGCPtr
+// Non-Owning Ref
 template<typename T>
-using RawNonnullGCPtr = NonnullGCPtr<T>;
+using RawRef = Ref<T>;
 
 template<typename T, typename U>
-inline bool operator==(GCPtr<T> const& a, GCPtr<U> const& b)
+inline bool operator==(Ptr<T> const& a, Ptr<U> const& b)
 {
     return a.ptr() == b.ptr();
 }
 
 template<typename T, typename U>
-inline bool operator==(GCPtr<T> const& a, NonnullGCPtr<U> const& b)
+inline bool operator==(Ptr<T> const& a, Ref<U> const& b)
 {
     return a.ptr() == b.ptr();
 }
 
 template<typename T, typename U>
-inline bool operator==(NonnullGCPtr<T> const& a, NonnullGCPtr<U> const& b)
+inline bool operator==(Ref<T> const& a, Ref<U> const& b)
 {
     return a.ptr() == b.ptr();
 }
 
 template<typename T, typename U>
-inline bool operator==(NonnullGCPtr<T> const& a, GCPtr<U> const& b)
+inline bool operator==(Ref<T> const& a, Ptr<U> const& b)
 {
     return a.ptr() == b.ptr();
 }
@@ -223,16 +223,16 @@ inline bool operator==(NonnullGCPtr<T> const& a, GCPtr<U> const& b)
 namespace AK {
 
 template<typename T>
-struct Traits<JS::GCPtr<T>> : public DefaultTraits<JS::GCPtr<T>> {
-    static unsigned hash(JS::GCPtr<T> const& value)
+struct Traits<GC::Ptr<T>> : public DefaultTraits<GC::Ptr<T>> {
+    static unsigned hash(GC::Ptr<T> const& value)
     {
         return Traits<T*>::hash(value.ptr());
     }
 };
 
 template<typename T>
-struct Traits<JS::NonnullGCPtr<T>> : public DefaultTraits<JS::NonnullGCPtr<T>> {
-    static unsigned hash(JS::NonnullGCPtr<T> const& value)
+struct Traits<GC::Ref<T>> : public DefaultTraits<GC::Ref<T>> {
+    static unsigned hash(GC::Ref<T> const& value)
     {
         return Traits<T*>::hash(value.ptr());
     }
diff --git a/Libraries/LibGC/Root.cpp b/Libraries/LibGC/Root.cpp
new file mode 100644
index 00000000000..48890e80edb
--- /dev/null
+++ b/Libraries/LibGC/Root.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibGC/Cell.h>
+#include <LibGC/Heap.h>
+#include <LibGC/Root.h>
+
+namespace GC {
+
+RootImpl::RootImpl(Cell* cell, SourceLocation location)
+    : m_cell(cell)
+    , m_location(location)
+{
+    m_cell->heap().did_create_root({}, *this);
+}
+
+RootImpl::~RootImpl()
+{
+    m_cell->heap().did_destroy_root({}, *this);
+}
+
+}
diff --git a/Libraries/LibGC/Root.h b/Libraries/LibGC/Root.h
new file mode 100644
index 00000000000..e814ffe2910
--- /dev/null
+++ b/Libraries/LibGC/Root.h
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <AK/Badge.h>
+#include <AK/IntrusiveList.h>
+#include <AK/Noncopyable.h>
+#include <AK/RefCounted.h>
+#include <AK/RefPtr.h>
+#include <AK/SourceLocation.h>
+#include <LibGC/Forward.h>
+#include <LibGC/Ptr.h>
+
+namespace GC {
+
+class RootImpl : public RefCounted<RootImpl> {
+    AK_MAKE_NONCOPYABLE(RootImpl);
+    AK_MAKE_NONMOVABLE(RootImpl);
+
+public:
+    ~RootImpl();
+
+    Cell* cell() { return m_cell; }
+    Cell const* cell() const { return m_cell; }
+
+    SourceLocation const& source_location() const { return m_location; }
+
+private:
+    template<class T>
+    friend class Root;
+
+    explicit RootImpl(Cell*, SourceLocation location);
+    Ptr<Cell> m_cell;
+    SourceLocation m_location;
+
+    IntrusiveListNode<RootImpl> m_list_node;
+
+public:
+    using List = IntrusiveList<&RootImpl::m_list_node>;
+};
+
+template<class T>
+class Root {
+public:
+    Root() = default;
+
+    static Root create(T* cell, SourceLocation location = SourceLocation::current())
+    {
+        return Root(adopt_ref(*new RootImpl(const_cast<RemoveConst<T>*>(cell), location)));
+    }
+
+    Root(T* cell, SourceLocation location = SourceLocation::current())
+    {
+        if (cell)
+            m_impl = adopt_ref(*new RootImpl(cell, location));
+    }
+
+    Root(T& cell, SourceLocation location = SourceLocation::current())
+        : m_impl(adopt_ref(*new RootImpl(&cell, location)))
+    {
+    }
+
+    Root(Ptr<T> cell, SourceLocation location = SourceLocation::current())
+        : Root(cell.ptr(), location)
+    {
+    }
+
+    Root(Ref<T> cell, SourceLocation location = SourceLocation::current())
+        : Root(*cell, location)
+    {
+    }
+
+    T* cell() const
+    {
+        if (!m_impl)
+            return nullptr;
+        return static_cast<T*>(m_impl->cell());
+    }
+
+    T* ptr() const
+    {
+        return cell();
+    }
+
+    bool is_null() const
+    {
+        return m_impl.is_null();
+    }
+
+    T* operator->() const
+    {
+        return cell();
+    }
+
+    [[nodiscard]] T& operator*() const
+    {
+        return *cell();
+    }
+
+    bool operator!() const
+    {
+        return !cell();
+    }
+    operator bool() const
+    {
+        return cell();
+    }
+
+    operator T*() const { return cell(); }
+
+private:
+    explicit Root(NonnullRefPtr<RootImpl> impl)
+        : m_impl(move(impl))
+    {
+    }
+
+    RefPtr<RootImpl> m_impl;
+};
+
+template<class T>
+inline Root<T> make_root(T* cell, SourceLocation location = SourceLocation::current())
+{
+    if (!cell)
+        return Root<T> {};
+    return Root<T>::create(cell, location);
+}
+
+template<class T>
+inline Root<T> make_root(T& cell, SourceLocation location = SourceLocation::current())
+{
+    return Root<T>::create(&cell, location);
+}
+
+template<class T>
+inline Root<T> make_root(Ptr<T> cell, SourceLocation location = SourceLocation::current())
+{
+    if (!cell)
+        return Root<T> {};
+    return Root<T>::create(cell.ptr(), location);
+}
+
+template<class T>
+inline Root<T> make_root(Ref<T> cell, SourceLocation location = SourceLocation::current())
+{
+    return Root<T>::create(cell.ptr(), location);
+}
+
+}
+
+namespace AK {
+
+template<typename T>
+struct Traits<GC::Root<T>> : public DefaultTraits<GC::Root<T>> {
+    static unsigned hash(GC::Root<T> const& handle) { return Traits<T>::hash(handle); }
+};
+
+namespace Detail {
+template<typename T>
+inline constexpr bool IsHashCompatible<GC::Root<T>, T> = true;
+
+template<typename T>
+inline constexpr bool IsHashCompatible<T, GC::Root<T>> = true;
+
+}
+}
diff --git a/Libraries/LibJS/Heap/WeakContainer.cpp b/Libraries/LibGC/WeakContainer.cpp
similarity index 84%
rename from Libraries/LibJS/Heap/WeakContainer.cpp
rename to Libraries/LibGC/WeakContainer.cpp
index b84cdf39713..86f74ba8fe1 100644
--- a/Libraries/LibJS/Heap/WeakContainer.cpp
+++ b/Libraries/LibGC/WeakContainer.cpp
@@ -4,10 +4,10 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/Heap.h>
+#include <LibGC/WeakContainer.h>
 
-namespace JS {
+namespace GC {
 
 WeakContainer::WeakContainer(Heap& heap)
     : m_heap(heap)
diff --git a/Libraries/LibJS/Heap/WeakContainer.h b/Libraries/LibGC/WeakContainer.h
similarity index 92%
rename from Libraries/LibJS/Heap/WeakContainer.h
rename to Libraries/LibGC/WeakContainer.h
index 81169984dc9..e2b47d50ec2 100644
--- a/Libraries/LibJS/Heap/WeakContainer.h
+++ b/Libraries/LibGC/WeakContainer.h
@@ -7,9 +7,9 @@
 #pragma once
 
 #include <AK/IntrusiveList.h>
-#include <LibJS/Forward.h>
+#include <LibGC/Forward.h>
 
-namespace JS {
+namespace GC {
 
 class WeakContainer {
 public:
diff --git a/Libraries/LibJS/AST.cpp b/Libraries/LibJS/AST.cpp
index 9ed24d38bc4..6764b1ac872 100644
--- a/Libraries/LibJS/AST.cpp
+++ b/Libraries/LibJS/AST.cpp
@@ -14,9 +14,9 @@
 #include <AK/StringBuilder.h>
 #include <AK/TemporaryChange.h>
 #include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibGC/ConservativeVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/AST.h>
-#include <LibJS/Heap/ConservativeVector.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibJS/Runtime/AbstractOperations.h>
 #include <LibJS/Runtime/Accessor.h>
 #include <LibJS/Runtime/Array.h>
@@ -97,7 +97,7 @@ Value FunctionExpression::instantiate_ordinary_function_expression(VM& vm, Depre
     auto has_own_name = !name().is_empty();
 
     auto const used_name = has_own_name ? name() : given_name.view();
-    auto environment = NonnullGCPtr { *vm.running_execution_context().lexical_environment };
+    auto environment = GC::Ref { *vm.running_execution_context().lexical_environment };
     if (has_own_name) {
         VERIFY(environment);
         environment = new_declarative_environment(*environment);
@@ -227,7 +227,7 @@ ThrowCompletionOr<ClassElement::ClassValue> ClassField::class_element_evaluation
     auto& realm = *vm.current_realm();
 
     auto property_key_or_private_name = TRY(class_key_to_property_name(vm, *m_key, property_key));
-    GCPtr<ECMAScriptFunctionObject> initializer;
+    GC::Ptr<ECMAScriptFunctionObject> initializer;
     if (m_initializer) {
         auto copy_initializer = m_initializer;
         auto name = property_key_or_private_name.visit(
@@ -310,7 +310,7 @@ ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::create_class_const
 
     vm.running_execution_context().lexical_environment = class_environment;
 
-    auto proto_parent = GCPtr { realm.intrinsics().object_prototype() };
+    auto proto_parent = GC::Ptr { realm.intrinsics().object_prototype() };
     auto constructor_parent = realm.intrinsics().function_prototype();
 
     if (!m_super_class.is_null()) {
@@ -366,12 +366,12 @@ ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::create_class_const
 
     prototype->define_direct_property(vm.names.constructor, class_constructor, Attribute::Writable | Attribute::Configurable);
 
-    using StaticElement = Variant<ClassFieldDefinition, JS::NonnullGCPtr<ECMAScriptFunctionObject>>;
+    using StaticElement = Variant<ClassFieldDefinition, GC::Ref<ECMAScriptFunctionObject>>;
 
-    ConservativeVector<PrivateElement> static_private_methods(vm.heap());
-    ConservativeVector<PrivateElement> instance_private_methods(vm.heap());
-    ConservativeVector<ClassFieldDefinition> instance_fields(vm.heap());
-    ConservativeVector<StaticElement> static_elements(vm.heap());
+    GC::ConservativeVector<PrivateElement> static_private_methods(vm.heap());
+    GC::ConservativeVector<PrivateElement> instance_private_methods(vm.heap());
+    GC::ConservativeVector<ClassFieldDefinition> instance_fields(vm.heap());
+    GC::ConservativeVector<StaticElement> static_elements(vm.heap());
 
     for (size_t element_index = 0; element_index < m_elements.size(); element_index++) {
         auto const& element = m_elements[element_index];
@@ -411,7 +411,7 @@ ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::create_class_const
             VERIFY(element_value.has<Completion>() && element_value.get<Completion>().value().has_value());
             auto& element_object = element_value.get<Completion>().value()->as_object();
             VERIFY(is<ECMAScriptFunctionObject>(element_object));
-            static_elements.append(NonnullGCPtr { static_cast<ECMAScriptFunctionObject&>(element_object) });
+            static_elements.append(GC::Ref { static_cast<ECMAScriptFunctionObject&>(element_object) });
         }
     }
 
@@ -435,7 +435,7 @@ ThrowCompletionOr<ECMAScriptFunctionObject*> ClassExpression::create_class_const
             [&](ClassFieldDefinition& field) -> ThrowCompletionOr<void> {
                 return TRY(class_constructor->define_field(field));
             },
-            [&](Handle<ECMAScriptFunctionObject> static_block_function) -> ThrowCompletionOr<void> {
+            [&](GC::Root<ECMAScriptFunctionObject> static_block_function) -> ThrowCompletionOr<void> {
                 VERIFY(!static_block_function.is_null());
                 // We discard any value returned here.
                 TRY(call(vm, *static_block_function.cell(), class_constructor));
diff --git a/Libraries/LibJS/AST.h b/Libraries/LibJS/AST.h
index 3c59145c922..dec69d2ec59 100644
--- a/Libraries/LibJS/AST.h
+++ b/Libraries/LibJS/AST.h
@@ -15,6 +15,7 @@
 #include <AK/RefPtr.h>
 #include <AK/Variant.h>
 #include <AK/Vector.h>
+#include <LibGC/Root.h>
 #include <LibJS/Bytecode/CodeGenerationError.h>
 #include <LibJS/Bytecode/Executable.h>
 #include <LibJS/Bytecode/IdentifierTable.h>
@@ -22,7 +23,6 @@
 #include <LibJS/Bytecode/Operand.h>
 #include <LibJS/Bytecode/ScopedOperand.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibJS/Runtime/ClassFieldDefinition.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/EnvironmentCoordinate.h>
@@ -160,10 +160,10 @@ public:
     }
 
     Bytecode::Executable* bytecode_executable() const { return m_bytecode_executable; }
-    void set_bytecode_executable(Bytecode::Executable* bytecode_executable) { m_bytecode_executable = make_handle(bytecode_executable); }
+    void set_bytecode_executable(Bytecode::Executable* bytecode_executable) { m_bytecode_executable = make_root(bytecode_executable); }
 
 private:
-    Handle<Bytecode::Executable> m_bytecode_executable;
+    GC::Root<Bytecode::Executable> m_bytecode_executable;
 };
 
 // 14.13 Labelled Statements, https://tc39.es/ecma262/#sec-labelled-statements
@@ -690,7 +690,7 @@ struct FunctionParameter {
     Variant<NonnullRefPtr<Identifier const>, NonnullRefPtr<BindingPattern const>> binding;
     RefPtr<Expression const> default_value;
     bool is_rest { false };
-    Handle<Bytecode::Executable> bytecode_executable {};
+    GC::Root<Bytecode::Executable> bytecode_executable {};
 };
 
 struct FunctionParsingInsights {
diff --git a/Libraries/LibJS/Bytecode/BasicBlock.h b/Libraries/LibJS/Bytecode/BasicBlock.h
index d28f112aaa7..d9e0ff4bf87 100644
--- a/Libraries/LibJS/Bytecode/BasicBlock.h
+++ b/Libraries/LibJS/Bytecode/BasicBlock.h
@@ -8,16 +8,16 @@
 
 #include <AK/Badge.h>
 #include <AK/String.h>
+#include <LibGC/Root.h>
 #include <LibJS/Bytecode/Executable.h>
 #include <LibJS/Bytecode/ScopedOperand.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 
 namespace JS::Bytecode {
 
 struct UnwindInfo {
-    JS::GCPtr<Executable const> executable;
-    JS::GCPtr<Environment> lexical_environment;
+    GC::Ptr<Executable const> executable;
+    GC::Ptr<Environment> lexical_environment;
 
     bool handler_called { false };
 };
diff --git a/Libraries/LibJS/Bytecode/Executable.cpp b/Libraries/LibJS/Bytecode/Executable.cpp
index 959a5ffe240..e012256418f 100644
--- a/Libraries/LibJS/Bytecode/Executable.cpp
+++ b/Libraries/LibJS/Bytecode/Executable.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Bytecode {
 
-JS_DEFINE_ALLOCATOR(Executable);
+GC_DEFINE_ALLOCATOR(Executable);
 
 Executable::Executable(
     Vector<u8> bytecode,
diff --git a/Libraries/LibJS/Bytecode/Executable.h b/Libraries/LibJS/Bytecode/Executable.h
index 7eb1b168bc4..499506809d8 100644
--- a/Libraries/LibJS/Bytecode/Executable.h
+++ b/Libraries/LibJS/Bytecode/Executable.h
@@ -11,12 +11,12 @@
 #include <AK/NonnullOwnPtr.h>
 #include <AK/OwnPtr.h>
 #include <AK/WeakPtr.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Bytecode/IdentifierTable.h>
 #include <LibJS/Bytecode/Label.h>
 #include <LibJS/Bytecode/StringTable.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibJS/Runtime/EnvironmentCoordinate.h>
 #include <LibJS/SourceRange.h>
 
@@ -40,8 +40,8 @@ struct SourceRecord {
 };
 
 class Executable final : public Cell {
-    JS_CELL(Executable, Cell);
-    JS_DECLARE_ALLOCATOR(Executable);
+    GC_CELL(Executable, Cell);
+    GC_DECLARE_ALLOCATOR(Executable);
 
 public:
     Executable(
diff --git a/Libraries/LibJS/Bytecode/Generator.cpp b/Libraries/LibJS/Bytecode/Generator.cpp
index 7ae318c1e1d..f4c99673a1c 100644
--- a/Libraries/LibJS/Bytecode/Generator.cpp
+++ b/Libraries/LibJS/Bytecode/Generator.cpp
@@ -17,7 +17,7 @@
 
 namespace JS::Bytecode {
 
-Generator::Generator(VM& vm, GCPtr<ECMAScriptFunctionObject const> function, MustPropagateCompletion must_propagate_completion)
+Generator::Generator(VM& vm, GC::Ptr<ECMAScriptFunctionObject const> function, MustPropagateCompletion must_propagate_completion)
     : m_vm(vm)
     , m_string_table(make<StringTable>())
     , m_identifier_table(make<IdentifierTable>())
@@ -199,7 +199,7 @@ CodeGenerationErrorOr<void> Generator::emit_function_declaration_instantiation(E
     return {};
 }
 
-CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::compile(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind, GCPtr<ECMAScriptFunctionObject const> function, MustPropagateCompletion must_propagate_completion, Vector<DeprecatedFlyString> local_variable_names)
+CodeGenerationErrorOr<GC::Ref<Executable>> Generator::compile(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind, GC::Ptr<ECMAScriptFunctionObject const> function, MustPropagateCompletion must_propagate_completion, Vector<DeprecatedFlyString> local_variable_names)
 {
     Generator generator(vm, function, must_propagate_completion);
 
@@ -460,7 +460,7 @@ CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::compile(VM& vm, ASTNo
     return executable;
 }
 
-CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::generate_from_ast_node(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind)
+CodeGenerationErrorOr<GC::Ref<Executable>> Generator::generate_from_ast_node(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind)
 {
     Vector<DeprecatedFlyString> local_variable_names;
     if (is<ScopeNode>(node))
@@ -468,7 +468,7 @@ CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::generate_from_ast_nod
     return compile(vm, node, enclosing_function_kind, {}, MustPropagateCompletion::Yes, move(local_variable_names));
 }
 
-CodeGenerationErrorOr<NonnullGCPtr<Executable>> Generator::generate_from_function(VM& vm, ECMAScriptFunctionObject const& function)
+CodeGenerationErrorOr<GC::Ref<Executable>> Generator::generate_from_function(VM& vm, ECMAScriptFunctionObject const& function)
 {
     return compile(vm, function.ecmascript_code(), function.kind(), &function, MustPropagateCompletion::No, function.local_variables_names());
 }
diff --git a/Libraries/LibJS/Bytecode/Generator.h b/Libraries/LibJS/Bytecode/Generator.h
index c934a42d364..bb496898914 100644
--- a/Libraries/LibJS/Bytecode/Generator.h
+++ b/Libraries/LibJS/Bytecode/Generator.h
@@ -38,8 +38,8 @@ public:
         Yes,
     };
 
-    static CodeGenerationErrorOr<NonnullGCPtr<Executable>> generate_from_ast_node(VM&, ASTNode const&, FunctionKind = FunctionKind::Normal);
-    static CodeGenerationErrorOr<NonnullGCPtr<Executable>> generate_from_function(VM&, ECMAScriptFunctionObject const& function);
+    static CodeGenerationErrorOr<GC::Ref<Executable>> generate_from_ast_node(VM&, ASTNode const&, FunctionKind = FunctionKind::Normal);
+    static CodeGenerationErrorOr<GC::Ref<Executable>> generate_from_function(VM&, ECMAScriptFunctionObject const& function);
 
     CodeGenerationErrorOr<void> emit_function_declaration_instantiation(ECMAScriptFunctionObject const& function);
 
@@ -343,7 +343,7 @@ public:
 private:
     VM& m_vm;
 
-    static CodeGenerationErrorOr<NonnullGCPtr<Executable>> compile(VM&, ASTNode const&, FunctionKind, GCPtr<ECMAScriptFunctionObject const>, MustPropagateCompletion, Vector<DeprecatedFlyString> local_variable_names);
+    static CodeGenerationErrorOr<GC::Ref<Executable>> compile(VM&, ASTNode const&, FunctionKind, GC::Ptr<ECMAScriptFunctionObject const>, MustPropagateCompletion, Vector<DeprecatedFlyString> local_variable_names);
 
     enum class JumpType {
         Continue,
@@ -352,7 +352,7 @@ private:
     void generate_scoped_jump(JumpType);
     void generate_labelled_jump(JumpType, DeprecatedFlyString const& label);
 
-    Generator(VM&, GCPtr<ECMAScriptFunctionObject const>, MustPropagateCompletion);
+    Generator(VM&, GC::Ptr<ECMAScriptFunctionObject const>, MustPropagateCompletion);
     ~Generator() = default;
 
     void grow(size_t);
@@ -373,7 +373,7 @@ private:
     NonnullOwnPtr<StringTable> m_string_table;
     NonnullOwnPtr<IdentifierTable> m_identifier_table;
     NonnullOwnPtr<RegexTable> m_regex_table;
-    MarkedVector<Value> m_constants;
+    GC::MarkedVector<Value> m_constants;
 
     mutable Optional<ScopedOperand> m_true_constant;
     mutable Optional<ScopedOperand> m_false_constant;
@@ -401,7 +401,7 @@ private:
     bool m_finished { false };
     bool m_must_propagate_completion { true };
 
-    GCPtr<ECMAScriptFunctionObject const> m_function;
+    GC::Ptr<ECMAScriptFunctionObject const> m_function;
 
     Optional<IdentifierTableIndex> m_length_identifier;
 };
diff --git a/Libraries/LibJS/Bytecode/Instruction.h b/Libraries/LibJS/Bytecode/Instruction.h
index 26a55d75247..2a557064d1f 100644
--- a/Libraries/LibJS/Bytecode/Instruction.h
+++ b/Libraries/LibJS/Bytecode/Instruction.h
@@ -213,7 +213,7 @@ private:
     u8 const* m_begin { nullptr };
     u8 const* m_end { nullptr };
     u8 const* m_ptr { nullptr };
-    GCPtr<Executable const> m_executable;
+    GC::Ptr<Executable const> m_executable;
 };
 
 }
diff --git a/Libraries/LibJS/Bytecode/Interpreter.cpp b/Libraries/LibJS/Bytecode/Interpreter.cpp
index ff3d2304f5e..b93a73dd387 100644
--- a/Libraries/LibJS/Bytecode/Interpreter.cpp
+++ b/Libraries/LibJS/Bytecode/Interpreter.cpp
@@ -182,7 +182,7 @@ ALWAYS_INLINE Value Interpreter::do_yield(Value value, Optional<Label> continuat
 }
 
 // 16.1.6 ScriptEvaluation ( scriptRecord ), https://tc39.es/ecma262/#sec-runtime-semantics-scriptevaluation
-ThrowCompletionOr<Value> Interpreter::run(Script& script_record, JS::GCPtr<Environment> lexical_environment_override)
+ThrowCompletionOr<Value> Interpreter::run(Script& script_record, GC::Ptr<Environment> lexical_environment_override)
 {
     auto& vm = this->vm();
 
@@ -199,7 +199,7 @@ ThrowCompletionOr<Value> Interpreter::run(Script& script_record, JS::GCPtr<Envir
     script_context->realm = &script_record.realm();
 
     // 5. Set the ScriptOrModule of scriptContext to scriptRecord.
-    script_context->script_or_module = NonnullGCPtr<Script>(script_record);
+    script_context->script_or_module = GC::Ref<Script>(script_record);
 
     // 6. Set the VariableEnvironment of scriptContext to globalEnv.
     script_context->variable_environment = &global_environment;
@@ -703,11 +703,11 @@ Interpreter::ResultAndReturnRegister Interpreter::run_executable(Executable& exe
 {
     dbgln_if(JS_BYTECODE_DEBUG, "Bytecode::Interpreter will run unit {:p}", &executable);
 
-    TemporaryChange restore_executable { m_current_executable, GCPtr { executable } };
+    TemporaryChange restore_executable { m_current_executable, GC::Ptr { executable } };
     TemporaryChange restore_saved_jump { m_scheduled_jump, Optional<size_t> {} };
-    TemporaryChange restore_realm { m_realm, GCPtr { vm().current_realm() } };
-    TemporaryChange restore_global_object { m_global_object, GCPtr { m_realm->global_object() } };
-    TemporaryChange restore_global_declarative_environment { m_global_declarative_environment, GCPtr { m_realm->global_environment().declarative_record() } };
+    TemporaryChange restore_realm { m_realm, GC::Ptr { vm().current_realm() } };
+    TemporaryChange restore_global_object { m_global_object, GC::Ptr { m_realm->global_object() } };
+    TemporaryChange restore_global_declarative_environment { m_global_declarative_environment, GC::Ptr { m_realm->global_environment().declarative_record() } };
 
     VERIFY(!vm().execution_context_stack().is_empty());
 
@@ -813,7 +813,7 @@ void Interpreter::enter_object_environment(Object& object)
     running_execution_context().lexical_environment = new_object_environment(object, true, old_environment);
 }
 
-ThrowCompletionOr<NonnullGCPtr<Bytecode::Executable>> compile(VM& vm, ASTNode const& node, FunctionKind kind, DeprecatedFlyString const& name)
+ThrowCompletionOr<GC::Ref<Bytecode::Executable>> compile(VM& vm, ASTNode const& node, FunctionKind kind, DeprecatedFlyString const& name)
 {
     auto executable_result = Bytecode::Generator::generate_from_ast_node(vm, node, kind);
     if (executable_result.is_error())
@@ -828,7 +828,7 @@ ThrowCompletionOr<NonnullGCPtr<Bytecode::Executable>> compile(VM& vm, ASTNode co
     return bytecode_executable;
 }
 
-ThrowCompletionOr<NonnullGCPtr<Bytecode::Executable>> compile(VM& vm, ECMAScriptFunctionObject const& function)
+ThrowCompletionOr<GC::Ref<Bytecode::Executable>> compile(VM& vm, ECMAScriptFunctionObject const& function)
 {
     auto const& name = function.name();
 
@@ -921,7 +921,7 @@ ALWAYS_INLINE Completion throw_null_or_undefined_property_access(VM& vm, Value b
     return vm.throw_completion<TypeError>(ErrorType::ToObjectNullOrUndefined);
 }
 
-ALWAYS_INLINE GCPtr<Object> base_object_for_get_impl(VM& vm, Value base_value)
+ALWAYS_INLINE GC::Ptr<Object> base_object_for_get_impl(VM& vm, Value base_value)
 {
     if (base_value.is_object()) [[likely]]
         return base_value.as_object();
@@ -942,19 +942,19 @@ ALWAYS_INLINE GCPtr<Object> base_object_for_get_impl(VM& vm, Value base_value)
     return nullptr;
 }
 
-ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> base_object_for_get(VM& vm, Value base_value, Optional<IdentifierTableIndex> base_identifier, IdentifierTableIndex property_identifier, Executable const& executable)
+ALWAYS_INLINE ThrowCompletionOr<GC::Ref<Object>> base_object_for_get(VM& vm, Value base_value, Optional<IdentifierTableIndex> base_identifier, IdentifierTableIndex property_identifier, Executable const& executable)
 {
     if (auto base_object = base_object_for_get_impl(vm, base_value))
-        return NonnullGCPtr { *base_object };
+        return GC::Ref { *base_object };
 
     // NOTE: At this point this is guaranteed to throw (null or undefined).
     return throw_null_or_undefined_property_get(vm, base_value, base_identifier, property_identifier, executable);
 }
 
-ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> base_object_for_get(VM& vm, Value base_value, Optional<IdentifierTableIndex> base_identifier, Value property, Executable const& executable)
+ALWAYS_INLINE ThrowCompletionOr<GC::Ref<Object>> base_object_for_get(VM& vm, Value base_value, Optional<IdentifierTableIndex> base_identifier, Value property, Executable const& executable)
 {
     if (auto base_object = base_object_for_get_impl(vm, base_value))
-        return NonnullGCPtr { *base_object };
+        return GC::Ref { *base_object };
 
     // NOTE: At this point this is guaranteed to throw (null or undefined).
     return throw_null_or_undefined_property_get(vm, base_value, base_identifier, property, executable);
@@ -1131,10 +1131,10 @@ inline ThrowCompletionOr<Value> get_global(Interpreter& interpreter, IdentifierT
 
     auto& identifier = interpreter.current_executable().get_identifier(identifier_index);
 
-    if (vm.running_execution_context().script_or_module.has<NonnullGCPtr<Module>>()) {
+    if (vm.running_execution_context().script_or_module.has<GC::Ref<Module>>()) {
         // NOTE: GetGlobal is used to access variables stored in the module environment and global environment.
         //       The module environment is checked first since it precedes the global environment in the environment chain.
-        auto& module_environment = *vm.running_execution_context().script_or_module.get<NonnullGCPtr<Module>>()->environment();
+        auto& module_environment = *vm.running_execution_context().script_or_module.get<GC::Ref<Module>>()->environment();
         if (TRY(module_environment.has_binding(identifier))) {
             // TODO: Cache offset of binding value
             return TRY(module_environment.get_binding_value(vm, identifier, vm.in_strict_mode()));
@@ -1436,13 +1436,13 @@ inline Value new_regexp(VM& vm, ParsedRegex const& parsed_regex, ByteString cons
 }
 
 // 13.3.8.1 https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
-inline MarkedVector<Value> argument_list_evaluation(VM& vm, Value arguments)
+inline GC::MarkedVector<Value> argument_list_evaluation(VM& vm, Value arguments)
 {
     // Note: Any spreading and actual evaluation is handled in preceding opcodes
     // Note: The spec uses the concept of a list, while we create a temporary array
     //       in the preceding opcodes, so we have to convert in a manner that is not
     //       visible to the user
-    MarkedVector<Value> argument_values { vm.heap() };
+    GC::MarkedVector<Value> argument_values { vm.heap() };
 
     auto& argument_array = arguments.as_array();
     auto array_length = argument_array.indexed_properties().array_like_size();
@@ -1507,7 +1507,7 @@ inline ThrowCompletionOr<ECMAScriptFunctionObject*> new_class(VM& vm, Value supe
 }
 
 // 13.3.7.1 Runtime Semantics: Evaluation, https://tc39.es/ecma262/#sec-super-keyword-runtime-semantics-evaluation
-inline ThrowCompletionOr<NonnullGCPtr<Object>> super_call_with_argument_array(VM& vm, Value argument_array, bool is_synthetic)
+inline ThrowCompletionOr<GC::Ref<Object>> super_call_with_argument_array(VM& vm, Value argument_array, bool is_synthetic)
 {
     // 1. Let newTarget be GetNewTarget().
     auto new_target = vm.get_new_target();
@@ -1519,7 +1519,7 @@ inline ThrowCompletionOr<NonnullGCPtr<Object>> super_call_with_argument_array(VM
     auto* func = get_super_constructor(vm);
 
     // 4. Let argList be ? ArgumentListEvaluation of Arguments.
-    MarkedVector<Value> arg_list { vm.heap() };
+    GC::MarkedVector<Value> arg_list { vm.heap() };
     if (is_synthetic) {
         VERIFY(argument_array.is_object() && is<Array>(argument_array.as_object()));
         auto const& array_value = static_cast<Array const&>(argument_array.as_object());
@@ -1556,7 +1556,7 @@ inline ThrowCompletionOr<NonnullGCPtr<Object>> super_call_with_argument_array(VM
     return result;
 }
 
-inline ThrowCompletionOr<NonnullGCPtr<Array>> iterator_to_array(VM& vm, Value iterator)
+inline ThrowCompletionOr<GC::Ref<Array>> iterator_to_array(VM& vm, Value iterator)
 {
     auto& iterator_record = verify_cast<IteratorRecord>(iterator.as_object());
 
@@ -1684,9 +1684,9 @@ inline ThrowCompletionOr<Object*> get_object_property_iterator(VM& vm, Value val
     //       so we just keep the order consistent anyway.
     OrderedHashTable<PropertyKey> properties;
     OrderedHashTable<PropertyKey> non_enumerable_properties;
-    HashTable<NonnullGCPtr<Object>> seen_objects;
+    HashTable<GC::Ref<Object>> seen_objects;
     // Collect all keys immediately (invariant no. 5)
-    for (auto object_to_check = GCPtr { object.ptr() }; object_to_check && !seen_objects.contains(*object_to_check); object_to_check = TRY(object_to_check->internal_get_prototype_of())) {
+    for (auto object_to_check = GC::Ptr { object.ptr() }; object_to_check && !seen_objects.contains(*object_to_check); object_to_check = TRY(object_to_check->internal_get_prototype_of())) {
         seen_objects.set(*object_to_check);
         for (auto& key : TRY(object_to_check->internal_own_property_keys())) {
             if (key.is_symbol())
@@ -2207,7 +2207,7 @@ void CreateLexicalEnvironment::execute_impl(Bytecode::Interpreter& interpreter)
     auto make_and_swap_envs = [&](auto& old_environment) {
         auto declarative_environment = new_declarative_environment(*old_environment).ptr();
         declarative_environment->ensure_capacity(m_capacity);
-        GCPtr<Environment> environment = declarative_environment;
+        GC::Ptr<Environment> environment = declarative_environment;
         swap(old_environment, environment);
         return environment;
     };
diff --git a/Libraries/LibJS/Bytecode/Interpreter.h b/Libraries/LibJS/Bytecode/Interpreter.h
index 934decc9e43..77f9b2cfe28 100644
--- a/Libraries/LibJS/Bytecode/Interpreter.h
+++ b/Libraries/LibJS/Bytecode/Interpreter.h
@@ -30,7 +30,7 @@ public:
     VM& vm() { return m_vm; }
     VM const& vm() const { return m_vm; }
 
-    ThrowCompletionOr<Value> run(Script&, JS::GCPtr<Environment> lexical_environment_override = nullptr);
+    ThrowCompletionOr<Value> run(Script&, GC::Ptr<Environment> lexical_environment_override = nullptr);
     ThrowCompletionOr<Value> run(SourceTextModule&);
 
     ThrowCompletionOr<Value> run(Bytecode::Executable& executable, Optional<size_t> entry_point = {}, Value initial_accumulator_value = {})
@@ -96,10 +96,10 @@ private:
 
     VM& m_vm;
     Optional<size_t> m_scheduled_jump;
-    GCPtr<Executable> m_current_executable { nullptr };
-    GCPtr<Realm> m_realm { nullptr };
-    GCPtr<Object> m_global_object { nullptr };
-    GCPtr<DeclarativeEnvironment> m_global_declarative_environment { nullptr };
+    GC::Ptr<Executable> m_current_executable { nullptr };
+    GC::Ptr<Realm> m_realm { nullptr };
+    GC::Ptr<Object> m_global_object { nullptr };
+    GC::Ptr<DeclarativeEnvironment> m_global_declarative_environment { nullptr };
     Optional<size_t&> m_program_counter;
     Span<Value> m_arguments;
     Span<Value> m_registers_and_constants_and_locals;
@@ -109,7 +109,7 @@ private:
 
 extern bool g_dump_bytecode;
 
-ThrowCompletionOr<NonnullGCPtr<Bytecode::Executable>> compile(VM&, ASTNode const&, JS::FunctionKind kind, DeprecatedFlyString const& name);
-ThrowCompletionOr<NonnullGCPtr<Bytecode::Executable>> compile(VM&, ECMAScriptFunctionObject const&);
+ThrowCompletionOr<GC::Ref<Bytecode::Executable>> compile(VM&, ASTNode const&, JS::FunctionKind kind, DeprecatedFlyString const& name);
+ThrowCompletionOr<GC::Ref<Bytecode::Executable>> compile(VM&, ECMAScriptFunctionObject const&);
 
 }
diff --git a/Libraries/LibJS/CMakeLists.txt b/Libraries/LibJS/CMakeLists.txt
index ede0471ca1a..0f640e14663 100644
--- a/Libraries/LibJS/CMakeLists.txt
+++ b/Libraries/LibJS/CMakeLists.txt
@@ -19,16 +19,7 @@ set(SOURCES
     Contrib/Test262/GlobalObject.cpp
     Contrib/Test262/IsHTMLDDA.cpp
     CyclicModule.cpp
-    Heap/BlockAllocator.cpp
     Heap/Cell.cpp
-    Heap/CellImpl.cpp
-    Heap/CellAllocator.cpp
-    Heap/ConservativeVector.cpp
-    Heap/Handle.cpp
-    Heap/Heap.cpp
-    Heap/HeapBlock.cpp
-    Heap/MarkedVector.cpp
-    Heap/WeakContainer.cpp
     Lexer.cpp
     MarkupGenerator.cpp
     Module.cpp
@@ -275,7 +266,7 @@ set(SOURCES
 )
 
 serenity_lib(LibJS js)
-target_link_libraries(LibJS PRIVATE LibCore LibCrypto LibFileSystem LibRegex LibSyntax)
+target_link_libraries(LibJS PRIVATE LibCore LibCrypto LibFileSystem LibRegex LibSyntax LibGC)
 
 # Link LibUnicode publicly to ensure ICU data (which is in libicudata.a) is available in any process using LibJS.
 target_link_libraries(LibJS PUBLIC LibUnicode)
diff --git a/Libraries/LibJS/Console.cpp b/Libraries/LibJS/Console.cpp
index 80fdef30c03..5c93af23b92 100644
--- a/Libraries/LibJS/Console.cpp
+++ b/Libraries/LibJS/Console.cpp
@@ -20,8 +20,8 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Console);
-JS_DEFINE_ALLOCATOR(ConsoleClient);
+GC_DEFINE_ALLOCATOR(Console);
+GC_DEFINE_ALLOCATOR(ConsoleClient);
 
 Console::Console(Realm& realm)
     : m_realm(realm)
@@ -51,7 +51,7 @@ ThrowCompletionOr<Value> Console::assert_()
     auto message = PrimitiveString::create(vm, "Assertion failed"_string);
 
     // NOTE: Assemble `data` from the function arguments.
-    MarkedVector<Value> data { vm.heap() };
+    GC::MarkedVector<Value> data { vm.heap() };
     if (vm.argument_count() > 1) {
         data.ensure_capacity(vm.argument_count() - 1);
         for (size_t i = 1; i < vm.argument_count(); ++i) {
@@ -143,7 +143,7 @@ ThrowCompletionOr<Value> Console::log()
 }
 
 // To [create table row] given tabularDataItem, rowIndex, list finalColumns, and optional list properties, perform the following steps:
-static ThrowCompletionOr<NonnullGCPtr<Object>> create_table_row(Realm& realm, Value row_index, Value tabular_data_item, MarkedVector<Value>& final_columns, HashMap<PropertyKey, bool>& visited_columns, HashMap<PropertyKey, bool>& properties)
+static ThrowCompletionOr<GC::Ref<Object>> create_table_row(Realm& realm, Value row_index, Value tabular_data_item, GC::MarkedVector<Value>& final_columns, HashMap<PropertyKey, bool>& visited_columns, HashMap<PropertyKey, bool>& properties)
 {
     auto& vm = realm.vm();
 
@@ -265,10 +265,10 @@ ThrowCompletionOr<Value> Console::table()
         }
 
         // 1. Let `finalRows` be the new list, initially empty
-        MarkedVector<Value> final_rows(vm.heap());
+        GC::MarkedVector<Value> final_rows(vm.heap());
 
         // 2. Let `finalColumns` be the new list, initially empty
-        MarkedVector<Value> final_columns(vm.heap());
+        GC::MarkedVector<Value> final_columns(vm.heap());
 
         HashMap<PropertyKey, bool> visited_columns;
 
@@ -328,7 +328,7 @@ ThrowCompletionOr<Value> Console::table()
             TRY(final_data->set(PropertyKey("columns"), table_cols, Object::ShouldThrowExceptions::No));
 
             // 5.4. Perform `Printer("table", finalData)`
-            MarkedVector<Value> args(vm.heap());
+            GC::MarkedVector<Value> args(vm.heap());
             args.append(Value(final_data));
             return m_client->printer(LogLevel::Table, args);
         }
@@ -390,7 +390,7 @@ ThrowCompletionOr<Value> Console::dir()
 
     // 2. Perform Printer("dir", « object », options).
     if (m_client) {
-        MarkedVector<Value> printer_arguments { vm.heap() };
+        GC::MarkedVector<Value> printer_arguments { vm.heap() };
         TRY_OR_THROW_OOM(vm, printer_arguments.try_append(object));
 
         return m_client->printer(LogLevel::Dir, move(printer_arguments));
@@ -430,7 +430,7 @@ ThrowCompletionOr<Value> Console::count()
     auto concat = TRY_OR_THROW_OOM(vm, String::formatted("{}: {}", label, map.get(label).value()));
 
     // 5. Perform Logger("count", « concat »).
-    MarkedVector<Value> concat_as_vector { vm.heap() };
+    GC::MarkedVector<Value> concat_as_vector { vm.heap() };
     concat_as_vector.append(PrimitiveString::create(vm, move(concat)));
     if (m_client)
         TRY(m_client->logger(LogLevel::Count, concat_as_vector));
@@ -458,7 +458,7 @@ ThrowCompletionOr<Value> Console::count_reset()
         //    that the given label does not have an associated count.
         auto message = TRY_OR_THROW_OOM(vm, String::formatted("\"{}\" doesn't have a count", label));
         // 2. Perform Logger("countReset", « message »);
-        MarkedVector<Value> message_as_vector { vm.heap() };
+        GC::MarkedVector<Value> message_as_vector { vm.heap() };
         message_as_vector.append(PrimitiveString::create(vm, move(message)));
         if (m_client)
             TRY(m_client->logger(LogLevel::CountReset, message_as_vector));
@@ -561,7 +561,7 @@ ThrowCompletionOr<Value> Console::time()
     //    a warning to the console indicating that a timer with label `label` has already been started.
     if (m_timer_table.contains(label)) {
         if (m_client) {
-            MarkedVector<Value> timer_already_exists_warning_message_as_vector { vm.heap() };
+            GC::MarkedVector<Value> timer_already_exists_warning_message_as_vector { vm.heap() };
 
             auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' already exists.", label));
             timer_already_exists_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@@ -592,7 +592,7 @@ ThrowCompletionOr<Value> Console::time_log()
     // NOTE: Warn if the timer doesn't exist. Not part of the spec yet, but discussed here: https://github.com/whatwg/console/issues/134
     if (maybe_start_time == m_timer_table.end()) {
         if (m_client) {
-            MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
+            GC::MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
 
             auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' does not exist.", label));
             timer_does_not_exist_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@@ -610,7 +610,7 @@ ThrowCompletionOr<Value> Console::time_log()
     auto concat = TRY_OR_THROW_OOM(vm, String::formatted("{}: {}", label, duration));
 
     // 5. Prepend concat to data.
-    MarkedVector<Value> data { vm.heap() };
+    GC::MarkedVector<Value> data { vm.heap() };
     data.ensure_capacity(vm.argument_count());
     data.append(PrimitiveString::create(vm, move(concat)));
     for (size_t i = 1; i < vm.argument_count(); ++i)
@@ -638,7 +638,7 @@ ThrowCompletionOr<Value> Console::time_end()
     // NOTE: Warn if the timer doesn't exist. Not part of the spec yet, but discussed here: https://github.com/whatwg/console/issues/134
     if (maybe_start_time == m_timer_table.end()) {
         if (m_client) {
-            MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
+            GC::MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
 
             auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' does not exist.", label));
             timer_does_not_exist_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@@ -660,18 +660,18 @@ ThrowCompletionOr<Value> Console::time_end()
 
     // 6. Perform Printer("timeEnd", « concat »).
     if (m_client) {
-        MarkedVector<Value> concat_as_vector { vm.heap() };
+        GC::MarkedVector<Value> concat_as_vector { vm.heap() };
         concat_as_vector.append(PrimitiveString::create(vm, move(concat)));
         TRY(m_client->printer(LogLevel::TimeEnd, move(concat_as_vector)));
     }
     return js_undefined();
 }
 
-MarkedVector<Value> Console::vm_arguments()
+GC::MarkedVector<Value> Console::vm_arguments()
 {
     auto& vm = realm().vm();
 
-    MarkedVector<Value> arguments { vm.heap() };
+    GC::MarkedVector<Value> arguments { vm.heap() };
     arguments.ensure_capacity(vm.argument_count());
     for (size_t i = 0; i < vm.argument_count(); ++i) {
         arguments.append(vm.argument(i));
@@ -709,7 +709,7 @@ void Console::report_exception(JS::Error const& exception, bool in_promise) cons
         m_client->report_exception(exception, in_promise);
 }
 
-ThrowCompletionOr<String> Console::value_vector_to_string(MarkedVector<Value> const& values)
+ThrowCompletionOr<String> Console::value_vector_to_string(GC::MarkedVector<Value> const& values)
 {
     auto& vm = realm().vm();
     StringBuilder builder;
@@ -767,7 +767,7 @@ void ConsoleClient::visit_edges(Visitor& visitor)
 }
 
 // 2.1. Logger(logLevel, args), https://console.spec.whatwg.org/#logger
-ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, MarkedVector<Value> const& args)
+ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, GC::MarkedVector<Value> const& args)
 {
     auto& vm = m_console->realm().vm();
 
@@ -783,7 +783,7 @@ ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, Mark
 
     // 4. If rest is empty, perform Printer(logLevel, « first ») and return.
     if (rest_size == 0) {
-        MarkedVector<Value> first_as_vector { vm.heap() };
+        GC::MarkedVector<Value> first_as_vector { vm.heap() };
         first_as_vector.append(first);
         return printer(log_level, move(first_as_vector));
     }
@@ -799,7 +799,7 @@ ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, Mark
 }
 
 // 2.2. Formatter(args), https://console.spec.whatwg.org/#formatter
-ThrowCompletionOr<MarkedVector<Value>> ConsoleClient::formatter(MarkedVector<Value> const& args)
+ThrowCompletionOr<GC::MarkedVector<Value>> ConsoleClient::formatter(GC::MarkedVector<Value> const& args)
 {
     auto& realm = m_console->realm();
     auto& vm = realm.vm();
@@ -901,7 +901,7 @@ ThrowCompletionOr<MarkedVector<Value>> ConsoleClient::formatter(MarkedVector<Val
     }
 
     // 7. Let result be a list containing target together with the elements of args starting from the third onward.
-    MarkedVector<Value> result { vm.heap() };
+    GC::MarkedVector<Value> result { vm.heap() };
     result.ensure_capacity(args.size() - 1);
     result.empend(PrimitiveString::create(vm, move(target)));
     for (size_t i = 2; i < args.size(); ++i)
@@ -911,7 +911,7 @@ ThrowCompletionOr<MarkedVector<Value>> ConsoleClient::formatter(MarkedVector<Val
     return formatter(result);
 }
 
-ThrowCompletionOr<String> ConsoleClient::generically_format_values(MarkedVector<Value> const& values)
+ThrowCompletionOr<String> ConsoleClient::generically_format_values(GC::MarkedVector<Value> const& values)
 {
     AllocatingMemoryStream stream;
     auto& vm = m_console->realm().vm();
diff --git a/Libraries/LibJS/Console.h b/Libraries/LibJS/Console.h
index c546b5ef3e4..a0a6c4ad6da 100644
--- a/Libraries/LibJS/Console.h
+++ b/Libraries/LibJS/Console.h
@@ -13,9 +13,9 @@
 #include <AK/String.h>
 #include <AK/Vector.h>
 #include <LibCore/ElapsedTimer.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibJS/Runtime/Value.h>
 
 namespace JS {
@@ -24,8 +24,8 @@ class ConsoleClient;
 
 // https://console.spec.whatwg.org
 class Console : public Cell {
-    JS_CELL(Console, Cell);
-    JS_DECLARE_ALLOCATOR(Console);
+    GC_CELL(Console, Cell);
+    GC_DECLARE_ALLOCATOR(Console);
 
 public:
     virtual ~Console() override;
@@ -63,7 +63,7 @@ public:
 
     Realm& realm() const { return m_realm; }
 
-    MarkedVector<Value> vm_arguments();
+    GC::MarkedVector<Value> vm_arguments();
 
     HashMap<String, unsigned>& counters() { return m_counters; }
     HashMap<String, unsigned> const& counters() const { return m_counters; }
@@ -95,11 +95,11 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    ThrowCompletionOr<String> value_vector_to_string(MarkedVector<Value> const&);
+    ThrowCompletionOr<String> value_vector_to_string(GC::MarkedVector<Value> const&);
     ThrowCompletionOr<String> format_time_since(Core::ElapsedTimer timer);
 
-    NonnullGCPtr<Realm> m_realm;
-    GCPtr<ConsoleClient> m_client;
+    GC::Ref<Realm> m_realm;
+    GC::Ptr<ConsoleClient> m_client;
 
     HashMap<String, unsigned> m_counters;
     HashMap<String, Core::ElapsedTimer> m_timer_table;
@@ -107,14 +107,14 @@ private:
 };
 
 class ConsoleClient : public Cell {
-    JS_CELL(ConsoleClient, Cell);
-    JS_DECLARE_ALLOCATOR(ConsoleClient);
+    GC_CELL(ConsoleClient, Cell);
+    GC_DECLARE_ALLOCATOR(ConsoleClient);
 
 public:
-    using PrinterArguments = Variant<Console::Group, Console::Trace, MarkedVector<Value>>;
+    using PrinterArguments = Variant<Console::Group, Console::Trace, GC::MarkedVector<Value>>;
 
-    ThrowCompletionOr<Value> logger(Console::LogLevel log_level, MarkedVector<Value> const& args);
-    ThrowCompletionOr<MarkedVector<Value>> formatter(MarkedVector<Value> const& args);
+    ThrowCompletionOr<Value> logger(Console::LogLevel log_level, GC::MarkedVector<Value> const& args);
+    ThrowCompletionOr<GC::MarkedVector<Value>> formatter(GC::MarkedVector<Value> const& args);
     virtual ThrowCompletionOr<Value> printer(Console::LogLevel log_level, PrinterArguments) = 0;
 
     virtual void add_css_style_to_current_message(StringView) { }
@@ -123,14 +123,14 @@ public:
     virtual void clear() = 0;
     virtual void end_group() = 0;
 
-    ThrowCompletionOr<String> generically_format_values(MarkedVector<Value> const&);
+    ThrowCompletionOr<String> generically_format_values(GC::MarkedVector<Value> const&);
 
 protected:
     explicit ConsoleClient(Console&);
     virtual ~ConsoleClient() override;
     virtual void visit_edges(Visitor& visitor) override;
 
-    NonnullGCPtr<Console> m_console;
+    GC::Ref<Console> m_console;
 };
 
 }
diff --git a/Libraries/LibJS/Contrib/Test262/262Object.cpp b/Libraries/LibJS/Contrib/Test262/262Object.cpp
index d6ee152070a..fe12d36a4ee 100644
--- a/Libraries/LibJS/Contrib/Test262/262Object.cpp
+++ b/Libraries/LibJS/Contrib/Test262/262Object.cpp
@@ -21,7 +21,7 @@
 
 namespace JS::Test262 {
 
-JS_DEFINE_ALLOCATOR($262Object);
+GC_DEFINE_ALLOCATOR($262Object);
 
 $262Object::$262Object(Realm& realm)
     : Object(Object::ConstructWithoutPrototypeTag::Tag, realm)
@@ -62,7 +62,7 @@ JS_DEFINE_NATIVE_FUNCTION($262Object::clear_kept_objects)
 
 JS_DEFINE_NATIVE_FUNCTION($262Object::create_realm)
 {
-    JS::GCPtr<JS::Test262::GlobalObject> global_object;
+    GC::Ptr<JS::Test262::GlobalObject> global_object;
     auto root_execution_context = MUST(JS::Realm::initialize_host_defined_realm(
         vm,
         [&](JS::Realm& realm) -> JS::GlobalObject* {
diff --git a/Libraries/LibJS/Contrib/Test262/262Object.h b/Libraries/LibJS/Contrib/Test262/262Object.h
index 880152b8823..c8a8d133b78 100644
--- a/Libraries/LibJS/Contrib/Test262/262Object.h
+++ b/Libraries/LibJS/Contrib/Test262/262Object.h
@@ -15,7 +15,7 @@ namespace JS::Test262 {
 
 class $262Object final : public Object {
     JS_OBJECT($262Object, Object);
-    JS_DECLARE_ALLOCATOR($262Object);
+    GC_DECLARE_ALLOCATOR($262Object);
 
 public:
     virtual void initialize(Realm&) override;
@@ -26,8 +26,8 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<AgentObject> m_agent;
-    GCPtr<IsHTMLDDA> m_is_htmldda;
+    GC::Ptr<AgentObject> m_agent;
+    GC::Ptr<IsHTMLDDA> m_is_htmldda;
 
     JS_DECLARE_NATIVE_FUNCTION(clear_kept_objects);
     JS_DECLARE_NATIVE_FUNCTION(create_realm);
diff --git a/Libraries/LibJS/Contrib/Test262/AgentObject.cpp b/Libraries/LibJS/Contrib/Test262/AgentObject.cpp
index 2cc3a385534..57fd43c16ac 100644
--- a/Libraries/LibJS/Contrib/Test262/AgentObject.cpp
+++ b/Libraries/LibJS/Contrib/Test262/AgentObject.cpp
@@ -12,7 +12,7 @@
 
 namespace JS::Test262 {
 
-JS_DEFINE_ALLOCATOR(AgentObject);
+GC_DEFINE_ALLOCATOR(AgentObject);
 
 AgentObject::AgentObject(Realm& realm)
     : Object(Object::ConstructWithoutPrototypeTag::Tag, realm)
diff --git a/Libraries/LibJS/Contrib/Test262/AgentObject.h b/Libraries/LibJS/Contrib/Test262/AgentObject.h
index d70f4f2ca3e..1f86cc3d41e 100644
--- a/Libraries/LibJS/Contrib/Test262/AgentObject.h
+++ b/Libraries/LibJS/Contrib/Test262/AgentObject.h
@@ -13,7 +13,7 @@ namespace JS::Test262 {
 
 class AgentObject final : public Object {
     JS_OBJECT(AgentObject, Object);
-    JS_DECLARE_ALLOCATOR(AgentObject);
+    GC_DECLARE_ALLOCATOR(AgentObject);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Contrib/Test262/GlobalObject.cpp b/Libraries/LibJS/Contrib/Test262/GlobalObject.cpp
index 3755a5d335d..76396ab4ffb 100644
--- a/Libraries/LibJS/Contrib/Test262/GlobalObject.cpp
+++ b/Libraries/LibJS/Contrib/Test262/GlobalObject.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Test262 {
 
-JS_DEFINE_ALLOCATOR(GlobalObject);
+GC_DEFINE_ALLOCATOR(GlobalObject);
 
 void GlobalObject::initialize(Realm& realm)
 {
diff --git a/Libraries/LibJS/Contrib/Test262/GlobalObject.h b/Libraries/LibJS/Contrib/Test262/GlobalObject.h
index 075cbfd3327..375742a6ba9 100644
--- a/Libraries/LibJS/Contrib/Test262/GlobalObject.h
+++ b/Libraries/LibJS/Contrib/Test262/GlobalObject.h
@@ -13,7 +13,7 @@ namespace JS::Test262 {
 
 class GlobalObject final : public JS::GlobalObject {
     JS_OBJECT(GlobalObject, JS::GlobalObject);
-    JS_DECLARE_ALLOCATOR(GlobalObject);
+    GC_DECLARE_ALLOCATOR(GlobalObject);
 
 public:
     virtual void initialize(Realm&) override;
@@ -29,7 +29,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<$262Object> m_$262;
+    GC::Ptr<$262Object> m_$262;
 
     JS_DECLARE_NATIVE_FUNCTION(print);
 };
diff --git a/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.cpp b/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.cpp
index 2f2567a20c8..9e860138d32 100644
--- a/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.cpp
+++ b/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.cpp
@@ -9,7 +9,7 @@
 
 namespace JS::Test262 {
 
-JS_DEFINE_ALLOCATOR(IsHTMLDDA);
+GC_DEFINE_ALLOCATOR(IsHTMLDDA);
 
 IsHTMLDDA::IsHTMLDDA(Realm& realm)
     // NativeFunction without prototype is currently not possible (only due to the lack of a ctor that supports it)
diff --git a/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.h b/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.h
index e1639bb80da..15a68756716 100644
--- a/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.h
+++ b/Libraries/LibJS/Contrib/Test262/IsHTMLDDA.h
@@ -12,7 +12,7 @@ namespace JS::Test262 {
 
 class IsHTMLDDA final : public NativeFunction {
     JS_OBJECT(IsHTMLDDA, NativeFunction);
-    JS_DECLARE_ALLOCATOR(IsHTMLDDA);
+    GC_DECLARE_ALLOCATOR(IsHTMLDDA);
 
 public:
     virtual ~IsHTMLDDA() override = default;
diff --git a/Libraries/LibJS/CyclicModule.cpp b/Libraries/LibJS/CyclicModule.cpp
index b7b020638a2..80060c184bb 100644
--- a/Libraries/LibJS/CyclicModule.cpp
+++ b/Libraries/LibJS/CyclicModule.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(CyclicModule);
+GC_DEFINE_ALLOCATOR(CyclicModule);
 
 CyclicModule::CyclicModule(Realm& realm, StringView filename, bool has_top_level_await, Vector<ModuleRequest> requested_modules, Script::HostDefined* host_defined)
     : Module(realm, filename, host_defined)
@@ -45,7 +45,7 @@ void GraphLoadingState::visit_edges(Cell::Visitor& visitor)
 }
 
 // 16.2.1.5.1 LoadRequestedModules ( [ hostDefined ] ), https://tc39.es/ecma262/#sec-LoadRequestedModules
-PromiseCapability& CyclicModule::load_requested_modules(GCPtr<GraphLoadingState::HostDefined> host_defined)
+PromiseCapability& CyclicModule::load_requested_modules(GC::Ptr<GraphLoadingState::HostDefined> host_defined)
 {
     // 1. If hostDefined is not present, let hostDefined be EMPTY.
     // NOTE: The empty state is handled by hostDefined being an optional without value.
@@ -54,7 +54,7 @@ PromiseCapability& CyclicModule::load_requested_modules(GCPtr<GraphLoadingState:
     auto promise_capability = MUST(new_promise_capability(vm(), vm().current_realm()->intrinsics().promise_constructor()));
 
     // 3. Let state be the GraphLoadingState Record { [[IsLoading]]: true, [[PendingModulesCount]]: 1, [[Visited]]: « », [[PromiseCapability]]: pc, [[HostDefined]]: hostDefined }.
-    auto state = heap().allocate<GraphLoadingState>(promise_capability, true, 1, HashTable<JS::GCPtr<CyclicModule>> {}, move(host_defined));
+    auto state = heap().allocate<GraphLoadingState>(promise_capability, true, 1, HashTable<GC::Ptr<CyclicModule>> {}, move(host_defined));
 
     // 4. Perform InnerModuleLoading(state, module).
     inner_module_loading(state);
@@ -101,7 +101,7 @@ void CyclicModule::inner_module_loading(JS::GraphLoadingState& state)
             // ii. Else,
             if (!found_record_in_loaded_modules) {
                 // 1. Perform HostLoadImportedModule(module, required, state.[[HostDefined]], state).
-                vm().host_load_imported_module(NonnullGCPtr<CyclicModule> { *this }, required, state.host_defined, NonnullGCPtr<GraphLoadingState> { state });
+                vm().host_load_imported_module(GC::Ref<CyclicModule> { *this }, required, state.host_defined, GC::Ref<GraphLoadingState> { state });
 
                 // 2. NOTE: HostLoadImportedModule will call FinishLoadingImportedModule, which re-enters the graph loading process through ContinueModuleLoading.
             }
@@ -138,7 +138,7 @@ void CyclicModule::inner_module_loading(JS::GraphLoadingState& state)
 }
 
 // 16.2.1.5.1.2 ContinueModuleLoading ( state, moduleCompletion ), https://tc39.es/ecma262/#sec-ContinueModuleLoading
-void continue_module_loading(GraphLoadingState& state, ThrowCompletionOr<NonnullGCPtr<Module>> const& module_completion)
+void continue_module_loading(GraphLoadingState& state, ThrowCompletionOr<GC::Ref<Module>> const& module_completion)
 {
     // 1. If state.[[IsLoading]] is false, return UNUSED.
     if (!state.is_loading)
@@ -469,7 +469,7 @@ ThrowCompletionOr<u32> CyclicModule::inner_module_evaluation(VM& vm, Vector<Modu
         if (!is<CyclicModule>(*required_module))
             continue;
 
-        JS::NonnullGCPtr<CyclicModule> cyclic_module = verify_cast<CyclicModule>(*required_module);
+        GC::Ref<CyclicModule> cyclic_module = verify_cast<CyclicModule>(*required_module);
         // i. Assert: requiredModule.[[Status]] is either evaluating, evaluating-async, or evaluated.
         VERIFY(cyclic_module->m_status == ModuleStatus::Evaluating || cyclic_module->m_status == ModuleStatus::EvaluatingAsync || cyclic_module->m_status == ModuleStatus::Evaluated);
 
@@ -578,7 +578,7 @@ ThrowCompletionOr<void> CyclicModule::initialize_environment(VM&)
     VERIFY_NOT_REACHED();
 }
 
-ThrowCompletionOr<void> CyclicModule::execute_module(VM&, GCPtr<PromiseCapability>)
+ThrowCompletionOr<void> CyclicModule::execute_module(VM&, GC::Ptr<PromiseCapability>)
 {
     // Note: In ecma262 this is never called on a cyclic module only on SourceTextModules.
     //       So this check is to make sure we don't accidentally call this.
@@ -807,7 +807,7 @@ void CyclicModule::async_module_execution_rejected(VM& vm, Value error)
 }
 
 // 16.2.1.7 GetImportedModule ( referrer, specifier ), https://tc39.es/ecma262/#sec-GetImportedModule
-NonnullGCPtr<Module> CyclicModule::get_imported_module(ModuleRequest const& request)
+GC::Ref<Module> CyclicModule::get_imported_module(ModuleRequest const& request)
 {
     // 1. Assert: Exactly one element of referrer.[[LoadedModules]] is a Record whose [[Specifier]] is specifier,
     //    since LoadRequestedModules has completed successfully on referrer prior to invoking this abstract operation.
@@ -829,7 +829,7 @@ NonnullGCPtr<Module> CyclicModule::get_imported_module(ModuleRequest const& requ
 }
 
 // 13.3.10.1.1 ContinueDynamicImport ( promiseCapability, moduleCompletion ), https://tc39.es/ecma262/#sec-ContinueDynamicImport
-void continue_dynamic_import(NonnullGCPtr<PromiseCapability> promise_capability, ThrowCompletionOr<NonnullGCPtr<Module>> const& module_completion)
+void continue_dynamic_import(GC::Ref<PromiseCapability> promise_capability, ThrowCompletionOr<GC::Ref<Module>> const& module_completion)
 {
     auto& vm = promise_capability->vm();
 
diff --git a/Libraries/LibJS/CyclicModule.h b/Libraries/LibJS/CyclicModule.h
index c0fa90df8e6..416fa02cb18 100644
--- a/Libraries/LibJS/CyclicModule.h
+++ b/Libraries/LibJS/CyclicModule.h
@@ -24,8 +24,8 @@ enum class ModuleStatus {
 
 // 16.2.1.5 Cyclic Module Records, https://tc39.es/ecma262/#cyclic-module-record
 class CyclicModule : public Module {
-    JS_CELL(CyclicModule, Module);
-    JS_DECLARE_ALLOCATOR(CyclicModule);
+    GC_CELL(CyclicModule, Module);
+    GC_DECLARE_ALLOCATOR(CyclicModule);
 
 public:
     virtual ~CyclicModule() override;
@@ -35,7 +35,7 @@ public:
     virtual ThrowCompletionOr<void> link(VM& vm) override final;
     virtual ThrowCompletionOr<Promise*> evaluate(VM& vm) override final;
 
-    virtual PromiseCapability& load_requested_modules(GCPtr<GraphLoadingState::HostDefined>) override;
+    virtual PromiseCapability& load_requested_modules(GC::Ptr<GraphLoadingState::HostDefined>) override;
     virtual void inner_module_loading(GraphLoadingState& state);
 
     Vector<ModuleRequest> const& requested_modules() const { return m_requested_modules; }
@@ -51,30 +51,30 @@ protected:
     virtual ThrowCompletionOr<u32> inner_module_evaluation(VM& vm, Vector<Module*>& stack, u32 index) override final;
 
     virtual ThrowCompletionOr<void> initialize_environment(VM& vm);
-    virtual ThrowCompletionOr<void> execute_module(VM& vm, GCPtr<PromiseCapability> capability = {});
+    virtual ThrowCompletionOr<void> execute_module(VM& vm, GC::Ptr<PromiseCapability> capability = {});
 
-    [[nodiscard]] NonnullGCPtr<Module> get_imported_module(ModuleRequest const&);
+    [[nodiscard]] GC::Ref<Module> get_imported_module(ModuleRequest const&);
 
     void execute_async_module(VM& vm);
     void gather_available_ancestors(Vector<CyclicModule*>& exec_list);
     void async_module_execution_fulfilled(VM& vm);
     void async_module_execution_rejected(VM& vm, Value error);
 
-    ModuleStatus m_status { ModuleStatus::New };        // [[Status]]
-    ThrowCompletionOr<void> m_evaluation_error;         // [[EvaluationError]]
-    Optional<u32> m_dfs_index;                          // [[DFSIndex]]
-    Optional<u32> m_dfs_ancestor_index;                 // [[DFSAncestorIndex]]
-    Vector<ModuleRequest> m_requested_modules;          // [[RequestedModules]]
-    Vector<ModuleWithSpecifier> m_loaded_modules;       // [[LoadedModules]]
-    GCPtr<CyclicModule> m_cycle_root;                   // [[CycleRoot]]
-    bool m_has_top_level_await { false };               // [[HasTLA]]
-    bool m_async_evaluation { false };                  // [[AsyncEvaluation]]
-    GCPtr<PromiseCapability> m_top_level_capability;    // [[TopLevelCapability]]
-    Vector<GCPtr<CyclicModule>> m_async_parent_modules; // [[AsyncParentModules]]
-    Optional<u32> m_pending_async_dependencies;         // [[PendingAsyncDependencies]]
+    ModuleStatus m_status { ModuleStatus::New };          // [[Status]]
+    ThrowCompletionOr<void> m_evaluation_error;           // [[EvaluationError]]
+    Optional<u32> m_dfs_index;                            // [[DFSIndex]]
+    Optional<u32> m_dfs_ancestor_index;                   // [[DFSAncestorIndex]]
+    Vector<ModuleRequest> m_requested_modules;            // [[RequestedModules]]
+    Vector<ModuleWithSpecifier> m_loaded_modules;         // [[LoadedModules]]
+    GC::Ptr<CyclicModule> m_cycle_root;                   // [[CycleRoot]]
+    bool m_has_top_level_await { false };                 // [[HasTLA]]
+    bool m_async_evaluation { false };                    // [[AsyncEvaluation]]
+    GC::Ptr<PromiseCapability> m_top_level_capability;    // [[TopLevelCapability]]
+    Vector<GC::Ptr<CyclicModule>> m_async_parent_modules; // [[AsyncParentModules]]
+    Optional<u32> m_pending_async_dependencies;           // [[PendingAsyncDependencies]]
 };
 
-void continue_module_loading(GraphLoadingState&, ThrowCompletionOr<NonnullGCPtr<Module>> const&);
-void continue_dynamic_import(NonnullGCPtr<PromiseCapability>, ThrowCompletionOr<NonnullGCPtr<Module>> const& module_completion);
+void continue_module_loading(GraphLoadingState&, ThrowCompletionOr<GC::Ref<Module>> const&);
+void continue_dynamic_import(GC::Ref<PromiseCapability>, ThrowCompletionOr<GC::Ref<Module>> const& module_completion);
 
 }
diff --git a/Libraries/LibJS/Forward.h b/Libraries/LibJS/Forward.h
index ef6bffcdd6e..01f9721c9e8 100644
--- a/Libraries/LibJS/Forward.h
+++ b/Libraries/LibJS/Forward.h
@@ -159,15 +159,12 @@ class BigInt;
 class BoundFunction;
 struct CachedSourceRange;
 class Cell;
-class CellImpl;
-class CellAllocator;
 class ClassExpression;
 struct ClassFieldDefinition;
 class Completion;
 class Console;
 class CyclicModule;
 class DeclarativeEnvironment;
-class DeferGC;
 class ECMAScriptFunctionObject;
 class Environment;
 class Error;
@@ -183,9 +180,6 @@ struct FunctionParameter;
 class GlobalEnvironment;
 class GlobalObject;
 struct GraphLoadingState;
-class HandleImpl;
-class Heap;
-class HeapBlock;
 struct ImportEntry;
 class ImportStatement;
 class Identifier;
@@ -195,7 +189,6 @@ class MemberExpression;
 class MetaProperty;
 class Module;
 struct ModuleRequest;
-class NanBoxedValue;
 class NativeFunction;
 class ObjectEnvironment;
 class Parser;
@@ -223,7 +216,6 @@ class Utf16String;
 class VM;
 class PrototypeChainValidity;
 class Value;
-class WeakContainer;
 class WrappedFunction;
 enum class DeclarationKind;
 struct AlreadyResolved;
@@ -301,22 +293,10 @@ struct TimeZoneMethods;
 struct PartialDurationRecord;
 };
 
-template<typename T>
-class HeapFunction;
-
 template<typename T>
 requires(!IsLvalueReference<T>)
 class ThrowCompletionOr;
 
-template<class T>
-class Handle;
-
-template<class T, size_t inline_capacity = 0>
-class ConservativeVector;
-
-template<class T, size_t inline_capacity = 0>
-class MarkedVector;
-
 namespace Bytecode {
 class BasicBlock;
 enum class Builtin : u8;
diff --git a/Libraries/LibJS/Heap/Cell.h b/Libraries/LibJS/Heap/Cell.h
index 84427ca1697..7c04a550abd 100644
--- a/Libraries/LibJS/Heap/Cell.h
+++ b/Libraries/LibJS/Heap/Cell.h
@@ -6,12 +6,13 @@
 
 #pragma once
 
-#include <LibJS/Heap/CellImpl.h>
+#include <LibGC/Cell.h>
+#include <LibJS/Forward.h>
 
 namespace JS {
 
-class Cell : public CellImpl {
-    JS_CELL(Cell, CellImpl);
+class Cell : public GC::Cell {
+    GC_CELL(Cell, GC::Cell);
 
 public:
     virtual void initialize(Realm&);
diff --git a/Libraries/LibJS/Heap/Handle.cpp b/Libraries/LibJS/Heap/Handle.cpp
deleted file mode 100644
index e80b56bfb6b..00000000000
--- a/Libraries/LibJS/Heap/Handle.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/Heap.h>
-
-namespace JS {
-
-HandleImpl::HandleImpl(CellImpl* cell, SourceLocation location)
-    : m_cell(cell)
-    , m_location(location)
-{
-    m_cell->heap().did_create_handle({}, *this);
-}
-
-HandleImpl::~HandleImpl()
-{
-    m_cell->heap().did_destroy_handle({}, *this);
-}
-
-}
diff --git a/Libraries/LibJS/Heap/Handle.h b/Libraries/LibJS/Heap/Handle.h
deleted file mode 100644
index 3dc99894e3a..00000000000
--- a/Libraries/LibJS/Heap/Handle.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <AK/Badge.h>
-#include <AK/IntrusiveList.h>
-#include <AK/Noncopyable.h>
-#include <AK/RefCounted.h>
-#include <AK/RefPtr.h>
-#include <AK/SourceLocation.h>
-#include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
-
-namespace JS {
-
-class HandleImpl : public RefCounted<HandleImpl> {
-    AK_MAKE_NONCOPYABLE(HandleImpl);
-    AK_MAKE_NONMOVABLE(HandleImpl);
-
-public:
-    ~HandleImpl();
-
-    CellImpl* cell() { return m_cell; }
-    CellImpl const* cell() const { return m_cell; }
-
-    SourceLocation const& source_location() const { return m_location; }
-
-private:
-    template<class T>
-    friend class Handle;
-
-    explicit HandleImpl(CellImpl*, SourceLocation location);
-    GCPtr<CellImpl> m_cell;
-    SourceLocation m_location;
-
-    IntrusiveListNode<HandleImpl> m_list_node;
-
-public:
-    using List = IntrusiveList<&HandleImpl::m_list_node>;
-};
-
-template<class T>
-class Handle {
-public:
-    Handle() = default;
-
-    static Handle create(T* cell, SourceLocation location = SourceLocation::current())
-    {
-        return Handle(adopt_ref(*new HandleImpl(const_cast<RemoveConst<T>*>(cell), location)));
-    }
-
-    Handle(T* cell, SourceLocation location = SourceLocation::current())
-    {
-        if (cell)
-            m_impl = adopt_ref(*new HandleImpl(cell, location));
-    }
-
-    Handle(T& cell, SourceLocation location = SourceLocation::current())
-        : m_impl(adopt_ref(*new HandleImpl(&cell, location)))
-    {
-    }
-
-    Handle(GCPtr<T> cell, SourceLocation location = SourceLocation::current())
-        : Handle(cell.ptr(), location)
-    {
-    }
-
-    Handle(NonnullGCPtr<T> cell, SourceLocation location = SourceLocation::current())
-        : Handle(*cell, location)
-    {
-    }
-
-    T* cell() const
-    {
-        if (!m_impl)
-            return nullptr;
-        return static_cast<T*>(m_impl->cell());
-    }
-
-    T* ptr() const
-    {
-        return cell();
-    }
-
-    bool is_null() const
-    {
-        return m_impl.is_null();
-    }
-
-    T* operator->() const
-    {
-        return cell();
-    }
-
-    [[nodiscard]] T& operator*() const
-    {
-        return *cell();
-    }
-
-    bool operator!() const
-    {
-        return !cell();
-    }
-    operator bool() const
-    {
-        return cell();
-    }
-
-    operator T*() const { return cell(); }
-
-private:
-    explicit Handle(NonnullRefPtr<HandleImpl> impl)
-        : m_impl(move(impl))
-    {
-    }
-
-    RefPtr<HandleImpl> m_impl;
-};
-
-template<class T>
-inline Handle<T> make_handle(T* cell, SourceLocation location = SourceLocation::current())
-{
-    if (!cell)
-        return Handle<T> {};
-    return Handle<T>::create(cell, location);
-}
-
-template<class T>
-inline Handle<T> make_handle(T& cell, SourceLocation location = SourceLocation::current())
-{
-    return Handle<T>::create(&cell, location);
-}
-
-template<class T>
-inline Handle<T> make_handle(GCPtr<T> cell, SourceLocation location = SourceLocation::current())
-{
-    if (!cell)
-        return Handle<T> {};
-    return Handle<T>::create(cell.ptr(), location);
-}
-
-template<class T>
-inline Handle<T> make_handle(NonnullGCPtr<T> cell, SourceLocation location = SourceLocation::current())
-{
-    return Handle<T>::create(cell.ptr(), location);
-}
-
-}
-
-namespace AK {
-
-template<typename T>
-struct Traits<JS::Handle<T>> : public DefaultTraits<JS::Handle<T>> {
-    static unsigned hash(JS::Handle<T> const& handle) { return Traits<T>::hash(handle); }
-};
-
-namespace Detail {
-template<typename T>
-inline constexpr bool IsHashCompatible<JS::Handle<T>, T> = true;
-
-template<typename T>
-inline constexpr bool IsHashCompatible<T, JS::Handle<T>> = true;
-
-}
-}
diff --git a/Libraries/LibJS/Heap/HeapFunction.h b/Libraries/LibJS/Heap/HeapFunction.h
deleted file mode 100644
index e4909f7ee7b..00000000000
--- a/Libraries/LibJS/Heap/HeapFunction.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2023, Andreas Kling <andreas@ladybird.org>
- *
- * SPDX-License-Identifier: BSD-2-Clause
- */
-
-#pragma once
-
-#include <AK/Function.h>
-#include <LibJS/Heap/CellImpl.h>
-#include <LibJS/Heap/Heap.h>
-
-namespace JS {
-
-template<typename T>
-class HeapFunction final : public CellImpl {
-    JS_CELL(HeapFunction, CellImpl);
-
-public:
-    static NonnullGCPtr<HeapFunction> create(Heap& heap, Function<T> function)
-    {
-        return heap.allocate<HeapFunction>(move(function));
-    }
-
-    virtual ~HeapFunction() override = default;
-
-    [[nodiscard]] Function<T> const& function() const { return m_function; }
-
-private:
-    HeapFunction(Function<T> function)
-        : m_function(move(function))
-    {
-    }
-
-    virtual void visit_edges(Visitor& visitor) override
-    {
-        Base::visit_edges(visitor);
-        visitor.visit_possible_values(m_function.raw_capture_range());
-    }
-
-    Function<T> m_function;
-};
-
-template<typename Callable, typename T = EquivalentFunctionType<Callable>>
-static NonnullGCPtr<HeapFunction<T>> create_heap_function(Heap& heap, Callable&& function)
-{
-    return HeapFunction<T>::create(heap, Function<T> { forward<Callable>(function) });
-}
-
-}
diff --git a/Libraries/LibJS/Module.cpp b/Libraries/LibJS/Module.cpp
index b4d7e6fdc13..2f2d238f8f1 100644
--- a/Libraries/LibJS/Module.cpp
+++ b/Libraries/LibJS/Module.cpp
@@ -15,8 +15,8 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Module);
-JS_DEFINE_ALLOCATOR(GraphLoadingState);
+GC_DEFINE_ALLOCATOR(Module);
+GC_DEFINE_ALLOCATOR(GraphLoadingState);
 
 Module::Module(Realm& realm, ByteString filename, Script::HostDefined* host_defined)
     : m_realm(realm)
@@ -68,14 +68,14 @@ ThrowCompletionOr<u32> Module::inner_module_evaluation(VM& vm, Vector<Module*>&,
 }
 
 // 16.2.1.9 FinishLoadingImportedModule ( referrer, specifier, payload, result ), https://tc39.es/ecma262/#sec-FinishLoadingImportedModule
-void finish_loading_imported_module(ImportedModuleReferrer referrer, ModuleRequest const& module_request, ImportedModulePayload payload, ThrowCompletionOr<NonnullGCPtr<Module>> const& result)
+void finish_loading_imported_module(ImportedModuleReferrer referrer, ModuleRequest const& module_request, ImportedModulePayload payload, ThrowCompletionOr<GC::Ref<Module>> const& result)
 {
     // 1. If result is a normal completion, then
     if (!result.is_error()) {
         // NOTE: Only Script and CyclicModule referrers have the [[LoadedModules]] internal slot.
-        if (referrer.has<NonnullGCPtr<Script>>() || referrer.has<NonnullGCPtr<CyclicModule>>()) {
+        if (referrer.has<GC::Ref<Script>>() || referrer.has<GC::Ref<CyclicModule>>()) {
             auto& loaded_modules = referrer.visit(
-                [](JS::NonnullGCPtr<JS::Realm>&) -> Vector<ModuleWithSpecifier>& {
+                [](GC::Ref<JS::Realm>&) -> Vector<ModuleWithSpecifier>& {
                     VERIFY_NOT_REACHED();
                     __builtin_unreachable();
                 },
@@ -101,19 +101,19 @@ void finish_loading_imported_module(ImportedModuleReferrer referrer, ModuleReque
                 // i. Append the Record { [[Specifier]]: specifier, [[Module]]: result.[[Value]] } to referrer.[[LoadedModules]].
                 loaded_modules.append(ModuleWithSpecifier {
                     .specifier = module_request.module_specifier,
-                    .module = NonnullGCPtr<Module>(*module) });
+                    .module = GC::Ref<Module>(*module) });
             }
         }
     }
 
-    if (payload.has<NonnullGCPtr<GraphLoadingState>>()) {
+    if (payload.has<GC::Ref<GraphLoadingState>>()) {
         // a. Perform ContinueModuleLoading(payload, result)
-        continue_module_loading(payload.get<NonnullGCPtr<GraphLoadingState>>(), result);
+        continue_module_loading(payload.get<GC::Ref<GraphLoadingState>>(), result);
     }
     // Else,
     else {
         // a. Perform ContinueDynamicImport(payload, result).
-        continue_dynamic_import(payload.get<NonnullGCPtr<PromiseCapability>>(), result);
+        continue_dynamic_import(payload.get<GC::Ref<PromiseCapability>>(), result);
     }
 
     // 4. Return unused.
@@ -174,7 +174,7 @@ Object* Module::module_namespace_create(Vector<DeprecatedFlyString> unambiguous_
     auto module_namespace = realm.create<ModuleNamespaceObject>(realm, this, move(unambiguous_names));
 
     // 9. Set module.[[Namespace]] to M.
-    m_namespace = make_handle(module_namespace);
+    m_namespace = make_root(module_namespace);
 
     // 10. Return M.
     return module_namespace;
diff --git a/Libraries/LibJS/Module.h b/Libraries/LibJS/Module.h
index 8a4119dd6ca..1704e9e7e8b 100644
--- a/Libraries/LibJS/Module.h
+++ b/Libraries/LibJS/Module.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/DeprecatedFlyString.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/ModuleLoading.h>
 #include <LibJS/Runtime/Environment.h>
 #include <LibJS/Runtime/Realm.h>
@@ -37,7 +37,7 @@ struct ResolvedBinding {
     }
 
     Type type { Null };
-    GCPtr<Module> module;
+    GC::Ptr<Module> module;
     DeprecatedFlyString export_name;
 
     bool is_valid() const
@@ -58,25 +58,25 @@ struct ResolvedBinding {
 
 // https://tc39.es/ecma262/#graphloadingstate-record
 struct GraphLoadingState : public Cell {
-    JS_CELL(GraphLoadingState, Cell);
-    JS_DECLARE_ALLOCATOR(GraphLoadingState);
+    GC_CELL(GraphLoadingState, Cell);
+    GC_DECLARE_ALLOCATOR(GraphLoadingState);
 
 public:
     struct HostDefined : Cell {
-        JS_CELL(HostDefined, Cell);
+        GC_CELL(HostDefined, Cell);
 
     public:
         virtual ~HostDefined() = default;
     };
 
-    GCPtr<PromiseCapability> promise_capability; // [[PromiseCapability]]
-    bool is_loading { false };                   // [[IsLoading]]
-    size_t pending_module_count { 0 };           // [[PendingModulesCount]]
-    HashTable<JS::GCPtr<CyclicModule>> visited;  // [[Visited]]
-    GCPtr<HostDefined> host_defined;             // [[HostDefined]]
+    GC::Ptr<PromiseCapability> promise_capability; // [[PromiseCapability]]
+    bool is_loading { false };                     // [[IsLoading]]
+    size_t pending_module_count { 0 };             // [[PendingModulesCount]]
+    HashTable<GC::Ptr<CyclicModule>> visited;      // [[Visited]]
+    GC::Ptr<HostDefined> host_defined;             // [[HostDefined]]
 
 private:
-    GraphLoadingState(GCPtr<PromiseCapability> promise_capability, bool is_loading, size_t pending_module_count, HashTable<JS::GCPtr<CyclicModule>> visited, GCPtr<HostDefined> host_defined)
+    GraphLoadingState(GC::Ptr<PromiseCapability> promise_capability, bool is_loading, size_t pending_module_count, HashTable<GC::Ptr<CyclicModule>> visited, GC::Ptr<HostDefined> host_defined)
         : promise_capability(move(promise_capability))
         , is_loading(is_loading)
         , pending_module_count(pending_module_count)
@@ -89,8 +89,8 @@ private:
 
 // 16.2.1.4 Abstract Module Records, https://tc39.es/ecma262/#sec-abstract-module-records
 class Module : public Cell {
-    JS_CELL(Module, Cell);
-    JS_DECLARE_ALLOCATOR(Module);
+    GC_CELL(Module, Cell);
+    GC_DECLARE_ALLOCATOR(Module);
 
 public:
     virtual ~Module() override;
@@ -115,7 +115,7 @@ public:
     virtual ThrowCompletionOr<u32> inner_module_linking(VM& vm, Vector<Module*>& stack, u32 index);
     virtual ThrowCompletionOr<u32> inner_module_evaluation(VM& vm, Vector<Module*>& stack, u32 index);
 
-    virtual PromiseCapability& load_requested_modules(GCPtr<GraphLoadingState::HostDefined>) = 0;
+    virtual PromiseCapability& load_requested_modules(GC::Ptr<GraphLoadingState::HostDefined>) = 0;
 
 protected:
     Module(Realm&, ByteString filename, Script::HostDefined* host_defined = nullptr);
@@ -135,9 +135,9 @@ private:
     // destroy the VM but keep the modules this should not happen. Because VM
     // stores modules with a RefPtr we cannot just store the VM as that leads to
     // cycles.
-    GCPtr<Realm> m_realm;                            // [[Realm]]
-    GCPtr<Environment> m_environment;                // [[Environment]]
-    GCPtr<Object> m_namespace;                       // [[Namespace]]
+    GC::Ptr<Realm> m_realm;                          // [[Realm]]
+    GC::Ptr<Environment> m_environment;              // [[Environment]]
+    GC::Ptr<Object> m_namespace;                     // [[Namespace]]
     Script::HostDefined* m_host_defined { nullptr }; // [[HostDefined]]
 
     // Needed for potential lookups of modules.
@@ -147,6 +147,6 @@ private:
 class CyclicModule;
 struct GraphLoadingState;
 
-void finish_loading_imported_module(ImportedModuleReferrer, ModuleRequest const&, ImportedModulePayload, ThrowCompletionOr<NonnullGCPtr<Module>> const&);
+void finish_loading_imported_module(ImportedModuleReferrer, ModuleRequest const&, ImportedModulePayload, ThrowCompletionOr<GC::Ref<Module>> const&);
 
 }
diff --git a/Libraries/LibJS/ModuleLoading.h b/Libraries/LibJS/ModuleLoading.h
index 98e302b8ded..a0e63834d56 100644
--- a/Libraries/LibJS/ModuleLoading.h
+++ b/Libraries/LibJS/ModuleLoading.h
@@ -7,12 +7,12 @@
 #pragma once
 
 #include <AK/Variant.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 
 namespace JS {
 
-using ImportedModuleReferrer = Variant<NonnullGCPtr<Script>, NonnullGCPtr<CyclicModule>, NonnullGCPtr<Realm>>;
-using ImportedModulePayload = Variant<NonnullGCPtr<GraphLoadingState>, NonnullGCPtr<PromiseCapability>>;
+using ImportedModuleReferrer = Variant<GC::Ref<Script>, GC::Ref<CyclicModule>, GC::Ref<Realm>>;
+using ImportedModulePayload = Variant<GC::Ref<GraphLoadingState>, GC::Ref<PromiseCapability>>;
 
 }
diff --git a/Libraries/LibJS/Parser.h b/Libraries/LibJS/Parser.h
index 531bb74acbc..4c484ded807 100644
--- a/Libraries/LibJS/Parser.h
+++ b/Libraries/LibJS/Parser.h
@@ -209,7 +209,7 @@ public:
     };
 
     // Needs to mess with m_state, and we're not going to expose a non-const getter for that :^)
-    friend ThrowCompletionOr<NonnullGCPtr<ECMAScriptFunctionObject>> FunctionConstructor::create_dynamic_function(VM&, FunctionObject&, FunctionObject*, FunctionKind, ReadonlySpan<String> parameter_args, String const& body_arg);
+    friend ThrowCompletionOr<GC::Ref<ECMAScriptFunctionObject>> FunctionConstructor::create_dynamic_function(VM&, FunctionObject&, FunctionObject*, FunctionKind, ReadonlySpan<String> parameter_args, String const& body_arg);
 
     static Parser parse_function_body_from_string(ByteString const& body_string, u16 parse_options, Vector<FunctionParameter> const& parameters, FunctionKind kind, FunctionParsingInsights&);
 
diff --git a/Libraries/LibJS/Runtime/AbstractOperations.cpp b/Libraries/LibJS/Runtime/AbstractOperations.cpp
index 7ed69824f1e..ca56fde0c04 100644
--- a/Libraries/LibJS/Runtime/AbstractOperations.cpp
+++ b/Libraries/LibJS/Runtime/AbstractOperations.cpp
@@ -73,7 +73,7 @@ ThrowCompletionOr<Value> call_impl(VM&, FunctionObject& function, Value this_val
 }
 
 // 7.3.15 Construct ( F [ , argumentsList [ , newTarget ] ] ), https://tc39.es/ecma262/#sec-construct
-ThrowCompletionOr<NonnullGCPtr<Object>> construct_impl(VM&, FunctionObject& function, ReadonlySpan<Value> arguments_list, FunctionObject* new_target)
+ThrowCompletionOr<GC::Ref<Object>> construct_impl(VM&, FunctionObject& function, ReadonlySpan<Value> arguments_list, FunctionObject* new_target)
 {
     // 1. If newTarget is not present, set newTarget to F.
     if (!new_target)
@@ -97,7 +97,7 @@ ThrowCompletionOr<size_t> length_of_array_like(VM& vm, Object const& object)
 }
 
 // 7.3.20 CreateListFromArrayLike ( obj [ , elementTypes ] ), https://tc39.es/ecma262/#sec-createlistfromarraylike
-ThrowCompletionOr<MarkedVector<Value>> create_list_from_array_like(VM& vm, Value value, Function<ThrowCompletionOr<void>(Value)> check_value)
+ThrowCompletionOr<GC::MarkedVector<Value>> create_list_from_array_like(VM& vm, Value value, Function<ThrowCompletionOr<void>(Value)> check_value)
 {
     // 1. If elementTypes is not present, set elementTypes to « Undefined, Null, Boolean, String, Symbol, Number, BigInt, Object ».
 
@@ -111,7 +111,7 @@ ThrowCompletionOr<MarkedVector<Value>> create_list_from_array_like(VM& vm, Value
     auto length = TRY(length_of_array_like(vm, array_like));
 
     // 4. Let list be a new empty List.
-    auto list = MarkedVector<Value> { vm.heap() };
+    auto list = GC::MarkedVector<Value> { vm.heap() };
     list.ensure_capacity(length);
 
     // 5. Let index be 0.
@@ -366,7 +366,7 @@ bool validate_and_apply_property_descriptor(Object* object, PropertyKey const& p
 }
 
 // 10.1.14 GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ), https://tc39.es/ecma262/#sec-getprototypefromconstructor
-ThrowCompletionOr<Object*> get_prototype_from_constructor(VM& vm, FunctionObject const& constructor, NonnullGCPtr<Object> (Intrinsics::*intrinsic_default_prototype)())
+ThrowCompletionOr<Object*> get_prototype_from_constructor(VM& vm, FunctionObject const& constructor, GC::Ref<Object> (Intrinsics::*intrinsic_default_prototype)())
 {
     // 1. Assert: intrinsicDefaultProto is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
 
@@ -387,7 +387,7 @@ ThrowCompletionOr<Object*> get_prototype_from_constructor(VM& vm, FunctionObject
 }
 
 // 9.1.2.2 NewDeclarativeEnvironment ( E ), https://tc39.es/ecma262/#sec-newdeclarativeenvironment
-NonnullGCPtr<DeclarativeEnvironment> new_declarative_environment(Environment& environment)
+GC::Ref<DeclarativeEnvironment> new_declarative_environment(Environment& environment)
 {
     auto& heap = environment.heap();
 
@@ -398,7 +398,7 @@ NonnullGCPtr<DeclarativeEnvironment> new_declarative_environment(Environment& en
 }
 
 // 9.1.2.3 NewObjectEnvironment ( O, W, E ), https://tc39.es/ecma262/#sec-newobjectenvironment
-NonnullGCPtr<ObjectEnvironment> new_object_environment(Object& object, bool is_with_environment, Environment* environment)
+GC::Ref<ObjectEnvironment> new_object_environment(Object& object, bool is_with_environment, Environment* environment)
 {
     auto& heap = object.heap();
 
@@ -411,7 +411,7 @@ NonnullGCPtr<ObjectEnvironment> new_object_environment(Object& object, bool is_w
 }
 
 // 9.1.2.4 NewFunctionEnvironment ( F, newTarget ), https://tc39.es/ecma262/#sec-newfunctionenvironment
-NonnullGCPtr<FunctionEnvironment> new_function_environment(ECMAScriptFunctionObject& function, Object* new_target)
+GC::Ref<FunctionEnvironment> new_function_environment(ECMAScriptFunctionObject& function, Object* new_target)
 {
     auto& heap = function.heap();
 
@@ -439,7 +439,7 @@ NonnullGCPtr<FunctionEnvironment> new_function_environment(ECMAScriptFunctionObj
 }
 
 // 9.2.1.1 NewPrivateEnvironment ( outerPrivEnv ), https://tc39.es/ecma262/#sec-newprivateenvironment
-NonnullGCPtr<PrivateEnvironment> new_private_environment(VM& vm, PrivateEnvironment* outer)
+GC::Ref<PrivateEnvironment> new_private_environment(VM& vm, PrivateEnvironment* outer)
 {
     // 1. Let names be a new empty List.
     // 2. Return the PrivateEnvironment Record { [[OuterPrivateEnvironment]]: outerPrivEnv, [[Names]]: names }.
@@ -447,7 +447,7 @@ NonnullGCPtr<PrivateEnvironment> new_private_environment(VM& vm, PrivateEnvironm
 }
 
 // 9.4.3 GetThisEnvironment ( ), https://tc39.es/ecma262/#sec-getthisenvironment
-NonnullGCPtr<Environment> get_this_environment(VM& vm)
+GC::Ref<Environment> get_this_environment(VM& vm)
 {
     // 1. Let env be the running execution context's LexicalEnvironment.
     // 2. Repeat,
@@ -1482,7 +1482,7 @@ ThrowCompletionOr<DisposableResource> create_disposable_resource(VM& vm, Value v
 }
 
 // 2.1.4 GetDisposeMethod ( V, hint ), https://tc39.es/proposal-explicit-resource-management/#sec-getdisposemethod
-ThrowCompletionOr<GCPtr<FunctionObject>> get_dispose_method(VM& vm, Value value, Environment::InitializeBindingHint hint)
+ThrowCompletionOr<GC::Ptr<FunctionObject>> get_dispose_method(VM& vm, Value value, Environment::InitializeBindingHint hint)
 {
     // NOTE: We only have sync dispose for now which means we ignore step 1.
     VERIFY(hint == Environment::InitializeBindingHint::SyncDispose);
@@ -1493,7 +1493,7 @@ ThrowCompletionOr<GCPtr<FunctionObject>> get_dispose_method(VM& vm, Value value,
 }
 
 // 2.1.5 Dispose ( V, hint, method ), https://tc39.es/proposal-explicit-resource-management/#sec-dispose
-Completion dispose(VM& vm, Value value, NonnullGCPtr<FunctionObject> method)
+Completion dispose(VM& vm, Value value, GC::Ref<FunctionObject> method)
 {
     // 1. Let result be ? Call(method, V).
     [[maybe_unused]] auto result = TRY(call(vm, *method, value));
@@ -1550,7 +1550,7 @@ Completion dispose_resources(VM& vm, Vector<DisposableResource> const& disposabl
     return completion;
 }
 
-Completion dispose_resources(VM& vm, GCPtr<DeclarativeEnvironment> disposable, Completion completion)
+Completion dispose_resources(VM& vm, GC::Ptr<DeclarativeEnvironment> disposable, Completion completion)
 {
     // 1. If disposable is not undefined, then
     if (disposable)
@@ -1588,12 +1588,12 @@ ThrowCompletionOr<Value> perform_import_call(VM& vm, Value specifier, Value opti
 
         // 2. If referrer is null, set referrer to the current Realm Record.
         if (active_script_or_module.has<Empty>())
-            return NonnullGCPtr<Realm> { realm };
+            return GC::Ref<Realm> { realm };
 
-        if (active_script_or_module.has<NonnullGCPtr<Script>>())
-            return active_script_or_module.get<NonnullGCPtr<Script>>();
+        if (active_script_or_module.has<GC::Ref<Script>>())
+            return active_script_or_module.get<GC::Ref<Script>>();
 
-        return NonnullGCPtr<CyclicModule> { verify_cast<CyclicModule>(*active_script_or_module.get<NonnullGCPtr<Module>>()) };
+        return GC::Ref<CyclicModule> { verify_cast<CyclicModule>(*active_script_or_module.get<GC::Ref<Module>>()) };
     }();
 
     // 7. Let promiseCapability be ! NewPromiseCapability(%Promise%).
diff --git a/Libraries/LibJS/Runtime/AbstractOperations.h b/Libraries/LibJS/Runtime/AbstractOperations.h
index ebcb044a67a..c082d99c83a 100644
--- a/Libraries/LibJS/Runtime/AbstractOperations.h
+++ b/Libraries/LibJS/Runtime/AbstractOperations.h
@@ -9,8 +9,8 @@
 #include <AK/Concepts.h>
 #include <AK/Forward.h>
 #include <LibCrypto/Forward.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibJS/Runtime/CanonicalIndex.h>
 #include <LibJS/Runtime/FunctionObject.h>
 #include <LibJS/Runtime/GlobalObject.h>
@@ -22,38 +22,38 @@
 
 namespace JS {
 
-NonnullGCPtr<DeclarativeEnvironment> new_declarative_environment(Environment&);
-NonnullGCPtr<ObjectEnvironment> new_object_environment(Object&, bool is_with_environment, Environment*);
-NonnullGCPtr<FunctionEnvironment> new_function_environment(ECMAScriptFunctionObject&, Object* new_target);
-NonnullGCPtr<PrivateEnvironment> new_private_environment(VM& vm, PrivateEnvironment* outer);
-NonnullGCPtr<Environment> get_this_environment(VM&);
+GC::Ref<DeclarativeEnvironment> new_declarative_environment(Environment&);
+GC::Ref<ObjectEnvironment> new_object_environment(Object&, bool is_with_environment, Environment*);
+GC::Ref<FunctionEnvironment> new_function_environment(ECMAScriptFunctionObject&, Object* new_target);
+GC::Ref<PrivateEnvironment> new_private_environment(VM& vm, PrivateEnvironment* outer);
+GC::Ref<Environment> get_this_environment(VM&);
 bool can_be_held_weakly(Value);
 Object* get_super_constructor(VM&);
 ThrowCompletionOr<Value> require_object_coercible(VM&, Value);
 ThrowCompletionOr<Value> call_impl(VM&, Value function, Value this_value, ReadonlySpan<Value> arguments = {});
 ThrowCompletionOr<Value> call_impl(VM&, FunctionObject& function, Value this_value, ReadonlySpan<Value> arguments = {});
-ThrowCompletionOr<NonnullGCPtr<Object>> construct_impl(VM&, FunctionObject&, ReadonlySpan<Value> arguments = {}, FunctionObject* new_target = nullptr);
+ThrowCompletionOr<GC::Ref<Object>> construct_impl(VM&, FunctionObject&, ReadonlySpan<Value> arguments = {}, FunctionObject* new_target = nullptr);
 ThrowCompletionOr<size_t> length_of_array_like(VM&, Object const&);
-ThrowCompletionOr<MarkedVector<Value>> create_list_from_array_like(VM&, Value, Function<ThrowCompletionOr<void>(Value)> = {});
+ThrowCompletionOr<GC::MarkedVector<Value>> create_list_from_array_like(VM&, Value, Function<ThrowCompletionOr<void>(Value)> = {});
 ThrowCompletionOr<FunctionObject*> species_constructor(VM&, Object const&, FunctionObject& default_constructor);
 ThrowCompletionOr<Realm*> get_function_realm(VM&, FunctionObject const&);
 ThrowCompletionOr<void> initialize_bound_name(VM&, DeprecatedFlyString const&, Value, Environment*);
 bool is_compatible_property_descriptor(bool extensible, PropertyDescriptor const&, Optional<PropertyDescriptor> const& current);
 bool validate_and_apply_property_descriptor(Object*, PropertyKey const&, bool extensible, PropertyDescriptor const&, Optional<PropertyDescriptor> const& current);
-ThrowCompletionOr<Object*> get_prototype_from_constructor(VM&, FunctionObject const& constructor, NonnullGCPtr<Object> (Intrinsics::*intrinsic_default_prototype)());
+ThrowCompletionOr<Object*> get_prototype_from_constructor(VM&, FunctionObject const& constructor, GC::Ref<Object> (Intrinsics::*intrinsic_default_prototype)());
 Object* create_unmapped_arguments_object(VM&, ReadonlySpan<Value> arguments);
 Object* create_mapped_arguments_object(VM&, FunctionObject&, Vector<FunctionParameter> const&, ReadonlySpan<Value> arguments, Environment&);
 
 struct DisposableResource {
     Value resource_value;
-    NonnullGCPtr<FunctionObject> dispose_method;
+    GC::Ref<FunctionObject> dispose_method;
 };
 ThrowCompletionOr<void> add_disposable_resource(VM&, Vector<DisposableResource>& disposable, Value, Environment::InitializeBindingHint, FunctionObject* = nullptr);
 ThrowCompletionOr<DisposableResource> create_disposable_resource(VM&, Value, Environment::InitializeBindingHint, FunctionObject* method = nullptr);
-ThrowCompletionOr<GCPtr<FunctionObject>> get_dispose_method(VM&, Value, Environment::InitializeBindingHint);
-Completion dispose(VM& vm, Value, NonnullGCPtr<FunctionObject> method);
+ThrowCompletionOr<GC::Ptr<FunctionObject>> get_dispose_method(VM&, Value, Environment::InitializeBindingHint);
+Completion dispose(VM& vm, Value, GC::Ref<FunctionObject> method);
 Completion dispose_resources(VM& vm, Vector<DisposableResource> const& disposable, Completion completion);
-Completion dispose_resources(VM& vm, GCPtr<DeclarativeEnvironment> disposable, Completion completion);
+Completion dispose_resources(VM& vm, GC::Ptr<DeclarativeEnvironment> disposable, Completion completion);
 
 ThrowCompletionOr<Value> perform_import_call(VM&, Value specifier, Value options_value);
 
@@ -120,7 +120,7 @@ ALWAYS_INLINE ThrowCompletionOr<Value> call(VM& vm, FunctionObject& function, Va
 
 // 7.3.15 Construct ( F [ , argumentsList [ , newTarget ] ] ), https://tc39.es/ecma262/#sec-construct
 template<typename... Args>
-ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> construct(VM& vm, FunctionObject& function, Args&&... args)
+ALWAYS_INLINE ThrowCompletionOr<GC::Ref<Object>> construct(VM& vm, FunctionObject& function, Args&&... args)
 {
     constexpr auto argument_count = sizeof...(Args);
     if constexpr (argument_count > 0) {
@@ -131,19 +131,19 @@ ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> construct(VM& vm, Function
     return construct_impl(vm, function);
 }
 
-ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> construct(VM& vm, FunctionObject& function, ReadonlySpan<Value> arguments_list, FunctionObject* new_target = nullptr)
+ALWAYS_INLINE ThrowCompletionOr<GC::Ref<Object>> construct(VM& vm, FunctionObject& function, ReadonlySpan<Value> arguments_list, FunctionObject* new_target = nullptr)
 {
     return construct_impl(vm, function, arguments_list, new_target);
 }
 
-ALWAYS_INLINE ThrowCompletionOr<NonnullGCPtr<Object>> construct(VM& vm, FunctionObject& function, Span<Value> arguments_list, FunctionObject* new_target = nullptr)
+ALWAYS_INLINE ThrowCompletionOr<GC::Ref<Object>> construct(VM& vm, FunctionObject& function, Span<Value> arguments_list, FunctionObject* new_target = nullptr)
 {
     return construct_impl(vm, function, static_cast<ReadonlySpan<Value>>(arguments_list), new_target);
 }
 
 // 10.1.13 OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ), https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor
 template<typename T, typename... Args>
-ThrowCompletionOr<NonnullGCPtr<T>> ordinary_create_from_constructor(VM& vm, FunctionObject const& constructor, NonnullGCPtr<Object> (Intrinsics::*intrinsic_default_prototype)(), Args&&... args)
+ThrowCompletionOr<GC::Ref<T>> ordinary_create_from_constructor(VM& vm, FunctionObject const& constructor, GC::Ref<Object> (Intrinsics::*intrinsic_default_prototype)(), Args&&... args)
 {
     auto& realm = *vm.current_realm();
     auto* prototype = TRY(get_prototype_from_constructor(vm, constructor, intrinsic_default_prototype));
@@ -199,7 +199,7 @@ void add_value_to_keyed_group(VM& vm, GroupsType& groups, KeyType key, Value val
     }
 
     // 2. Let group be the Record { [[Key]]: key, [[Elements]]: « value » }.
-    MarkedVector<Value> new_elements { vm.heap() };
+    GC::MarkedVector<Value> new_elements { vm.heap() };
     new_elements.append(value);
 
     // 3. Append group as the last element of groups.
@@ -278,7 +278,7 @@ ThrowCompletionOr<GroupsType> group_by(VM& vm, Value items, Value callback_funct
             // ii. Set key to CanonicalizeKeyedCollectionKey(key).
             key = canonicalize_keyed_collection_key(key.value());
 
-            add_value_to_keyed_group(vm, groups, make_handle(key.release_value()), value);
+            add_value_to_keyed_group(vm, groups, make_root(key.release_value()), value);
         }
 
         // i. Perform AddValueToKeyedGroup(groups, key, value).
diff --git a/Libraries/LibJS/Runtime/Accessor.cpp b/Libraries/LibJS/Runtime/Accessor.cpp
index 15f3611555c..b2fa03cff3e 100644
--- a/Libraries/LibJS/Runtime/Accessor.cpp
+++ b/Libraries/LibJS/Runtime/Accessor.cpp
@@ -8,6 +8,6 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Accessor);
+GC_DEFINE_ALLOCATOR(Accessor);
 
 }
diff --git a/Libraries/LibJS/Runtime/Accessor.h b/Libraries/LibJS/Runtime/Accessor.h
index 29a181e5b24..a9a25f4cce1 100644
--- a/Libraries/LibJS/Runtime/Accessor.h
+++ b/Libraries/LibJS/Runtime/Accessor.h
@@ -14,11 +14,11 @@
 namespace JS {
 
 class Accessor final : public Cell {
-    JS_CELL(Accessor, Cell);
-    JS_DECLARE_ALLOCATOR(Accessor);
+    GC_CELL(Accessor, Cell);
+    GC_DECLARE_ALLOCATOR(Accessor);
 
 public:
-    static NonnullGCPtr<Accessor> create(VM& vm, FunctionObject* getter, FunctionObject* setter)
+    static GC::Ref<Accessor> create(VM& vm, FunctionObject* getter, FunctionObject* setter)
     {
         return vm.heap().allocate<Accessor>(getter, setter);
     }
@@ -43,8 +43,8 @@ private:
     {
     }
 
-    GCPtr<FunctionObject> m_getter;
-    GCPtr<FunctionObject> m_setter;
+    GC::Ptr<FunctionObject> m_getter;
+    GC::Ptr<FunctionObject> m_setter;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/AggregateError.cpp b/Libraries/LibJS/Runtime/AggregateError.cpp
index 752b238b67d..71a27de7f3e 100644
--- a/Libraries/LibJS/Runtime/AggregateError.cpp
+++ b/Libraries/LibJS/Runtime/AggregateError.cpp
@@ -10,9 +10,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AggregateError);
+GC_DEFINE_ALLOCATOR(AggregateError);
 
-NonnullGCPtr<AggregateError> AggregateError::create(Realm& realm)
+GC::Ref<AggregateError> AggregateError::create(Realm& realm)
 {
     return realm.create<AggregateError>(realm.intrinsics().aggregate_error_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/AggregateError.h b/Libraries/LibJS/Runtime/AggregateError.h
index 9d68d748134..abf59437bb3 100644
--- a/Libraries/LibJS/Runtime/AggregateError.h
+++ b/Libraries/LibJS/Runtime/AggregateError.h
@@ -13,10 +13,10 @@ namespace JS {
 
 class AggregateError : public Error {
     JS_OBJECT(AggregateError, Error);
-    JS_DECLARE_ALLOCATOR(AggregateError);
+    GC_DECLARE_ALLOCATOR(AggregateError);
 
 public:
-    static NonnullGCPtr<AggregateError> create(Realm&);
+    static GC::Ref<AggregateError> create(Realm&);
     virtual ~AggregateError() override = default;
 
 private:
diff --git a/Libraries/LibJS/Runtime/AggregateErrorConstructor.cpp b/Libraries/LibJS/Runtime/AggregateErrorConstructor.cpp
index 1284bfb7fa9..bbdcaf308f0 100644
--- a/Libraries/LibJS/Runtime/AggregateErrorConstructor.cpp
+++ b/Libraries/LibJS/Runtime/AggregateErrorConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AggregateErrorConstructor);
+GC_DEFINE_ALLOCATOR(AggregateErrorConstructor);
 
 AggregateErrorConstructor::AggregateErrorConstructor(Realm& realm)
     : NativeFunction(static_cast<Object&>(*realm.intrinsics().error_constructor()))
@@ -40,7 +40,7 @@ ThrowCompletionOr<Value> AggregateErrorConstructor::call()
 }
 
 // 20.5.7.1.1 AggregateError ( errors, message [ , options ] ), https://tc39.es/ecma262/#sec-aggregate-error
-ThrowCompletionOr<NonnullGCPtr<Object>> AggregateErrorConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> AggregateErrorConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
diff --git a/Libraries/LibJS/Runtime/AggregateErrorConstructor.h b/Libraries/LibJS/Runtime/AggregateErrorConstructor.h
index 62229bdd4b8..3e09bf393a6 100644
--- a/Libraries/LibJS/Runtime/AggregateErrorConstructor.h
+++ b/Libraries/LibJS/Runtime/AggregateErrorConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class AggregateErrorConstructor final : public NativeFunction {
     JS_OBJECT(AggregateErrorConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(AggregateErrorConstructor);
+    GC_DECLARE_ALLOCATOR(AggregateErrorConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~AggregateErrorConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit AggregateErrorConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/AggregateErrorPrototype.cpp b/Libraries/LibJS/Runtime/AggregateErrorPrototype.cpp
index f69bfbfa638..3a7451a61ff 100644
--- a/Libraries/LibJS/Runtime/AggregateErrorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AggregateErrorPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AggregateErrorPrototype);
+GC_DEFINE_ALLOCATOR(AggregateErrorPrototype);
 
 AggregateErrorPrototype::AggregateErrorPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().error_prototype())
diff --git a/Libraries/LibJS/Runtime/AggregateErrorPrototype.h b/Libraries/LibJS/Runtime/AggregateErrorPrototype.h
index 83a307b64eb..18134c7139f 100644
--- a/Libraries/LibJS/Runtime/AggregateErrorPrototype.h
+++ b/Libraries/LibJS/Runtime/AggregateErrorPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class AggregateErrorPrototype final : public Object {
     JS_OBJECT(AggregateErrorPrototype, Object);
-    JS_DECLARE_ALLOCATOR(AggregateErrorPrototype);
+    GC_DECLARE_ALLOCATOR(AggregateErrorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ArgumentsObject.cpp b/Libraries/LibJS/Runtime/ArgumentsObject.cpp
index 9bef49e222d..3465cf20fca 100644
--- a/Libraries/LibJS/Runtime/ArgumentsObject.cpp
+++ b/Libraries/LibJS/Runtime/ArgumentsObject.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArgumentsObject);
+GC_DEFINE_ALLOCATOR(ArgumentsObject);
 
 ArgumentsObject::ArgumentsObject(Realm& realm, Environment& environment)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype(), MayInterfereWithIndexedPropertyAccess::Yes)
diff --git a/Libraries/LibJS/Runtime/ArgumentsObject.h b/Libraries/LibJS/Runtime/ArgumentsObject.h
index be27a62e1e4..675afcd400f 100644
--- a/Libraries/LibJS/Runtime/ArgumentsObject.h
+++ b/Libraries/LibJS/Runtime/ArgumentsObject.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class ArgumentsObject final : public Object {
     JS_OBJECT(ArgumentsObject, Object);
-    JS_DECLARE_ALLOCATOR(ArgumentsObject);
+    GC_DECLARE_ALLOCATOR(ArgumentsObject);
 
 public:
     virtual void initialize(Realm&) override;
@@ -36,8 +36,8 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    NonnullGCPtr<Environment> m_environment;
-    GCPtr<Object> m_parameter_map;
+    GC::Ref<Environment> m_environment;
+    GC::Ptr<Object> m_parameter_map;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Array.cpp b/Libraries/LibJS/Runtime/Array.cpp
index fed5cb8bbc4..7aef99beb5a 100644
--- a/Libraries/LibJS/Runtime/Array.cpp
+++ b/Libraries/LibJS/Runtime/Array.cpp
@@ -17,10 +17,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Array);
+GC_DEFINE_ALLOCATOR(Array);
 
 // 10.4.2.2 ArrayCreate ( length [ , proto ] ), https://tc39.es/ecma262/#sec-arraycreate
-ThrowCompletionOr<NonnullGCPtr<Array>> Array::create(Realm& realm, u64 length, Object* prototype)
+ThrowCompletionOr<GC::Ref<Array>> Array::create(Realm& realm, u64 length, Object* prototype)
 {
     auto& vm = realm.vm();
 
@@ -45,7 +45,7 @@ ThrowCompletionOr<NonnullGCPtr<Array>> Array::create(Realm& realm, u64 length, O
 }
 
 // 7.3.18 CreateArrayFromList ( elements ), https://tc39.es/ecma262/#sec-createarrayfromlist
-NonnullGCPtr<Array> Array::create_from(Realm& realm, ReadonlySpan<Value> elements)
+GC::Ref<Array> Array::create_from(Realm& realm, ReadonlySpan<Value> elements)
 {
     // 1. Let array be ! ArrayCreate(0).
     auto array = MUST(Array::create(realm, 0));
@@ -161,10 +161,10 @@ ThrowCompletionOr<bool> Array::set_length(PropertyDescriptor const& property_des
 }
 
 // 23.1.3.30.1 SortIndexedProperties ( obj, len, SortCompare, holes ), https://tc39.es/ecma262/#sec-sortindexedproperties
-ThrowCompletionOr<MarkedVector<Value>> sort_indexed_properties(VM& vm, Object const& object, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes)
+ThrowCompletionOr<GC::MarkedVector<Value>> sort_indexed_properties(VM& vm, Object const& object, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes)
 {
     // 1. Let items be a new empty List.
-    auto items = MarkedVector<Value> { vm.heap() };
+    auto items = GC::MarkedVector<Value> { vm.heap() };
 
     // 2. Let k be 0.
     // 3. Repeat, while k < len,
@@ -330,7 +330,7 @@ ThrowCompletionOr<bool> Array::internal_delete(PropertyKey const& property_key)
 }
 
 // NON-STANDARD: Used to inject the ephemeral length property's key
-ThrowCompletionOr<MarkedVector<Value>> Array::internal_own_property_keys() const
+ThrowCompletionOr<GC::MarkedVector<Value>> Array::internal_own_property_keys() const
 {
     auto& vm = this->vm();
     auto keys = TRY(Object::internal_own_property_keys());
diff --git a/Libraries/LibJS/Runtime/Array.h b/Libraries/LibJS/Runtime/Array.h
index 75ce47ae71b..faf9bb20f0d 100644
--- a/Libraries/LibJS/Runtime/Array.h
+++ b/Libraries/LibJS/Runtime/Array.h
@@ -21,23 +21,23 @@ namespace JS {
 
 class Array : public Object {
     JS_OBJECT(Array, Object);
-    JS_DECLARE_ALLOCATOR(Array);
+    GC_DECLARE_ALLOCATOR(Array);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<Array>> create(Realm&, u64 length, Object* prototype = nullptr);
-    static NonnullGCPtr<Array> create_from(Realm&, ReadonlySpan<Value>);
+    static ThrowCompletionOr<GC::Ref<Array>> create(Realm&, u64 length, Object* prototype = nullptr);
+    static GC::Ref<Array> create_from(Realm&, ReadonlySpan<Value>);
 
     template<size_t N>
-    static NonnullGCPtr<Array> create_from(Realm& realm, Value const (&values)[N])
+    static GC::Ref<Array> create_from(Realm& realm, Value const (&values)[N])
     {
         return create_from(realm, ReadonlySpan<Value> { values, N });
     }
 
     // Non-standard but equivalent to CreateArrayFromList.
     template<typename T>
-    static NonnullGCPtr<Array> create_from(Realm& realm, ReadonlySpan<T> elements, Function<Value(T const&)> map_fn)
+    static GC::Ref<Array> create_from(Realm& realm, ReadonlySpan<T> elements, Function<Value(T const&)> map_fn)
     {
-        auto values = MarkedVector<Value> { realm.heap() };
+        auto values = GC::MarkedVector<Value> { realm.heap() };
         values.ensure_capacity(elements.size());
         for (auto const& element : elements)
             values.append(map_fn(element));
@@ -50,7 +50,7 @@ public:
     virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const override final;
     virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr) override final;
     virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const override final;
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override final;
 
     [[nodiscard]] bool length_is_writable() const { return m_length_writable; }
 
@@ -68,7 +68,7 @@ enum class Holes {
     ReadThroughHoles,
 };
 
-ThrowCompletionOr<MarkedVector<Value>> sort_indexed_properties(VM&, Object const&, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes);
+ThrowCompletionOr<GC::MarkedVector<Value>> sort_indexed_properties(VM&, Object const&, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes);
 ThrowCompletionOr<double> compare_array_elements(VM&, Value x, Value y, FunctionObject* comparefn);
 
 }
diff --git a/Libraries/LibJS/Runtime/ArrayBuffer.cpp b/Libraries/LibJS/Runtime/ArrayBuffer.cpp
index 853e00b8c41..bf12087e231 100644
--- a/Libraries/LibJS/Runtime/ArrayBuffer.cpp
+++ b/Libraries/LibJS/Runtime/ArrayBuffer.cpp
@@ -11,9 +11,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayBuffer);
+GC_DEFINE_ALLOCATOR(ArrayBuffer);
 
-ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> ArrayBuffer::create(Realm& realm, size_t byte_length)
+ThrowCompletionOr<GC::Ref<ArrayBuffer>> ArrayBuffer::create(Realm& realm, size_t byte_length)
 {
     auto buffer = ByteBuffer::create_zeroed(byte_length);
     if (buffer.is_error())
@@ -22,12 +22,12 @@ ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> ArrayBuffer::create(Realm& realm, s
     return realm.create<ArrayBuffer>(buffer.release_value(), realm.intrinsics().array_buffer_prototype());
 }
 
-NonnullGCPtr<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer buffer)
+GC::Ref<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer buffer)
 {
     return realm.create<ArrayBuffer>(move(buffer), realm.intrinsics().array_buffer_prototype());
 }
 
-NonnullGCPtr<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer* buffer)
+GC::Ref<ArrayBuffer> ArrayBuffer::create(Realm& realm, ByteBuffer* buffer)
 {
     return realm.create<ArrayBuffer>(buffer, realm.intrinsics().array_buffer_prototype());
 }
@@ -302,7 +302,7 @@ ThrowCompletionOr<Optional<size_t>> get_array_buffer_max_byte_length_option(VM&
 }
 
 // 25.2.2.1 AllocateSharedArrayBuffer ( constructor, byteLength [ , maxByteLength ] ), https://tc39.es/ecma262/#sec-allocatesharedarraybuffer
-ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> allocate_shared_array_buffer(VM& vm, FunctionObject& constructor, size_t byte_length)
+ThrowCompletionOr<GC::Ref<ArrayBuffer>> allocate_shared_array_buffer(VM& vm, FunctionObject& constructor, size_t byte_length)
 {
     // 1. Let obj be ? OrdinaryCreateFromConstructor(constructor, "%SharedArrayBuffer.prototype%", « [[ArrayBufferData]], [[ArrayBufferByteLength]] »).
     auto obj = TRY(ordinary_create_from_constructor<ArrayBuffer>(vm, constructor, &Intrinsics::shared_array_buffer_prototype, nullptr));
diff --git a/Libraries/LibJS/Runtime/ArrayBuffer.h b/Libraries/LibJS/Runtime/ArrayBuffer.h
index 057b0ce7024..15fb85b9282 100644
--- a/Libraries/LibJS/Runtime/ArrayBuffer.h
+++ b/Libraries/LibJS/Runtime/ArrayBuffer.h
@@ -56,12 +56,12 @@ struct DataBlock {
 
 class ArrayBuffer : public Object {
     JS_OBJECT(ArrayBuffer, Object);
-    JS_DECLARE_ALLOCATOR(ArrayBuffer);
+    GC_DECLARE_ALLOCATOR(ArrayBuffer);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> create(Realm&, size_t);
-    static NonnullGCPtr<ArrayBuffer> create(Realm&, ByteBuffer);
-    static NonnullGCPtr<ArrayBuffer> create(Realm&, ByteBuffer*);
+    static ThrowCompletionOr<GC::Ref<ArrayBuffer>> create(Realm&, size_t);
+    static GC::Ref<ArrayBuffer> create(Realm&, ByteBuffer);
+    static GC::Ref<ArrayBuffer> create(Realm&, ByteBuffer*);
 
     virtual ~ArrayBuffer() override = default;
 
@@ -152,7 +152,7 @@ ThrowCompletionOr<ArrayBuffer*> array_buffer_copy_and_detach(VM&, ArrayBuffer& a
 ThrowCompletionOr<void> detach_array_buffer(VM&, ArrayBuffer& array_buffer, Optional<Value> key = {});
 ThrowCompletionOr<Optional<size_t>> get_array_buffer_max_byte_length_option(VM&, Value options);
 ThrowCompletionOr<ArrayBuffer*> clone_array_buffer(VM&, ArrayBuffer& source_buffer, size_t source_byte_offset, size_t source_length);
-ThrowCompletionOr<NonnullGCPtr<ArrayBuffer>> allocate_shared_array_buffer(VM&, FunctionObject& constructor, size_t byte_length);
+ThrowCompletionOr<GC::Ref<ArrayBuffer>> allocate_shared_array_buffer(VM&, FunctionObject& constructor, size_t byte_length);
 
 // 25.1.3.2 ArrayBufferByteLength ( arrayBuffer, order ), https://tc39.es/ecma262/#sec-arraybufferbytelength
 inline size_t array_buffer_byte_length(ArrayBuffer const& array_buffer, ArrayBuffer::Order)
diff --git a/Libraries/LibJS/Runtime/ArrayBufferConstructor.cpp b/Libraries/LibJS/Runtime/ArrayBufferConstructor.cpp
index 42bafef8913..3e9a2077b60 100644
--- a/Libraries/LibJS/Runtime/ArrayBufferConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ArrayBufferConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayBufferConstructor);
+GC_DEFINE_ALLOCATOR(ArrayBufferConstructor);
 
 ArrayBufferConstructor::ArrayBufferConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.ArrayBuffer.as_string(), realm.intrinsics().function_prototype())
@@ -48,7 +48,7 @@ ThrowCompletionOr<Value> ArrayBufferConstructor::call()
 }
 
 // 25.1.4.1 ArrayBuffer ( length [ , options ] ), https://tc39.es/ecma262/#sec-arraybuffer-length
-ThrowCompletionOr<NonnullGCPtr<Object>> ArrayBufferConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ArrayBufferConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/ArrayBufferConstructor.h b/Libraries/LibJS/Runtime/ArrayBufferConstructor.h
index 041fb1360c7..c0ef3480341 100644
--- a/Libraries/LibJS/Runtime/ArrayBufferConstructor.h
+++ b/Libraries/LibJS/Runtime/ArrayBufferConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class ArrayBufferConstructor final : public NativeFunction {
     JS_OBJECT(ArrayBufferConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ArrayBufferConstructor);
+    GC_DECLARE_ALLOCATOR(ArrayBufferConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ArrayBufferConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ArrayBufferConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/ArrayBufferPrototype.cpp b/Libraries/LibJS/Runtime/ArrayBufferPrototype.cpp
index 1c778d599af..80d1b57541b 100644
--- a/Libraries/LibJS/Runtime/ArrayBufferPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ArrayBufferPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayBufferPrototype);
+GC_DEFINE_ALLOCATOR(ArrayBufferPrototype);
 
 ArrayBufferPrototype::ArrayBufferPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/ArrayBufferPrototype.h b/Libraries/LibJS/Runtime/ArrayBufferPrototype.h
index 72e95bd9216..73f4c52f920 100644
--- a/Libraries/LibJS/Runtime/ArrayBufferPrototype.h
+++ b/Libraries/LibJS/Runtime/ArrayBufferPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class ArrayBufferPrototype final : public PrototypeObject<ArrayBufferPrototype, ArrayBuffer> {
     JS_PROTOTYPE_OBJECT(ArrayBufferPrototype, ArrayBuffer, ArrayBuffer);
-    JS_DECLARE_ALLOCATOR(ArrayBufferPrototype);
+    GC_DECLARE_ALLOCATOR(ArrayBufferPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ArrayConstructor.cpp b/Libraries/LibJS/Runtime/ArrayConstructor.cpp
index 37da813c0e1..735a8f1b76a 100644
--- a/Libraries/LibJS/Runtime/ArrayConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ArrayConstructor.cpp
@@ -22,7 +22,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayConstructor);
+GC_DEFINE_ALLOCATOR(ArrayConstructor);
 
 ArrayConstructor::ArrayConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Array.as_string(), realm.intrinsics().function_prototype())
@@ -57,7 +57,7 @@ ThrowCompletionOr<Value> ArrayConstructor::call()
 }
 
 // 23.1.1.1 Array ( ...values ), https://tc39.es/ecma262/#sec-array
-ThrowCompletionOr<NonnullGCPtr<Object>> ArrayConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ArrayConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
@@ -149,7 +149,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from)
     auto constructor = vm.this_value();
 
     // 2. If mapfn is undefined, let mapping be false.
-    GCPtr<FunctionObject> mapfn;
+    GC::Ptr<FunctionObject> mapfn;
 
     // 3. Else,
     if (!mapfn_value.is_undefined()) {
@@ -166,7 +166,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from)
 
     // 5. If usingIterator is not undefined, then
     if (using_iterator) {
-        GCPtr<Object> array;
+        GC::Ptr<Object> array;
 
         // a. If IsConstructor(C) is true, then
         if (constructor.is_constructor()) {
@@ -245,7 +245,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from)
     // 8. Let len be ? LengthOfArrayLike(arrayLike).
     auto length = TRY(length_of_array_like(vm, array_like));
 
-    GCPtr<Object> array;
+    GC::Ptr<Object> array;
 
     // 9. If IsConstructor(C) is true, then
     if (constructor.is_constructor()) {
@@ -306,7 +306,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from_async)
     auto promise_capability = MUST(new_promise_capability(vm, realm.intrinsics().promise_constructor()));
 
     // 3. Let fromAsyncClosure be a new Abstract Closure with no parameters that captures C, mapfn, and thisArg and performs the following steps when called:
-    auto from_async_closure = create_heap_function(realm.heap(), [constructor, mapfn, this_arg, &vm, &realm, async_items]() mutable -> Completion {
+    auto from_async_closure = GC::create_function(realm.heap(), [constructor, mapfn, this_arg, &vm, &realm, async_items]() mutable -> Completion {
         bool mapping;
 
         // a. If mapfn is undefined, let mapping be false.
@@ -326,7 +326,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from_async)
         // c. Let usingAsyncIterator be ? GetMethod(asyncItems, @@asyncIterator).
         auto using_async_iterator = TRY(async_items.get_method(vm, vm.well_known_symbol_async_iterator()));
 
-        GCPtr<FunctionObject> using_sync_iterator;
+        GC::Ptr<FunctionObject> using_sync_iterator;
 
         // d. If usingAsyncIterator is undefined, then
         if (!using_async_iterator) {
@@ -335,7 +335,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from_async)
         }
 
         // e. Let iteratorRecord be undefined.
-        GCPtr<IteratorRecord> iterator_record;
+        GC::Ptr<IteratorRecord> iterator_record;
 
         // f. If usingAsyncIterator is not undefined, then
         if (using_async_iterator) {
@@ -352,7 +352,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from_async)
 
         // h. If iteratorRecord is not undefined, then
         if (iterator_record) {
-            GCPtr<Object> array;
+            GC::Ptr<Object> array;
 
             // i. If IsConstructor(C) is true, then
             if (constructor.is_constructor()) {
@@ -458,7 +458,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::from_async)
             // iii. Let len be ? LengthOfArrayLike(arrayLike).
             auto length = TRY(length_of_array_like(vm, array_like));
 
-            GCPtr<Object> array;
+            GC::Ptr<Object> array;
 
             // iv. If IsConstructor(C) is true, then
             if (constructor.is_constructor()) {
@@ -542,7 +542,7 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayConstructor::of)
     // 3. Let C be the this value.
     auto constructor = vm.this_value();
 
-    GCPtr<Object> array;
+    GC::Ptr<Object> array;
 
     // 4. If IsConstructor(C) is true, then
     if (constructor.is_constructor()) {
diff --git a/Libraries/LibJS/Runtime/ArrayConstructor.h b/Libraries/LibJS/Runtime/ArrayConstructor.h
index 205931232d5..6d31b080606 100644
--- a/Libraries/LibJS/Runtime/ArrayConstructor.h
+++ b/Libraries/LibJS/Runtime/ArrayConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class ArrayConstructor final : public NativeFunction {
     JS_OBJECT(ArrayConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ArrayConstructor);
+    GC_DECLARE_ALLOCATOR(ArrayConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ArrayConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ArrayConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/ArrayIterator.cpp b/Libraries/LibJS/Runtime/ArrayIterator.cpp
index 27db58465c7..1ff8f9f7cce 100644
--- a/Libraries/LibJS/Runtime/ArrayIterator.cpp
+++ b/Libraries/LibJS/Runtime/ArrayIterator.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayIterator);
+GC_DEFINE_ALLOCATOR(ArrayIterator);
 
-NonnullGCPtr<ArrayIterator> ArrayIterator::create(Realm& realm, Value array, Object::PropertyKind iteration_kind)
+GC::Ref<ArrayIterator> ArrayIterator::create(Realm& realm, Value array, Object::PropertyKind iteration_kind)
 {
     return realm.create<ArrayIterator>(array, iteration_kind, realm.intrinsics().array_iterator_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/ArrayIterator.h b/Libraries/LibJS/Runtime/ArrayIterator.h
index 034d35e3814..92c3114418d 100644
--- a/Libraries/LibJS/Runtime/ArrayIterator.h
+++ b/Libraries/LibJS/Runtime/ArrayIterator.h
@@ -12,10 +12,10 @@ namespace JS {
 
 class ArrayIterator final : public Object {
     JS_OBJECT(ArrayIterator, Object);
-    JS_DECLARE_ALLOCATOR(ArrayIterator);
+    GC_DECLARE_ALLOCATOR(ArrayIterator);
 
 public:
-    static NonnullGCPtr<ArrayIterator> create(Realm&, Value array, Object::PropertyKind iteration_kind);
+    static GC::Ref<ArrayIterator> create(Realm&, Value array, Object::PropertyKind iteration_kind);
 
     virtual ~ArrayIterator() override = default;
 
diff --git a/Libraries/LibJS/Runtime/ArrayIteratorPrototype.cpp b/Libraries/LibJS/Runtime/ArrayIteratorPrototype.cpp
index c3f9dea450c..589c62fb2fc 100644
--- a/Libraries/LibJS/Runtime/ArrayIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ArrayIteratorPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayIteratorPrototype);
+GC_DEFINE_ALLOCATOR(ArrayIteratorPrototype);
 
 ArrayIteratorPrototype::ArrayIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/ArrayIteratorPrototype.h b/Libraries/LibJS/Runtime/ArrayIteratorPrototype.h
index 34e2c22e7e9..aac5c3d39e6 100644
--- a/Libraries/LibJS/Runtime/ArrayIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/ArrayIteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class ArrayIteratorPrototype final : public PrototypeObject<ArrayIteratorPrototype, ArrayIterator> {
     JS_PROTOTYPE_OBJECT(ArrayIteratorPrototype, ArrayIterator, ArrayIterator);
-    JS_DECLARE_ALLOCATOR(ArrayIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(ArrayIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ArrayPrototype.cpp b/Libraries/LibJS/Runtime/ArrayPrototype.cpp
index d47962c0db9..e566edc9cdf 100644
--- a/Libraries/LibJS/Runtime/ArrayPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ArrayPrototype.cpp
@@ -27,9 +27,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ArrayPrototype);
+GC_DEFINE_ALLOCATOR(ArrayPrototype);
 
-static HashTable<NonnullGCPtr<Object>> s_array_join_seen_objects;
+static HashTable<GC::Ref<Object>> s_array_join_seen_objects;
 
 ArrayPrototype::ArrayPrototype(Realm& realm)
     : Array(realm.intrinsics().object_prototype())
@@ -1339,15 +1339,15 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayPrototype::some)
     return Value(false);
 }
 
-ThrowCompletionOr<void> array_merge_sort(VM& vm, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, MarkedVector<Value>& arr_to_sort)
+ThrowCompletionOr<void> array_merge_sort(VM& vm, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::MarkedVector<Value>& arr_to_sort)
 {
     // FIXME: it would probably be better to switch to insertion sort for small arrays for
     // better performance
     if (arr_to_sort.size() <= 1)
         return {};
 
-    MarkedVector<Value> left(vm.heap());
-    MarkedVector<Value> right(vm.heap());
+    GC::MarkedVector<Value> left(vm.heap());
+    GC::MarkedVector<Value> right(vm.heap());
 
     left.ensure_capacity(arr_to_sort.size() / 2);
     right.ensure_capacity(arr_to_sort.size() / 2 + (arr_to_sort.size() & 1));
diff --git a/Libraries/LibJS/Runtime/ArrayPrototype.h b/Libraries/LibJS/Runtime/ArrayPrototype.h
index 4cd603c4677..c19f51839ed 100644
--- a/Libraries/LibJS/Runtime/ArrayPrototype.h
+++ b/Libraries/LibJS/Runtime/ArrayPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class ArrayPrototype final : public Array {
     JS_OBJECT(ArrayPrototype, Array);
-    JS_DECLARE_ALLOCATOR(ArrayPrototype);
+    GC_DECLARE_ALLOCATOR(ArrayPrototype);
 
 public:
     virtual void initialize(Realm&) override;
@@ -64,6 +64,6 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(with);
 };
 
-ThrowCompletionOr<void> array_merge_sort(VM&, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, MarkedVector<Value>& arr_to_sort);
+ThrowCompletionOr<void> array_merge_sort(VM&, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::MarkedVector<Value>& arr_to_sort);
 
 }
diff --git a/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp b/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp
index aa0773a33f7..b4fc3b03914 100644
--- a/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp
+++ b/Libraries/LibJS/Runtime/AsyncFromSyncIterator.cpp
@@ -11,14 +11,14 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncFromSyncIterator);
+GC_DEFINE_ALLOCATOR(AsyncFromSyncIterator);
 
-NonnullGCPtr<AsyncFromSyncIterator> AsyncFromSyncIterator::create(Realm& realm, NonnullGCPtr<IteratorRecord> sync_iterator_record)
+GC::Ref<AsyncFromSyncIterator> AsyncFromSyncIterator::create(Realm& realm, GC::Ref<IteratorRecord> sync_iterator_record)
 {
     return realm.create<AsyncFromSyncIterator>(realm, sync_iterator_record);
 }
 
-AsyncFromSyncIterator::AsyncFromSyncIterator(Realm& realm, NonnullGCPtr<IteratorRecord> sync_iterator_record)
+AsyncFromSyncIterator::AsyncFromSyncIterator(Realm& realm, GC::Ref<IteratorRecord> sync_iterator_record)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().async_from_sync_iterator_prototype())
     , m_sync_iterator_record(sync_iterator_record)
 {
diff --git a/Libraries/LibJS/Runtime/AsyncFromSyncIterator.h b/Libraries/LibJS/Runtime/AsyncFromSyncIterator.h
index 747fedb61fc..cf8a314ecac 100644
--- a/Libraries/LibJS/Runtime/AsyncFromSyncIterator.h
+++ b/Libraries/LibJS/Runtime/AsyncFromSyncIterator.h
@@ -15,10 +15,10 @@ namespace JS {
 // 27.1.4.3 Properties of Async-from-Sync Iterator Instances, https://tc39.es/ecma262/#sec-properties-of-async-from-sync-iterator-instances
 class AsyncFromSyncIterator final : public Object {
     JS_OBJECT(AsyncFromSyncIterator, Object);
-    JS_DECLARE_ALLOCATOR(AsyncFromSyncIterator);
+    GC_DECLARE_ALLOCATOR(AsyncFromSyncIterator);
 
 public:
-    static NonnullGCPtr<AsyncFromSyncIterator> create(Realm&, NonnullGCPtr<IteratorRecord> sync_iterator_record);
+    static GC::Ref<AsyncFromSyncIterator> create(Realm&, GC::Ref<IteratorRecord> sync_iterator_record);
 
     virtual ~AsyncFromSyncIterator() override = default;
 
@@ -28,9 +28,9 @@ public:
     IteratorRecord const& sync_iterator_record() const { return m_sync_iterator_record; }
 
 private:
-    AsyncFromSyncIterator(Realm&, NonnullGCPtr<IteratorRecord> sync_iterator_record);
+    AsyncFromSyncIterator(Realm&, GC::Ref<IteratorRecord> sync_iterator_record);
 
-    NonnullGCPtr<IteratorRecord> m_sync_iterator_record; // [[SyncIteratorRecord]]
+    GC::Ref<IteratorRecord> m_sync_iterator_record; // [[SyncIteratorRecord]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.cpp b/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.cpp
index e80231f8ed0..cd75136779f 100644
--- a/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncFromSyncIteratorPrototype);
+GC_DEFINE_ALLOCATOR(AsyncFromSyncIteratorPrototype);
 
 AsyncFromSyncIteratorPrototype::AsyncFromSyncIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().async_iterator_prototype())
@@ -199,7 +199,7 @@ JS_DEFINE_NATIVE_FUNCTION(AsyncFromSyncIteratorPrototype::throw_)
 }
 
 // 27.1.4.1 CreateAsyncFromSyncIterator ( syncIteratorRecord ), https://tc39.es/ecma262/#sec-createasyncfromsynciterator
-NonnullGCPtr<IteratorRecord> create_async_from_sync_iterator(VM& vm, NonnullGCPtr<IteratorRecord> sync_iterator_record)
+GC::Ref<IteratorRecord> create_async_from_sync_iterator(VM& vm, GC::Ref<IteratorRecord> sync_iterator_record)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.h b/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.h
index 684fc90de22..4995143e681 100644
--- a/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/AsyncFromSyncIteratorPrototype.h
@@ -17,7 +17,7 @@ namespace JS {
 // 27.1.4.2 The %AsyncFromSyncIteratorPrototype% Object, https://tc39.es/ecma262/#sec-%asyncfromsynciteratorprototype%-object
 class AsyncFromSyncIteratorPrototype final : public PrototypeObject<AsyncFromSyncIteratorPrototype, AsyncFromSyncIterator> {
     JS_PROTOTYPE_OBJECT(AsyncFromSyncIteratorPrototype, AsyncFromSyncIterator, AsyncFromSyncIterator);
-    JS_DECLARE_ALLOCATOR(AsyncFromSyncIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(AsyncFromSyncIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
@@ -31,6 +31,6 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(throw_);
 };
 
-NonnullGCPtr<IteratorRecord> create_async_from_sync_iterator(VM&, NonnullGCPtr<IteratorRecord> sync_iterator);
+GC::Ref<IteratorRecord> create_async_from_sync_iterator(VM&, GC::Ref<IteratorRecord> sync_iterator);
 
 }
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionConstructor.cpp b/Libraries/LibJS/Runtime/AsyncFunctionConstructor.cpp
index 2e027279a59..e37fc15dab1 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionConstructor.cpp
+++ b/Libraries/LibJS/Runtime/AsyncFunctionConstructor.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncFunctionConstructor);
+GC_DEFINE_ALLOCATOR(AsyncFunctionConstructor);
 
 AsyncFunctionConstructor::AsyncFunctionConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.AsyncFunction.as_string(), realm.intrinsics().function_constructor())
@@ -37,7 +37,7 @@ ThrowCompletionOr<Value> AsyncFunctionConstructor::call()
 }
 
 // 27.7.1.1 AsyncFunction ( ...parameterArgs, bodyArg ), https://tc39.es/ecma262/#sec-async-function-constructor-arguments
-ThrowCompletionOr<NonnullGCPtr<Object>> AsyncFunctionConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> AsyncFunctionConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionConstructor.h b/Libraries/LibJS/Runtime/AsyncFunctionConstructor.h
index 4a3795d0295..01ff33e4517 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionConstructor.h
+++ b/Libraries/LibJS/Runtime/AsyncFunctionConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class AsyncFunctionConstructor final : public NativeFunction {
     JS_OBJECT(AsyncFunctionConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(AsyncFunctionConstructor);
+    GC_DECLARE_ALLOCATOR(AsyncFunctionConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~AsyncFunctionConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit AsyncFunctionConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.cpp b/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.cpp
index 45fc34caac1..8e59f1fcc6c 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.cpp
+++ b/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.cpp
@@ -15,9 +15,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncFunctionDriverWrapper);
+GC_DEFINE_ALLOCATOR(AsyncFunctionDriverWrapper);
 
-NonnullGCPtr<Promise> AsyncFunctionDriverWrapper::create(Realm& realm, GeneratorObject* generator_object)
+GC::Ref<Promise> AsyncFunctionDriverWrapper::create(Realm& realm, GeneratorObject* generator_object)
 {
     auto top_level_promise = Promise::create(realm);
     // Note: The top_level_promise is also kept alive by this Wrapper
@@ -29,7 +29,7 @@ NonnullGCPtr<Promise> AsyncFunctionDriverWrapper::create(Realm& realm, Generator
     return top_level_promise;
 }
 
-AsyncFunctionDriverWrapper::AsyncFunctionDriverWrapper(Realm& realm, NonnullGCPtr<GeneratorObject> generator_object, NonnullGCPtr<Promise> top_level_promise)
+AsyncFunctionDriverWrapper::AsyncFunctionDriverWrapper(Realm& realm, GC::Ref<GeneratorObject> generator_object, GC::Ref<Promise> top_level_promise)
     : Promise(realm.intrinsics().promise_prototype())
     , m_generator_object(generator_object)
     , m_top_level_promise(top_level_promise)
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.h b/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.h
index 919f2d40a97..23b9e113190 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.h
+++ b/Libraries/LibJS/Runtime/AsyncFunctionDriverWrapper.h
@@ -16,7 +16,7 @@ namespace JS {
 
 class AsyncFunctionDriverWrapper final : public Promise {
     JS_OBJECT(AsyncFunctionDriverWrapper, Promise);
-    JS_DECLARE_ALLOCATOR(AsyncFunctionDriverWrapper);
+    GC_DECLARE_ALLOCATOR(AsyncFunctionDriverWrapper);
 
 public:
     enum class IsInitialExecution {
@@ -24,7 +24,7 @@ public:
         Yes,
     };
 
-    [[nodiscard]] static NonnullGCPtr<Promise> create(Realm&, GeneratorObject*);
+    [[nodiscard]] static GC::Ref<Promise> create(Realm&, GeneratorObject*);
 
     virtual ~AsyncFunctionDriverWrapper() override = default;
     void visit_edges(Cell::Visitor&) override;
@@ -32,12 +32,12 @@ public:
     void continue_async_execution(VM&, Value, bool is_successful, IsInitialExecution is_initial_execution = IsInitialExecution::No);
 
 private:
-    AsyncFunctionDriverWrapper(Realm&, NonnullGCPtr<GeneratorObject>, NonnullGCPtr<Promise> top_level_promise);
+    AsyncFunctionDriverWrapper(Realm&, GC::Ref<GeneratorObject>, GC::Ref<Promise> top_level_promise);
     ThrowCompletionOr<void> await(Value);
 
-    NonnullGCPtr<GeneratorObject> m_generator_object;
-    NonnullGCPtr<Promise> m_top_level_promise;
-    GCPtr<Promise> m_current_promise { nullptr };
+    GC::Ref<GeneratorObject> m_generator_object;
+    GC::Ref<Promise> m_top_level_promise;
+    GC::Ptr<Promise> m_current_promise { nullptr };
     OwnPtr<ExecutionContext> m_suspended_execution_context;
 };
 
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionPrototype.cpp b/Libraries/LibJS/Runtime/AsyncFunctionPrototype.cpp
index 8b98fd144b3..4392bc1ae7b 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AsyncFunctionPrototype.cpp
@@ -9,7 +9,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncFunctionPrototype);
+GC_DEFINE_ALLOCATOR(AsyncFunctionPrototype);
 
 AsyncFunctionPrototype::AsyncFunctionPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().function_prototype())
diff --git a/Libraries/LibJS/Runtime/AsyncFunctionPrototype.h b/Libraries/LibJS/Runtime/AsyncFunctionPrototype.h
index 4bec053fbf7..6bf3351f573 100644
--- a/Libraries/LibJS/Runtime/AsyncFunctionPrototype.h
+++ b/Libraries/LibJS/Runtime/AsyncFunctionPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class AsyncFunctionPrototype final : public Object {
     JS_OBJECT(AsyncFunctionPrototype, Object);
-    JS_DECLARE_ALLOCATOR(AsyncFunctionPrototype);
+    GC_DECLARE_ALLOCATOR(AsyncFunctionPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/AsyncGenerator.cpp b/Libraries/LibJS/Runtime/AsyncGenerator.cpp
index 3e2cf55e97b..6356e2cf17f 100644
--- a/Libraries/LibJS/Runtime/AsyncGenerator.cpp
+++ b/Libraries/LibJS/Runtime/AsyncGenerator.cpp
@@ -14,9 +14,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncGenerator);
+GC_DEFINE_ALLOCATOR(AsyncGenerator);
 
-ThrowCompletionOr<NonnullGCPtr<AsyncGenerator>> AsyncGenerator::create(Realm& realm, Value initial_value, ECMAScriptFunctionObject* generating_function, NonnullOwnPtr<ExecutionContext> execution_context)
+ThrowCompletionOr<GC::Ref<AsyncGenerator>> AsyncGenerator::create(Realm& realm, Value initial_value, ECMAScriptFunctionObject* generating_function, NonnullOwnPtr<ExecutionContext> execution_context)
 {
     auto& vm = realm.vm();
     // This is "g1.prototype" in figure-2 (https://tc39.es/ecma262/img/figure-2.png)
@@ -51,7 +51,7 @@ void AsyncGenerator::visit_edges(Cell::Visitor& visitor)
 }
 
 // 27.6.3.4 AsyncGeneratorEnqueue ( generator, completion, promiseCapability ), https://tc39.es/ecma262/#sec-asyncgeneratorenqueue
-void AsyncGenerator::async_generator_enqueue(Completion completion, NonnullGCPtr<PromiseCapability> promise_capability)
+void AsyncGenerator::async_generator_enqueue(Completion completion, GC::Ref<PromiseCapability> promise_capability)
 {
     // 1. Let request be AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }.
     auto request = AsyncGeneratorRequest { .completion = move(completion), .capability = promise_capability };
@@ -458,7 +458,7 @@ void AsyncGenerator::complete_step(Completion completion, bool done, Realm* real
         // a. Assert: completion.[[Type]] is normal.
         VERIFY(completion.type() == Completion::Type::Normal);
 
-        GCPtr<Object> iterator_result;
+        GC::Ptr<Object> iterator_result;
 
         // b. If realm is present, then
         if (realm) {
diff --git a/Libraries/LibJS/Runtime/AsyncGenerator.h b/Libraries/LibJS/Runtime/AsyncGenerator.h
index f2f9cffc7ea..3be3e206e4d 100644
--- a/Libraries/LibJS/Runtime/AsyncGenerator.h
+++ b/Libraries/LibJS/Runtime/AsyncGenerator.h
@@ -17,7 +17,7 @@ namespace JS {
 // 27.6.2 Properties of AsyncGenerator Instances, https://tc39.es/ecma262/#sec-properties-of-asyncgenerator-intances
 class AsyncGenerator final : public Object {
     JS_OBJECT(AsyncGenerator, Object);
-    JS_DECLARE_ALLOCATOR(AsyncGenerator);
+    GC_DECLARE_ALLOCATOR(AsyncGenerator);
 
 public:
     enum class State {
@@ -28,11 +28,11 @@ public:
         Completed,
     };
 
-    static ThrowCompletionOr<NonnullGCPtr<AsyncGenerator>> create(Realm&, Value, ECMAScriptFunctionObject*, NonnullOwnPtr<ExecutionContext>);
+    static ThrowCompletionOr<GC::Ref<AsyncGenerator>> create(Realm&, Value, ECMAScriptFunctionObject*, NonnullOwnPtr<ExecutionContext>);
 
     virtual ~AsyncGenerator() override;
 
-    void async_generator_enqueue(Completion, NonnullGCPtr<PromiseCapability>);
+    void async_generator_enqueue(Completion, GC::Ref<PromiseCapability>);
     ThrowCompletionOr<void> resume(VM&, Completion completion);
     void await_return();
     void complete_step(Completion, bool done, Realm* realm = nullptr);
@@ -58,9 +58,9 @@ private:
     Vector<AsyncGeneratorRequest> m_async_generator_queue;     // [[AsyncGeneratorQueue]]
     Optional<String> m_generator_brand;                        // [[GeneratorBrand]]
 
-    GCPtr<ECMAScriptFunctionObject> m_generating_function;
+    GC::Ptr<ECMAScriptFunctionObject> m_generating_function;
     Value m_previous_value;
-    GCPtr<Promise> m_current_promise;
+    GC::Ptr<Promise> m_current_promise;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.cpp b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.cpp
index 055667e45eb..0ed9fd202c1 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.cpp
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncGeneratorFunctionConstructor);
+GC_DEFINE_ALLOCATOR(AsyncGeneratorFunctionConstructor);
 
 AsyncGeneratorFunctionConstructor::AsyncGeneratorFunctionConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.AsyncGeneratorFunction.as_string(), realm.intrinsics().function_prototype())
@@ -38,7 +38,7 @@ ThrowCompletionOr<Value> AsyncGeneratorFunctionConstructor::call()
 }
 
 // 27.4.1.1 AsyncGeneratorFunction ( ...parameterArgs, bodyArg ), https://tc39.es/ecma262/#sec-asyncgeneratorfunction
-ThrowCompletionOr<NonnullGCPtr<Object>> AsyncGeneratorFunctionConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> AsyncGeneratorFunctionConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.h b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.h
index 351520ace8d..9365ea495a2 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.h
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class AsyncGeneratorFunctionConstructor final : public NativeFunction {
     JS_OBJECT(AsyncGeneratorFunctionConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(AsyncGeneratorFunctionConstructor);
+    GC_DECLARE_ALLOCATOR(AsyncGeneratorFunctionConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~AsyncGeneratorFunctionConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit AsyncGeneratorFunctionConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.cpp b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.cpp
index f56da2e4e3e..577f2c1d563 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncGeneratorFunctionPrototype);
+GC_DEFINE_ALLOCATOR(AsyncGeneratorFunctionPrototype);
 
 AsyncGeneratorFunctionPrototype::AsyncGeneratorFunctionPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().function_prototype())
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.h b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.h
index 209fd76dffb..2790d5abccc 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.h
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorFunctionPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class AsyncGeneratorFunctionPrototype final : public PrototypeObject<AsyncGeneratorFunctionPrototype, AsyncGeneratorFunction> {
     JS_PROTOTYPE_OBJECT(AsyncGeneratorFunctionPrototype, AsyncGeneratorFunction, AsyncGeneratorFunction);
-    JS_DECLARE_ALLOCATOR(AsyncGeneratorFunctionPrototype);
+    GC_DECLARE_ALLOCATOR(AsyncGeneratorFunctionPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.cpp b/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.cpp
index ac1de396f2f..96ea884d899 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncGeneratorPrototype);
+GC_DEFINE_ALLOCATOR(AsyncGeneratorPrototype);
 
 // 27.6.1 Properties of the AsyncGenerator Prototype Object, https://tc39.es/ecma262/#sec-properties-of-asyncgenerator-prototype
 AsyncGeneratorPrototype::AsyncGeneratorPrototype(Realm& realm)
@@ -34,7 +34,7 @@ void AsyncGeneratorPrototype::initialize(Realm& realm)
 }
 
 // 27.6.3.3 AsyncGeneratorValidate ( generator, generatorBrand ), https://tc39.es/ecma262/#sec-asyncgeneratorvalidate
-static ThrowCompletionOr<NonnullGCPtr<AsyncGenerator>> async_generator_validate(VM& vm, Value generator, Optional<String> generator_brand)
+static ThrowCompletionOr<GC::Ref<AsyncGenerator>> async_generator_validate(VM& vm, Value generator, Optional<String> generator_brand)
 {
     // 1. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorContext]]).
     // 2. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorState]]).
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.h b/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.h
index a231e72358e..daea67ba0a5 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.h
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class AsyncGeneratorPrototype final : public PrototypeObject<AsyncGeneratorPrototype, AsyncGenerator> {
     JS_PROTOTYPE_OBJECT(AsyncGeneratorPrototype, AsyncGenerator, AsyncGenerator)
-    JS_DECLARE_ALLOCATOR(AsyncGeneratorPrototype);
+    GC_DECLARE_ALLOCATOR(AsyncGeneratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/AsyncGeneratorRequest.h b/Libraries/LibJS/Runtime/AsyncGeneratorRequest.h
index 7be045fab04..36c99714fdc 100644
--- a/Libraries/LibJS/Runtime/AsyncGeneratorRequest.h
+++ b/Libraries/LibJS/Runtime/AsyncGeneratorRequest.h
@@ -13,8 +13,8 @@ namespace JS {
 
 // 27.6.3.1 AsyncGeneratorRequest Records, https://tc39.es/ecma262/#sec-asyncgeneratorrequest-records
 struct AsyncGeneratorRequest {
-    Completion completion;                      // [[Completion]]
-    NonnullGCPtr<PromiseCapability> capability; // [[Capability]]
+    Completion completion;                 // [[Completion]]
+    GC::Ref<PromiseCapability> capability; // [[Capability]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/AsyncIteratorPrototype.cpp b/Libraries/LibJS/Runtime/AsyncIteratorPrototype.cpp
index ead650764e1..26d99450320 100644
--- a/Libraries/LibJS/Runtime/AsyncIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/AsyncIteratorPrototype.cpp
@@ -8,7 +8,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AsyncIteratorPrototype);
+GC_DEFINE_ALLOCATOR(AsyncIteratorPrototype);
 
 AsyncIteratorPrototype::AsyncIteratorPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/AsyncIteratorPrototype.h b/Libraries/LibJS/Runtime/AsyncIteratorPrototype.h
index 4a08ff249ec..f1eb3895617 100644
--- a/Libraries/LibJS/Runtime/AsyncIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/AsyncIteratorPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class AsyncIteratorPrototype final : public Object {
     JS_OBJECT(AsyncIteratorPrototype, Object)
-    JS_DECLARE_ALLOCATOR(AsyncIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(AsyncIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/AtomicsObject.cpp b/Libraries/LibJS/Runtime/AtomicsObject.cpp
index 26904aaa167..27574df959d 100644
--- a/Libraries/LibJS/Runtime/AtomicsObject.cpp
+++ b/Libraries/LibJS/Runtime/AtomicsObject.cpp
@@ -25,7 +25,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AtomicsObject);
+GC_DEFINE_ALLOCATOR(AtomicsObject);
 
 // 25.4.2.1 ValidateIntegerTypedArray ( typedArray, waitable ), https://tc39.es/ecma262/#sec-validateintegertypedarray
 static ThrowCompletionOr<TypedArrayWithBufferWitness> validate_integer_typed_array(VM& vm, TypedArrayBase const& typed_array, bool waitable)
diff --git a/Libraries/LibJS/Runtime/AtomicsObject.h b/Libraries/LibJS/Runtime/AtomicsObject.h
index 49fdd1040fa..3ace57e2a55 100644
--- a/Libraries/LibJS/Runtime/AtomicsObject.h
+++ b/Libraries/LibJS/Runtime/AtomicsObject.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class AtomicsObject : public Object {
     JS_OBJECT(AtomicsObject, Object);
-    JS_DECLARE_ALLOCATOR(AtomicsObject);
+    GC_DECLARE_ALLOCATOR(AtomicsObject);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/BigInt.cpp b/Libraries/LibJS/Runtime/BigInt.cpp
index f7b3428c5dd..4e01b4117a9 100644
--- a/Libraries/LibJS/Runtime/BigInt.cpp
+++ b/Libraries/LibJS/Runtime/BigInt.cpp
@@ -5,15 +5,15 @@
  */
 
 #include <LibCrypto/BigInt/SignedBigInteger.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/BigInt.h>
 #include <LibJS/Runtime/GlobalObject.h>
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BigInt);
+GC_DEFINE_ALLOCATOR(BigInt);
 
-NonnullGCPtr<BigInt> BigInt::create(VM& vm, Crypto::SignedBigInteger big_integer)
+GC::Ref<BigInt> BigInt::create(VM& vm, Crypto::SignedBigInteger big_integer)
 {
     return vm.heap().allocate<BigInt>(move(big_integer));
 }
diff --git a/Libraries/LibJS/Runtime/BigInt.h b/Libraries/LibJS/Runtime/BigInt.h
index 498a02adb6a..50e6ff60b23 100644
--- a/Libraries/LibJS/Runtime/BigInt.h
+++ b/Libraries/LibJS/Runtime/BigInt.h
@@ -10,17 +10,17 @@
 #include <AK/String.h>
 #include <AK/StringView.h>
 #include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 
 namespace JS {
 
 class BigInt final : public Cell {
-    JS_CELL(BigInt, Cell);
-    JS_DECLARE_ALLOCATOR(BigInt);
+    GC_CELL(BigInt, Cell);
+    GC_DECLARE_ALLOCATOR(BigInt);
 
 public:
-    [[nodiscard]] static NonnullGCPtr<BigInt> create(VM&, Crypto::SignedBigInteger);
+    [[nodiscard]] static GC::Ref<BigInt> create(VM&, Crypto::SignedBigInteger);
 
     virtual ~BigInt() override = default;
 
diff --git a/Libraries/LibJS/Runtime/BigIntConstructor.cpp b/Libraries/LibJS/Runtime/BigIntConstructor.cpp
index 53f9c597560..a101b8878fb 100644
--- a/Libraries/LibJS/Runtime/BigIntConstructor.cpp
+++ b/Libraries/LibJS/Runtime/BigIntConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BigIntConstructor);
+GC_DEFINE_ALLOCATOR(BigIntConstructor);
 
 static Crypto::SignedBigInteger const BIGINT_ONE { 1 };
 
@@ -58,7 +58,7 @@ ThrowCompletionOr<Value> BigIntConstructor::call()
 }
 
 // 21.2.1.1 BigInt ( value ), https://tc39.es/ecma262/#sec-bigint-constructor-number-value
-ThrowCompletionOr<NonnullGCPtr<Object>> BigIntConstructor::construct(FunctionObject&)
+ThrowCompletionOr<GC::Ref<Object>> BigIntConstructor::construct(FunctionObject&)
 {
     return vm().throw_completion<TypeError>(ErrorType::NotAConstructor, "BigInt");
 }
diff --git a/Libraries/LibJS/Runtime/BigIntConstructor.h b/Libraries/LibJS/Runtime/BigIntConstructor.h
index 0dd08537f5e..e2218b8f68c 100644
--- a/Libraries/LibJS/Runtime/BigIntConstructor.h
+++ b/Libraries/LibJS/Runtime/BigIntConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class BigIntConstructor final : public NativeFunction {
     JS_OBJECT(BigIntConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(BigIntConstructor);
+    GC_DECLARE_ALLOCATOR(BigIntConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~BigIntConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit BigIntConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/BigIntObject.cpp b/Libraries/LibJS/Runtime/BigIntObject.cpp
index 8857efc9ede..fe915bdeeb8 100644
--- a/Libraries/LibJS/Runtime/BigIntObject.cpp
+++ b/Libraries/LibJS/Runtime/BigIntObject.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BigIntObject);
+GC_DEFINE_ALLOCATOR(BigIntObject);
 
-NonnullGCPtr<BigIntObject> BigIntObject::create(Realm& realm, BigInt& bigint)
+GC::Ref<BigIntObject> BigIntObject::create(Realm& realm, BigInt& bigint)
 {
     return realm.create<BigIntObject>(bigint, realm.intrinsics().bigint_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/BigIntObject.h b/Libraries/LibJS/Runtime/BigIntObject.h
index d0d0b232805..0696c31cd85 100644
--- a/Libraries/LibJS/Runtime/BigIntObject.h
+++ b/Libraries/LibJS/Runtime/BigIntObject.h
@@ -13,10 +13,10 @@ namespace JS {
 
 class BigIntObject final : public Object {
     JS_OBJECT(BigIntObject, Object);
-    JS_DECLARE_ALLOCATOR(BigIntObject);
+    GC_DECLARE_ALLOCATOR(BigIntObject);
 
 public:
-    static NonnullGCPtr<BigIntObject> create(Realm&, BigInt&);
+    static GC::Ref<BigIntObject> create(Realm&, BigInt&);
 
     virtual ~BigIntObject() override = default;
 
@@ -28,7 +28,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<BigInt> m_bigint;
+    GC::Ref<BigInt> m_bigint;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/BigIntPrototype.cpp b/Libraries/LibJS/Runtime/BigIntPrototype.cpp
index 6047a0d6fa4..952355f7a66 100644
--- a/Libraries/LibJS/Runtime/BigIntPrototype.cpp
+++ b/Libraries/LibJS/Runtime/BigIntPrototype.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BigIntPrototype);
+GC_DEFINE_ALLOCATOR(BigIntPrototype);
 
 BigIntPrototype::BigIntPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
@@ -38,7 +38,7 @@ void BigIntPrototype::initialize(Realm& realm)
 }
 
 // thisBigIntValue ( value ), https://tc39.es/ecma262/#thisbigintvalue
-static ThrowCompletionOr<NonnullGCPtr<BigInt>> this_bigint_value(VM& vm, Value value)
+static ThrowCompletionOr<GC::Ref<BigInt>> this_bigint_value(VM& vm, Value value)
 {
     // 1. If value is a BigInt, return value.
     if (value.is_bigint())
diff --git a/Libraries/LibJS/Runtime/BigIntPrototype.h b/Libraries/LibJS/Runtime/BigIntPrototype.h
index b6f87390ba6..ba88a43b33e 100644
--- a/Libraries/LibJS/Runtime/BigIntPrototype.h
+++ b/Libraries/LibJS/Runtime/BigIntPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class BigIntPrototype final : public Object {
     JS_OBJECT(BigIntPrototype, Object);
-    JS_DECLARE_ALLOCATOR(BigIntPrototype);
+    GC_DECLARE_ALLOCATOR(BigIntPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/BooleanConstructor.cpp b/Libraries/LibJS/Runtime/BooleanConstructor.cpp
index 3ce42d580db..2ed8fd3d116 100644
--- a/Libraries/LibJS/Runtime/BooleanConstructor.cpp
+++ b/Libraries/LibJS/Runtime/BooleanConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BooleanConstructor);
+GC_DEFINE_ALLOCATOR(BooleanConstructor);
 
 BooleanConstructor::BooleanConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Boolean.as_string(), realm.intrinsics().function_prototype())
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> BooleanConstructor::call()
 }
 
 // 20.3.1.1 Boolean ( value ), https://tc39.es/ecma262/#sec-boolean-constructor-boolean-value
-ThrowCompletionOr<NonnullGCPtr<Object>> BooleanConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> BooleanConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto value = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/BooleanConstructor.h b/Libraries/LibJS/Runtime/BooleanConstructor.h
index 3cd4be965cd..1fcedc295bc 100644
--- a/Libraries/LibJS/Runtime/BooleanConstructor.h
+++ b/Libraries/LibJS/Runtime/BooleanConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class BooleanConstructor final : public NativeFunction {
     JS_OBJECT(BooleanConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(BooleanConstructor);
+    GC_DECLARE_ALLOCATOR(BooleanConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~BooleanConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit BooleanConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/BooleanObject.cpp b/Libraries/LibJS/Runtime/BooleanObject.cpp
index 5df3cf39e1c..c7852818121 100644
--- a/Libraries/LibJS/Runtime/BooleanObject.cpp
+++ b/Libraries/LibJS/Runtime/BooleanObject.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BooleanObject);
+GC_DEFINE_ALLOCATOR(BooleanObject);
 
-NonnullGCPtr<BooleanObject> BooleanObject::create(Realm& realm, bool value)
+GC::Ref<BooleanObject> BooleanObject::create(Realm& realm, bool value)
 {
     return realm.create<BooleanObject>(value, realm.intrinsics().boolean_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/BooleanObject.h b/Libraries/LibJS/Runtime/BooleanObject.h
index 609d3d2c9f0..ae97c51b68c 100644
--- a/Libraries/LibJS/Runtime/BooleanObject.h
+++ b/Libraries/LibJS/Runtime/BooleanObject.h
@@ -12,10 +12,10 @@ namespace JS {
 
 class BooleanObject : public Object {
     JS_OBJECT(BooleanObject, Object);
-    JS_DECLARE_ALLOCATOR(BooleanObject);
+    GC_DECLARE_ALLOCATOR(BooleanObject);
 
 public:
-    static NonnullGCPtr<BooleanObject> create(Realm&, bool);
+    static GC::Ref<BooleanObject> create(Realm&, bool);
 
     virtual ~BooleanObject() override = default;
 
diff --git a/Libraries/LibJS/Runtime/BooleanPrototype.cpp b/Libraries/LibJS/Runtime/BooleanPrototype.cpp
index 6729f38e293..22f118da7b8 100644
--- a/Libraries/LibJS/Runtime/BooleanPrototype.cpp
+++ b/Libraries/LibJS/Runtime/BooleanPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BooleanPrototype);
+GC_DEFINE_ALLOCATOR(BooleanPrototype);
 
 BooleanPrototype::BooleanPrototype(Realm& realm)
     : BooleanObject(false, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/BooleanPrototype.h b/Libraries/LibJS/Runtime/BooleanPrototype.h
index 0db725dd2c9..10651a55474 100644
--- a/Libraries/LibJS/Runtime/BooleanPrototype.h
+++ b/Libraries/LibJS/Runtime/BooleanPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class BooleanPrototype final : public BooleanObject {
     JS_OBJECT(BooleanPrototype, BooleanObject);
-    JS_DECLARE_ALLOCATOR(BooleanPrototype);
+    GC_DECLARE_ALLOCATOR(BooleanPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/BoundFunction.cpp b/Libraries/LibJS/Runtime/BoundFunction.cpp
index 7b416092c19..85f8ef701b1 100644
--- a/Libraries/LibJS/Runtime/BoundFunction.cpp
+++ b/Libraries/LibJS/Runtime/BoundFunction.cpp
@@ -11,10 +11,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(BoundFunction);
+GC_DEFINE_ALLOCATOR(BoundFunction);
 
 // 10.4.1.3 BoundFunctionCreate ( targetFunction, boundThis, boundArgs ), https://tc39.es/ecma262/#sec-boundfunctioncreate
-ThrowCompletionOr<NonnullGCPtr<BoundFunction>> BoundFunction::create(Realm& realm, FunctionObject& target_function, Value bound_this, Vector<Value> bound_arguments)
+ThrowCompletionOr<GC::Ref<BoundFunction>> BoundFunction::create(Realm& realm, FunctionObject& target_function, Value bound_this, Vector<Value> bound_arguments)
 {
     // 1. Let proto be ? targetFunction.[[GetPrototypeOf]]().
     auto* prototype = TRY(target_function.internal_get_prototype_of());
@@ -69,7 +69,7 @@ ThrowCompletionOr<Value> BoundFunction::internal_call([[maybe_unused]] Value thi
 }
 
 // 10.4.1.2 [[Construct]] ( argumentsList, newTarget ), https://tc39.es/ecma262/#sec-bound-function-exotic-objects-construct-argumentslist-newtarget
-ThrowCompletionOr<NonnullGCPtr<Object>> BoundFunction::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> BoundFunction::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -83,7 +83,7 @@ ThrowCompletionOr<NonnullGCPtr<Object>> BoundFunction::internal_construct(Readon
     auto& bound_args = m_bound_arguments;
 
     // 4. Let args be the list-concatenation of boundArgs and argumentsList.
-    auto args = MarkedVector<Value> { heap() };
+    auto args = GC::MarkedVector<Value> { heap() };
     args.extend(bound_args);
     args.append(arguments_list.data(), arguments_list.size());
 
diff --git a/Libraries/LibJS/Runtime/BoundFunction.h b/Libraries/LibJS/Runtime/BoundFunction.h
index e5d4796f72d..50f9e0353dd 100644
--- a/Libraries/LibJS/Runtime/BoundFunction.h
+++ b/Libraries/LibJS/Runtime/BoundFunction.h
@@ -13,15 +13,15 @@ namespace JS {
 
 class BoundFunction final : public FunctionObject {
     JS_OBJECT(BoundFunction, FunctionObject);
-    JS_DECLARE_ALLOCATOR(BoundFunction);
+    GC_DECLARE_ALLOCATOR(BoundFunction);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<BoundFunction>> create(Realm&, FunctionObject& target_function, Value bound_this, Vector<Value> bound_arguments);
+    static ThrowCompletionOr<GC::Ref<BoundFunction>> create(Realm&, FunctionObject& target_function, Value bound_this, Vector<Value> bound_arguments);
 
     virtual ~BoundFunction() override = default;
 
     virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
 
     virtual DeprecatedFlyString const& name() const override { return m_name; }
     virtual bool is_strict_mode() const override { return m_bound_target_function->is_strict_mode(); }
@@ -36,9 +36,9 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<FunctionObject> m_bound_target_function; // [[BoundTargetFunction]]
-    Value m_bound_this;                            // [[BoundThis]]
-    Vector<Value> m_bound_arguments;               // [[BoundArguments]]
+    GC::Ptr<FunctionObject> m_bound_target_function; // [[BoundTargetFunction]]
+    Value m_bound_this;                              // [[BoundThis]]
+    Vector<Value> m_bound_arguments;                 // [[BoundArguments]]
 
     DeprecatedFlyString m_name;
 };
diff --git a/Libraries/LibJS/Runtime/ClassFieldDefinition.h b/Libraries/LibJS/Runtime/ClassFieldDefinition.h
index 6e97461aed4..72aada6e339 100644
--- a/Libraries/LibJS/Runtime/ClassFieldDefinition.h
+++ b/Libraries/LibJS/Runtime/ClassFieldDefinition.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibJS/Runtime/Environment.h>
 
 namespace JS {
@@ -17,8 +17,8 @@ using ClassElementName = Variant<PropertyKey, PrivateName>;
 
 // 6.2.10 The ClassFieldDefinition Record Specification Type, https://tc39.es/ecma262/#sec-classfielddefinition-record-specification-type
 struct ClassFieldDefinition {
-    ClassElementName name;                       // [[Name]]
-    GCPtr<ECMAScriptFunctionObject> initializer; // [[Initializer]]
+    ClassElementName name;                         // [[Name]]
+    GC::Ptr<ECMAScriptFunctionObject> initializer; // [[Initializer]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Completion.cpp b/Libraries/LibJS/Runtime/Completion.cpp
index f466893f8b5..e24e363d48f 100644
--- a/Libraries/LibJS/Runtime/Completion.cpp
+++ b/Libraries/LibJS/Runtime/Completion.cpp
@@ -101,7 +101,7 @@ ThrowCompletionOr<Value> await(VM& vm, Value value)
     //        running all queued promise jobs.
     // Note: This is not used by LibJS itself, and is performed for the embedder (i.e. LibWeb).
     if (auto* custom_data = vm.custom_data()) {
-        custom_data->spin_event_loop_until(create_heap_function(vm.heap(), [success] {
+        custom_data->spin_event_loop_until(GC::create_function(vm.heap(), [success] {
             return success.has_value();
         }));
     }
diff --git a/Libraries/LibJS/Runtime/ConsoleObject.cpp b/Libraries/LibJS/Runtime/ConsoleObject.cpp
index ba27247212a..1fbb26eccc5 100644
--- a/Libraries/LibJS/Runtime/ConsoleObject.cpp
+++ b/Libraries/LibJS/Runtime/ConsoleObject.cpp
@@ -13,9 +13,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ConsoleObject);
+GC_DEFINE_ALLOCATOR(ConsoleObject);
 
-static NonnullGCPtr<ConsoleObjectPrototype> create_console_prototype(Realm& realm)
+static GC::Ref<ConsoleObjectPrototype> create_console_prototype(Realm& realm)
 {
     return realm.create<ConsoleObjectPrototype>(realm);
 }
diff --git a/Libraries/LibJS/Runtime/ConsoleObject.h b/Libraries/LibJS/Runtime/ConsoleObject.h
index ded6f6c5d19..b7586908ac8 100644
--- a/Libraries/LibJS/Runtime/ConsoleObject.h
+++ b/Libraries/LibJS/Runtime/ConsoleObject.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class ConsoleObject final : public Object {
     JS_OBJECT(ConsoleObject, Object);
-    JS_DECLARE_ALLOCATOR(ConsoleObject);
+    GC_DECLARE_ALLOCATOR(ConsoleObject);
 
 public:
     virtual void initialize(Realm&) override;
@@ -43,7 +43,7 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(time_log);
     JS_DECLARE_NATIVE_FUNCTION(time_end);
 
-    GCPtr<Console> m_console;
+    GC::Ptr<Console> m_console;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/ConsoleObjectPrototype.cpp b/Libraries/LibJS/Runtime/ConsoleObjectPrototype.cpp
index a403e838340..9b8349bb9dd 100644
--- a/Libraries/LibJS/Runtime/ConsoleObjectPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ConsoleObjectPrototype.cpp
@@ -22,7 +22,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ConsoleObjectPrototype);
+GC_DEFINE_ALLOCATOR(ConsoleObjectPrototype);
 
 ConsoleObjectPrototype::ConsoleObjectPrototype(JS::Realm& realm)
     : Object(JS::Object::ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/ConsoleObjectPrototype.h b/Libraries/LibJS/Runtime/ConsoleObjectPrototype.h
index e1b4a05c1a7..705e7adb55e 100644
--- a/Libraries/LibJS/Runtime/ConsoleObjectPrototype.h
+++ b/Libraries/LibJS/Runtime/ConsoleObjectPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class ConsoleObjectPrototype final : public Object {
     JS_OBJECT(ConsoleObjectPrototype, Object);
-    JS_DECLARE_ALLOCATOR(ConsoleObjectPrototype);
+    GC_DECLARE_ALLOCATOR(ConsoleObjectPrototype);
 
 public:
     virtual void initialize(JS::Realm&) override;
diff --git a/Libraries/LibJS/Runtime/DataView.cpp b/Libraries/LibJS/Runtime/DataView.cpp
index 232eed3df42..15b81a65e8a 100644
--- a/Libraries/LibJS/Runtime/DataView.cpp
+++ b/Libraries/LibJS/Runtime/DataView.cpp
@@ -8,9 +8,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DataView);
+GC_DEFINE_ALLOCATOR(DataView);
 
-NonnullGCPtr<DataView> DataView::create(Realm& realm, ArrayBuffer* viewed_buffer, ByteLength byte_length, size_t byte_offset)
+GC::Ref<DataView> DataView::create(Realm& realm, ArrayBuffer* viewed_buffer, ByteLength byte_length, size_t byte_offset)
 {
     return realm.create<DataView>(viewed_buffer, move(byte_length), byte_offset, realm.intrinsics().data_view_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/DataView.h b/Libraries/LibJS/Runtime/DataView.h
index cbf45864256..e451c022bf2 100644
--- a/Libraries/LibJS/Runtime/DataView.h
+++ b/Libraries/LibJS/Runtime/DataView.h
@@ -15,10 +15,10 @@ namespace JS {
 
 class DataView : public Object {
     JS_OBJECT(DataView, Object);
-    JS_DECLARE_ALLOCATOR(DataView);
+    GC_DECLARE_ALLOCATOR(DataView);
 
 public:
-    static NonnullGCPtr<DataView> create(Realm&, ArrayBuffer*, ByteLength byte_length, size_t byte_offset);
+    static GC::Ref<DataView> create(Realm&, ArrayBuffer*, ByteLength byte_length, size_t byte_offset);
 
     virtual ~DataView() override = default;
 
@@ -31,14 +31,14 @@ private:
 
     virtual void visit_edges(Visitor& visitor) override;
 
-    GCPtr<ArrayBuffer> m_viewed_array_buffer;
+    GC::Ptr<ArrayBuffer> m_viewed_array_buffer;
     ByteLength m_byte_length { 0 };
     size_t m_byte_offset { 0 };
 };
 
 // 25.3.1.1 DataView With Buffer Witness Records, https://tc39.es/ecma262/#sec-dataview-with-buffer-witness-records
 struct DataViewWithBufferWitness {
-    NonnullGCPtr<DataView const> object;  // [[Object]]
+    GC::Ref<DataView const> object;       // [[Object]]
     ByteLength cached_buffer_byte_length; // [[CachedBufferByteLength]]
 };
 
diff --git a/Libraries/LibJS/Runtime/DataViewConstructor.cpp b/Libraries/LibJS/Runtime/DataViewConstructor.cpp
index 06731cf3840..7bf3f4ce474 100644
--- a/Libraries/LibJS/Runtime/DataViewConstructor.cpp
+++ b/Libraries/LibJS/Runtime/DataViewConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DataViewConstructor);
+GC_DEFINE_ALLOCATOR(DataViewConstructor);
 
 DataViewConstructor::DataViewConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.DataView.as_string(), realm.intrinsics().function_prototype())
@@ -42,7 +42,7 @@ ThrowCompletionOr<Value> DataViewConstructor::call()
 }
 
 // 25.3.2.1 DataView ( buffer [ , byteOffset [ , byteLength ] ] ), https://tc39.es/ecma262/#sec-dataview-buffer-byteoffset-bytelength
-ThrowCompletionOr<NonnullGCPtr<Object>> DataViewConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DataViewConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/DataViewConstructor.h b/Libraries/LibJS/Runtime/DataViewConstructor.h
index 81cd43688a4..476b79c297f 100644
--- a/Libraries/LibJS/Runtime/DataViewConstructor.h
+++ b/Libraries/LibJS/Runtime/DataViewConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class DataViewConstructor final : public NativeFunction {
     JS_OBJECT(DataViewConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DataViewConstructor);
+    GC_DECLARE_ALLOCATOR(DataViewConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DataViewConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit DataViewConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/DataViewPrototype.cpp b/Libraries/LibJS/Runtime/DataViewPrototype.cpp
index f190b346d37..cdd8c7e8212 100644
--- a/Libraries/LibJS/Runtime/DataViewPrototype.cpp
+++ b/Libraries/LibJS/Runtime/DataViewPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DataViewPrototype);
+GC_DEFINE_ALLOCATOR(DataViewPrototype);
 
 DataViewPrototype::DataViewPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/DataViewPrototype.h b/Libraries/LibJS/Runtime/DataViewPrototype.h
index 184a0717595..9689e4a049c 100644
--- a/Libraries/LibJS/Runtime/DataViewPrototype.h
+++ b/Libraries/LibJS/Runtime/DataViewPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class DataViewPrototype final : public PrototypeObject<DataViewPrototype, DataView> {
     JS_PROTOTYPE_OBJECT(DataViewPrototype, DataView, DataView);
-    JS_DECLARE_ALLOCATOR(DataViewPrototype);
+    GC_DECLARE_ALLOCATOR(DataViewPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Date.cpp b/Libraries/LibJS/Runtime/Date.cpp
index 0334ad3168e..b5d9c42e458 100644
--- a/Libraries/LibJS/Runtime/Date.cpp
+++ b/Libraries/LibJS/Runtime/Date.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Date);
+GC_DEFINE_ALLOCATOR(Date);
 
 static Crypto::SignedBigInteger const s_one_billion_bigint { 1'000'000'000 };
 static Crypto::SignedBigInteger const s_one_million_bigint { 1'000'000 };
@@ -25,7 +25,7 @@ static Crypto::SignedBigInteger const s_one_thousand_bigint { 1'000 };
 
 Crypto::SignedBigInteger const ns_per_day_bigint { static_cast<i64>(ns_per_day) };
 
-NonnullGCPtr<Date> Date::create(Realm& realm, double date_value)
+GC::Ref<Date> Date::create(Realm& realm, double date_value)
 {
     return realm.create<Date>(date_value, realm.intrinsics().date_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/Date.h b/Libraries/LibJS/Runtime/Date.h
index 58103963c54..17da2fdd9f8 100644
--- a/Libraries/LibJS/Runtime/Date.h
+++ b/Libraries/LibJS/Runtime/Date.h
@@ -15,10 +15,10 @@ namespace JS {
 
 class Date final : public Object {
     JS_OBJECT(Date, Object);
-    JS_DECLARE_ALLOCATOR(Date);
+    GC_DECLARE_ALLOCATOR(Date);
 
 public:
-    static NonnullGCPtr<Date> create(Realm&, double date_value);
+    static GC::Ref<Date> create(Realm&, double date_value);
 
     // Out of line to ensure we have a key function
     virtual ~Date() override;
diff --git a/Libraries/LibJS/Runtime/DateConstructor.cpp b/Libraries/LibJS/Runtime/DateConstructor.cpp
index e71b351e31a..801eda3586f 100644
--- a/Libraries/LibJS/Runtime/DateConstructor.cpp
+++ b/Libraries/LibJS/Runtime/DateConstructor.cpp
@@ -23,7 +23,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DateConstructor);
+GC_DEFINE_ALLOCATOR(DateConstructor);
 
 // 21.4.3.2 Date.parse ( string ), https://tc39.es/ecma262/#sec-date.parse
 static double parse_simplified_iso8601(ByteString const& iso_8601)
@@ -237,7 +237,7 @@ ThrowCompletionOr<Value> DateConstructor::call()
 }
 
 // 21.4.2.1 Date ( ...values ), https://tc39.es/ecma262/#sec-date
-ThrowCompletionOr<NonnullGCPtr<Object>> DateConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DateConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/DateConstructor.h b/Libraries/LibJS/Runtime/DateConstructor.h
index 5b9ef47efdd..c8a108d6884 100644
--- a/Libraries/LibJS/Runtime/DateConstructor.h
+++ b/Libraries/LibJS/Runtime/DateConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class DateConstructor final : public NativeFunction {
     JS_OBJECT(DateConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DateConstructor);
+    GC_DECLARE_ALLOCATOR(DateConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DateConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit DateConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/DatePrototype.cpp b/Libraries/LibJS/Runtime/DatePrototype.cpp
index e123edf6d34..980d5d16c94 100644
--- a/Libraries/LibJS/Runtime/DatePrototype.cpp
+++ b/Libraries/LibJS/Runtime/DatePrototype.cpp
@@ -30,7 +30,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DatePrototype);
+GC_DEFINE_ALLOCATOR(DatePrototype);
 
 DatePrototype::DatePrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/DatePrototype.h b/Libraries/LibJS/Runtime/DatePrototype.h
index 49135b179d6..8160ff2911a 100644
--- a/Libraries/LibJS/Runtime/DatePrototype.h
+++ b/Libraries/LibJS/Runtime/DatePrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class DatePrototype final : public PrototypeObject<DatePrototype, Date> {
     JS_PROTOTYPE_OBJECT(DatePrototype, Date, Date);
-    JS_DECLARE_ALLOCATOR(DatePrototype);
+    GC_DECLARE_ALLOCATOR(DatePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/DeclarativeEnvironment.cpp b/Libraries/LibJS/Runtime/DeclarativeEnvironment.cpp
index abb77f151ce..6bc3b33561a 100644
--- a/Libraries/LibJS/Runtime/DeclarativeEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/DeclarativeEnvironment.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DeclarativeEnvironment);
+GC_DEFINE_ALLOCATOR(DeclarativeEnvironment);
 
 DeclarativeEnvironment* DeclarativeEnvironment::create_for_per_iteration_bindings(Badge<ForStatement>, DeclarativeEnvironment& other, size_t bindings_size)
 {
diff --git a/Libraries/LibJS/Runtime/DeclarativeEnvironment.h b/Libraries/LibJS/Runtime/DeclarativeEnvironment.h
index 76061a37b47..2a9e1dcbff8 100644
--- a/Libraries/LibJS/Runtime/DeclarativeEnvironment.h
+++ b/Libraries/LibJS/Runtime/DeclarativeEnvironment.h
@@ -17,7 +17,7 @@ namespace JS {
 
 class DeclarativeEnvironment : public Environment {
     JS_ENVIRONMENT(DeclarativeEnvironment, Environment);
-    JS_DECLARE_ALLOCATOR(DeclarativeEnvironment);
+    GC_DECLARE_ALLOCATOR(DeclarativeEnvironment);
 
     struct Binding {
         DeprecatedFlyString name;
@@ -73,7 +73,7 @@ private:
     ThrowCompletionOr<Value> get_binding_value_direct(VM&, Binding const&) const;
     ThrowCompletionOr<void> set_mutable_binding_direct(VM&, Binding&, Value, bool strict);
 
-    friend Completion dispose_resources(VM&, GCPtr<DeclarativeEnvironment>, Completion);
+    friend Completion dispose_resources(VM&, GC::Ptr<DeclarativeEnvironment>, Completion);
     Vector<DisposableResource> const& disposable_resource_stack() const { return m_disposable_resource_stack; }
 
 protected:
diff --git a/Libraries/LibJS/Runtime/DisposableStack.cpp b/Libraries/LibJS/Runtime/DisposableStack.cpp
index 62fe33d1655..bfca0571d22 100644
--- a/Libraries/LibJS/Runtime/DisposableStack.cpp
+++ b/Libraries/LibJS/Runtime/DisposableStack.cpp
@@ -8,7 +8,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DisposableStack);
+GC_DEFINE_ALLOCATOR(DisposableStack);
 
 DisposableStack::DisposableStack(Vector<DisposableResource> stack, Object& prototype)
     : Object(ConstructWithPrototypeTag::Tag, prototype)
diff --git a/Libraries/LibJS/Runtime/DisposableStack.h b/Libraries/LibJS/Runtime/DisposableStack.h
index 36af8e047d7..d0e2d8d6151 100644
--- a/Libraries/LibJS/Runtime/DisposableStack.h
+++ b/Libraries/LibJS/Runtime/DisposableStack.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class DisposableStack final : public Object {
     JS_OBJECT(DisposableStack, Object);
-    JS_DECLARE_ALLOCATOR(DisposableStack);
+    GC_DECLARE_ALLOCATOR(DisposableStack);
 
 public:
     virtual ~DisposableStack() override = default;
diff --git a/Libraries/LibJS/Runtime/DisposableStackConstructor.cpp b/Libraries/LibJS/Runtime/DisposableStackConstructor.cpp
index 7b9b06aaa7f..7d811b5f3f2 100644
--- a/Libraries/LibJS/Runtime/DisposableStackConstructor.cpp
+++ b/Libraries/LibJS/Runtime/DisposableStackConstructor.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DisposableStackConstructor);
+GC_DEFINE_ALLOCATOR(DisposableStackConstructor);
 
 DisposableStackConstructor::DisposableStackConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.DisposableStack.as_string(), realm.intrinsics().function_prototype())
@@ -38,7 +38,7 @@ ThrowCompletionOr<Value> DisposableStackConstructor::call()
 }
 
 // 11.3.1.1 DisposableStack ( ), https://tc39.es/proposal-explicit-resource-management/#sec-disposablestack
-ThrowCompletionOr<NonnullGCPtr<Object>> DisposableStackConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DisposableStackConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/DisposableStackConstructor.h b/Libraries/LibJS/Runtime/DisposableStackConstructor.h
index 6a190c2011b..8b956e4e3d9 100644
--- a/Libraries/LibJS/Runtime/DisposableStackConstructor.h
+++ b/Libraries/LibJS/Runtime/DisposableStackConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class DisposableStackConstructor final : public NativeFunction {
     JS_OBJECT(DisposableStackConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DisposableStackConstructor);
+    GC_DECLARE_ALLOCATOR(DisposableStackConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DisposableStackConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit DisposableStackConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/DisposableStackPrototype.cpp b/Libraries/LibJS/Runtime/DisposableStackPrototype.cpp
index d6a6ead81de..7fd01bab3ee 100644
--- a/Libraries/LibJS/Runtime/DisposableStackPrototype.cpp
+++ b/Libraries/LibJS/Runtime/DisposableStackPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(DisposableStackPrototype);
+GC_DEFINE_ALLOCATOR(DisposableStackPrototype);
 
 DisposableStackPrototype::DisposableStackPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
@@ -136,7 +136,7 @@ JS_DEFINE_NATIVE_FUNCTION(DisposableStackPrototype::adopt)
     // 11.3.3.4.1 DisposableStack Adopt Callback Functions, https://tc39.es/proposal-explicit-resource-management/#sec-disposablestack-adopt-callback-functions
     // A DisposableStack adopt callback function is an anonymous built-in function object that has [[Argument]] and [[OnDisposeCallback]] internal slots.
     auto function = NativeFunction::create(
-        realm, [argument = make_handle(value), callback = make_handle(on_dispose)](VM& vm) {
+        realm, [argument = make_root(value), callback = make_root(on_dispose)](VM& vm) {
             // When a DisposableStack adopt callback function is called, the following steps are taken:
             // 1. Let F be the active function object.
             // 2. Assert: IsCallable(F.[[OnDisposeCallback]]) is true.
diff --git a/Libraries/LibJS/Runtime/DisposableStackPrototype.h b/Libraries/LibJS/Runtime/DisposableStackPrototype.h
index 158674f9872..a5741564572 100644
--- a/Libraries/LibJS/Runtime/DisposableStackPrototype.h
+++ b/Libraries/LibJS/Runtime/DisposableStackPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class DisposableStackPrototype final : public PrototypeObject<DisposableStackPrototype, DisposableStack> {
     JS_PROTOTYPE_OBJECT(DisposableStackPrototype, DisposableStack, DisposableStack);
-    JS_DECLARE_ALLOCATOR(DisposableStackPrototype);
+    GC_DECLARE_ALLOCATOR(DisposableStackPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp b/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
index 8508c78d0ec..df075f1a375 100644
--- a/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
+++ b/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp
@@ -31,9 +31,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ECMAScriptFunctionObject);
+GC_DEFINE_ALLOCATOR(ECMAScriptFunctionObject);
 
-NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, FunctionParsingInsights parsing_insights, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
+GC::Ref<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, FunctionParsingInsights parsing_insights, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
 {
     Object* prototype = nullptr;
     switch (kind) {
@@ -53,7 +53,7 @@ NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& r
     return realm.create<ECMAScriptFunctionObject>(move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, move(local_variables_names), parent_environment, private_environment, *prototype, kind, is_strict, parsing_insights, is_arrow_function, move(class_field_initializer_name));
 }
 
-NonnullGCPtr<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, Object& prototype, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, FunctionParsingInsights parsing_insights, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
+GC::Ref<ECMAScriptFunctionObject> ECMAScriptFunctionObject::create(Realm& realm, DeprecatedFlyString name, Object& prototype, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind kind, bool is_strict, FunctionParsingInsights parsing_insights, bool is_arrow_function, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name)
 {
     return realm.create<ECMAScriptFunctionObject>(move(name), move(source_text), ecmascript_code, move(parameters), m_function_length, move(local_variables_names), parent_environment, private_environment, prototype, kind, is_strict, parsing_insights, is_arrow_function, move(class_field_initializer_name));
 }
@@ -438,7 +438,7 @@ ThrowCompletionOr<Value> ECMAScriptFunctionObject::internal_call(Value this_argu
 }
 
 // 10.2.2 [[Construct]] ( argumentsList, newTarget ), https://tc39.es/ecma262/#sec-ecmascript-function-objects-construct-argumentslist-newtarget
-ThrowCompletionOr<NonnullGCPtr<Object>> ECMAScriptFunctionObject::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ECMAScriptFunctionObject::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -448,7 +448,7 @@ ThrowCompletionOr<NonnullGCPtr<Object>> ECMAScriptFunctionObject::internal_const
     // 2. Let kind be F.[[ConstructorKind]].
     auto kind = m_constructor_kind;
 
-    GCPtr<Object> this_argument;
+    GC::Ptr<Object> this_argument;
 
     // 3. If kind is base, then
     if (kind == ConstructorKind::Base) {
@@ -735,7 +735,7 @@ void async_block_start(VM& vm, T const& async_body, PromiseCapability const& pro
         Completion result;
 
         // a. If asyncBody is a Parse Node, then
-        if constexpr (!IsSame<T, HeapFunction<Completion()>>) {
+        if constexpr (!IsSame<T, GC::Function<Completion()>>) {
             // a. Let result be the result of evaluating asyncBody.
             // FIXME: Cache this executable somewhere.
             auto maybe_executable = Bytecode::compile(vm, async_body, FunctionKind::Async, "AsyncBlockStart"sv);
@@ -810,8 +810,8 @@ void async_block_start(VM& vm, T const& async_body, PromiseCapability const& pro
 template void async_block_start(VM&, NonnullRefPtr<Statement const> const& async_body, PromiseCapability const&, ExecutionContext&);
 template void async_function_start(VM&, PromiseCapability const&, NonnullRefPtr<Statement const> const& async_function_body);
 
-template void async_block_start(VM&, HeapFunction<Completion()> const& async_body, PromiseCapability const&, ExecutionContext&);
-template void async_function_start(VM&, PromiseCapability const&, HeapFunction<Completion()> const& async_function_body);
+template void async_block_start(VM&, GC::Function<Completion()> const& async_body, PromiseCapability const&, ExecutionContext&);
+template void async_function_start(VM&, PromiseCapability const&, GC::Function<Completion()> const& async_function_body);
 
 // 10.2.1.4 OrdinaryCallEvaluateBody ( F, argumentsList ), https://tc39.es/ecma262/#sec-ordinarycallevaluatebody
 // 15.8.4 Runtime Semantics: EvaluateAsyncFunctionBody, https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody
diff --git a/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.h b/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.h
index 46a4f602ccc..0c876f75d9e 100644
--- a/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.h
+++ b/Libraries/LibJS/Runtime/ECMAScriptFunctionObject.h
@@ -25,7 +25,7 @@ void async_function_start(VM&, PromiseCapability const&, T const& async_function
 // 10.2 ECMAScript Function Objects, https://tc39.es/ecma262/#sec-ecmascript-function-objects
 class ECMAScriptFunctionObject final : public FunctionObject {
     JS_OBJECT(ECMAScriptFunctionObject, FunctionObject);
-    JS_DECLARE_ALLOCATOR(ECMAScriptFunctionObject);
+    GC_DECLARE_ALLOCATOR(ECMAScriptFunctionObject);
 
 public:
     enum class ConstructorKind : u8 {
@@ -39,14 +39,14 @@ public:
         Global,
     };
 
-    static NonnullGCPtr<ECMAScriptFunctionObject> create(Realm&, DeprecatedFlyString name, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, FunctionParsingInsights, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
-    static NonnullGCPtr<ECMAScriptFunctionObject> create(Realm&, DeprecatedFlyString name, Object& prototype, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, FunctionParsingInsights, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
+    static GC::Ref<ECMAScriptFunctionObject> create(Realm&, DeprecatedFlyString name, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, FunctionParsingInsights, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
+    static GC::Ref<ECMAScriptFunctionObject> create(Realm&, DeprecatedFlyString name, Object& prototype, ByteString source_text, Statement const& ecmascript_code, Vector<FunctionParameter> parameters, i32 m_function_length, Vector<DeprecatedFlyString> local_variables_names, Environment* parent_environment, PrivateEnvironment* private_environment, FunctionKind, bool is_strict, FunctionParsingInsights, bool is_arrow_function = false, Variant<PropertyKey, PrivateName, Empty> class_field_initializer_name = {});
 
     virtual void initialize(Realm&) override;
     virtual ~ECMAScriptFunctionObject() override = default;
 
     virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
 
     void make_method(Object& home_object);
 
@@ -118,20 +118,20 @@ private:
     void ordinary_call_bind_this(ExecutionContext&, Value this_argument);
 
     DeprecatedFlyString m_name;
-    GCPtr<PrimitiveString> m_name_string;
+    GC::Ptr<PrimitiveString> m_name_string;
 
-    GCPtr<Bytecode::Executable> m_bytecode_executable;
+    GC::Ptr<Bytecode::Executable> m_bytecode_executable;
     i32 m_function_length { 0 };
     Vector<DeprecatedFlyString> m_local_variables_names;
 
     // Internal Slots of ECMAScript Function Objects, https://tc39.es/ecma262/#table-internal-slots-of-ecmascript-function-objects
-    GCPtr<Environment> m_environment;                                        // [[Environment]]
-    GCPtr<PrivateEnvironment> m_private_environment;                         // [[PrivateEnvironment]]
+    GC::Ptr<Environment> m_environment;                                      // [[Environment]]
+    GC::Ptr<PrivateEnvironment> m_private_environment;                       // [[PrivateEnvironment]]
     Vector<FunctionParameter> const m_formal_parameters;                     // [[FormalParameters]]
     NonnullRefPtr<Statement const> m_ecmascript_code;                        // [[ECMAScriptCode]]
-    GCPtr<Realm> m_realm;                                                    // [[Realm]]
+    GC::Ptr<Realm> m_realm;                                                  // [[Realm]]
     ScriptOrModule m_script_or_module;                                       // [[ScriptOrModule]]
-    GCPtr<Object> m_home_object;                                             // [[HomeObject]]
+    GC::Ptr<Object> m_home_object;                                           // [[HomeObject]]
     ByteString m_source_text;                                                // [[SourceText]]
     Vector<ClassFieldDefinition> m_fields;                                   // [[Fields]]
     Vector<PrivateElement> m_private_methods;                                // [[PrivateMethods]]
diff --git a/Libraries/LibJS/Runtime/Environment.h b/Libraries/LibJS/Runtime/Environment.h
index d047f7260aa..53e93aafa29 100644
--- a/Libraries/LibJS/Runtime/Environment.h
+++ b/Libraries/LibJS/Runtime/Environment.h
@@ -17,10 +17,10 @@ struct Variable {
     DeclarationKind declaration_kind;
 };
 
-#define JS_ENVIRONMENT(class_, base_class) JS_CELL(class_, base_class)
+#define JS_ENVIRONMENT(class_, base_class) GC_CELL(class_, base_class)
 
 class Environment : public Cell {
-    JS_CELL(Environment, Cell);
+    GC_CELL(Environment, Cell);
 
 public:
     enum class InitializeBindingHint {
@@ -70,7 +70,7 @@ private:
     bool m_permanently_screwed_by_eval { false };
     bool m_declarative { false };
 
-    GCPtr<Environment> m_outer_environment;
+    GC::Ptr<Environment> m_outer_environment;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Error.cpp b/Libraries/LibJS/Runtime/Error.cpp
index 4198a7f4ef6..69b1b1f0b90 100644
--- a/Libraries/LibJS/Runtime/Error.cpp
+++ b/Libraries/LibJS/Runtime/Error.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Error);
+GC_DEFINE_ALLOCATOR(Error);
 
 static SourceRange dummy_source_range { SourceCode::create(String {}, String {}), {}, {} };
 
@@ -34,12 +34,12 @@ SourceRange const& TracebackFrame::source_range() const
     return cached_source_range->source_range.get<SourceRange>();
 }
 
-NonnullGCPtr<Error> Error::create(Realm& realm)
+GC::Ref<Error> Error::create(Realm& realm)
 {
     return realm.create<Error>(realm.intrinsics().error_prototype());
 }
 
-NonnullGCPtr<Error> Error::create(Realm& realm, String message)
+GC::Ref<Error> Error::create(Realm& realm, String message)
 {
     auto& vm = realm.vm();
     auto error = Error::create(realm);
@@ -48,7 +48,7 @@ NonnullGCPtr<Error> Error::create(Realm& realm, String message)
     return error;
 }
 
-NonnullGCPtr<Error> Error::create(Realm& realm, StringView message)
+GC::Ref<Error> Error::create(Realm& realm, StringView message)
 {
     return create(realm, MUST(String::from_utf8(message)));
 }
@@ -157,13 +157,13 @@ String Error::stack_string(CompactTraceback compact) const
 }
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType)                   \
-    JS_DEFINE_ALLOCATOR(ClassName);                                                                        \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm)                                                \
+    GC_DEFINE_ALLOCATOR(ClassName);                                                                        \
+    GC::Ref<ClassName> ClassName::create(Realm& realm)                                                     \
     {                                                                                                      \
         return realm.create<ClassName>(realm.intrinsics().snake_name##_prototype());                       \
     }                                                                                                      \
                                                                                                            \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, String message)                                \
+    GC::Ref<ClassName> ClassName::create(Realm& realm, String message)                                     \
     {                                                                                                      \
         auto& vm = realm.vm();                                                                             \
         auto error = ClassName::create(realm);                                                             \
@@ -172,7 +172,7 @@ String Error::stack_string(CompactTraceback compact) const
         return error;                                                                                      \
     }                                                                                                      \
                                                                                                            \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, StringView message)                            \
+    GC::Ref<ClassName> ClassName::create(Realm& realm, StringView message)                                 \
     {                                                                                                      \
         return create(realm, MUST(String::from_utf8(message)));                                            \
     }                                                                                                      \
diff --git a/Libraries/LibJS/Runtime/Error.h b/Libraries/LibJS/Runtime/Error.h
index df847706a49..e28868f9474 100644
--- a/Libraries/LibJS/Runtime/Error.h
+++ b/Libraries/LibJS/Runtime/Error.h
@@ -29,12 +29,12 @@ enum CompactTraceback {
 
 class Error : public Object {
     JS_OBJECT(Error, Object);
-    JS_DECLARE_ALLOCATOR(Error);
+    GC_DECLARE_ALLOCATOR(Error);
 
 public:
-    static NonnullGCPtr<Error> create(Realm&);
-    static NonnullGCPtr<Error> create(Realm&, String message);
-    static NonnullGCPtr<Error> create(Realm&, StringView message);
+    static GC::Ref<Error> create(Realm&);
+    static GC::Ref<Error> create(Realm&, String message);
+    static GC::Ref<Error> create(Realm&, StringView message);
 
     virtual ~Error() override = default;
 
@@ -58,12 +58,12 @@ private:
 #define DECLARE_NATIVE_ERROR(ClassName, snake_name, PrototypeName, ConstructorName) \
     class ClassName final : public Error {                                          \
         JS_OBJECT(ClassName, Error);                                                \
-        JS_DECLARE_ALLOCATOR(ClassName);                                            \
+        GC_DECLARE_ALLOCATOR(ClassName);                                            \
                                                                                     \
     public:                                                                         \
-        static NonnullGCPtr<ClassName> create(Realm&);                              \
-        static NonnullGCPtr<ClassName> create(Realm&, String message);              \
-        static NonnullGCPtr<ClassName> create(Realm&, StringView message);          \
+        static GC::Ref<ClassName> create(Realm&);                                   \
+        static GC::Ref<ClassName> create(Realm&, String message);                   \
+        static GC::Ref<ClassName> create(Realm&, StringView message);               \
                                                                                     \
         explicit ClassName(Object& prototype);                                      \
         virtual ~ClassName() override = default;                                    \
diff --git a/Libraries/LibJS/Runtime/ErrorConstructor.cpp b/Libraries/LibJS/Runtime/ErrorConstructor.cpp
index 4e3b609a03f..5f382848926 100644
--- a/Libraries/LibJS/Runtime/ErrorConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ErrorConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ErrorConstructor);
+GC_DEFINE_ALLOCATOR(ErrorConstructor);
 
 ErrorConstructor::ErrorConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Error.as_string(), realm.intrinsics().function_prototype())
@@ -40,7 +40,7 @@ ThrowCompletionOr<Value> ErrorConstructor::call()
 }
 
 // 20.5.1.1 Error ( message [ , options ] ), https://tc39.es/ecma262/#sec-error-message
-ThrowCompletionOr<NonnullGCPtr<Object>> ErrorConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ErrorConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -67,7 +67,7 @@ ThrowCompletionOr<NonnullGCPtr<Object>> ErrorConstructor::construct(FunctionObje
 }
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType)                                    \
-    JS_DEFINE_ALLOCATOR(ConstructorName);                                                                                   \
+    GC_DEFINE_ALLOCATOR(ConstructorName);                                                                                   \
     ConstructorName::ConstructorName(Realm& realm)                                                                          \
         : NativeFunction(realm.vm().names.ClassName.as_string(), realm.intrinsics().error_constructor())                    \
     {                                                                                                                       \
@@ -94,7 +94,7 @@ ThrowCompletionOr<NonnullGCPtr<Object>> ErrorConstructor::construct(FunctionObje
     }                                                                                                                       \
                                                                                                                             \
     /* 20.5.6.1.1 NativeError ( message [ , options ] ), https://tc39.es/ecma262/#sec-nativeerror */                        \
-    ThrowCompletionOr<NonnullGCPtr<Object>> ConstructorName::construct(FunctionObject& new_target)                          \
+    ThrowCompletionOr<GC::Ref<Object>> ConstructorName::construct(FunctionObject& new_target)                               \
     {                                                                                                                       \
         auto& vm = this->vm();                                                                                              \
                                                                                                                             \
diff --git a/Libraries/LibJS/Runtime/ErrorConstructor.h b/Libraries/LibJS/Runtime/ErrorConstructor.h
index a046c05835e..7582b217a37 100644
--- a/Libraries/LibJS/Runtime/ErrorConstructor.h
+++ b/Libraries/LibJS/Runtime/ErrorConstructor.h
@@ -13,14 +13,14 @@ namespace JS {
 
 class ErrorConstructor final : public NativeFunction {
     JS_OBJECT(ErrorConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ErrorConstructor);
+    GC_DECLARE_ALLOCATOR(ErrorConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ErrorConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ErrorConstructor(Realm&);
@@ -30,24 +30,24 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(is_error);
 };
 
-#define DECLARE_NATIVE_ERROR_CONSTRUCTOR(ClassName, snake_name, PrototypeName, ConstructorName)         \
-    class ConstructorName final : public NativeFunction {                                               \
-        JS_OBJECT(ConstructorName, NativeFunction);                                                     \
-        JS_DECLARE_ALLOCATOR(ConstructorName);                                                          \
-                                                                                                        \
-    public:                                                                                             \
-        virtual void initialize(Realm&) override;                                                       \
-        virtual ~ConstructorName() override;                                                            \
-        virtual ThrowCompletionOr<Value> call() override;                                               \
-        virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override; \
-                                                                                                        \
-    private:                                                                                            \
-        explicit ConstructorName(Realm&);                                                               \
-                                                                                                        \
-        virtual bool has_constructor() const override                                                   \
-        {                                                                                               \
-            return true;                                                                                \
-        }                                                                                               \
+#define DECLARE_NATIVE_ERROR_CONSTRUCTOR(ClassName, snake_name, PrototypeName, ConstructorName)    \
+    class ConstructorName final : public NativeFunction {                                          \
+        JS_OBJECT(ConstructorName, NativeFunction);                                                \
+        GC_DECLARE_ALLOCATOR(ConstructorName);                                                     \
+                                                                                                   \
+    public:                                                                                        \
+        virtual void initialize(Realm&) override;                                                  \
+        virtual ~ConstructorName() override;                                                       \
+        virtual ThrowCompletionOr<Value> call() override;                                          \
+        virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override; \
+                                                                                                   \
+    private:                                                                                       \
+        explicit ConstructorName(Realm&);                                                          \
+                                                                                                   \
+        virtual bool has_constructor() const override                                              \
+        {                                                                                          \
+            return true;                                                                           \
+        }                                                                                          \
     };
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
diff --git a/Libraries/LibJS/Runtime/ErrorPrototype.cpp b/Libraries/LibJS/Runtime/ErrorPrototype.cpp
index 2623f029bb9..fc8e3c49f92 100644
--- a/Libraries/LibJS/Runtime/ErrorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ErrorPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ErrorPrototype);
+GC_DEFINE_ALLOCATOR(ErrorPrototype);
 
 ErrorPrototype::ErrorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
@@ -125,7 +125,7 @@ JS_DEFINE_NATIVE_FUNCTION(ErrorPrototype::stack_setter)
 }
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType)               \
-    JS_DEFINE_ALLOCATOR(PrototypeName);                                                                \
+    GC_DEFINE_ALLOCATOR(PrototypeName);                                                                \
                                                                                                        \
     PrototypeName::PrototypeName(Realm& realm)                                                         \
         : PrototypeObject(realm.intrinsics().error_prototype())                                        \
diff --git a/Libraries/LibJS/Runtime/ErrorPrototype.h b/Libraries/LibJS/Runtime/ErrorPrototype.h
index 23f44a5fac3..1edcdc9e293 100644
--- a/Libraries/LibJS/Runtime/ErrorPrototype.h
+++ b/Libraries/LibJS/Runtime/ErrorPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class ErrorPrototype final : public PrototypeObject<ErrorPrototype, Error> {
     JS_PROTOTYPE_OBJECT(ErrorPrototype, Error, Error);
-    JS_DECLARE_ALLOCATOR(ErrorPrototype);
+    GC_DECLARE_ALLOCATOR(ErrorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
@@ -31,7 +31,7 @@ private:
 #define DECLARE_NATIVE_ERROR_PROTOTYPE(ClassName, snake_name, PrototypeName, ConstructorName) \
     class PrototypeName final : public PrototypeObject<PrototypeName, ClassName> {            \
         JS_PROTOTYPE_OBJECT(PrototypeName, ClassName, ClassName);                             \
-        JS_DECLARE_ALLOCATOR(PrototypeName);                                                  \
+        GC_DECLARE_ALLOCATOR(PrototypeName);                                                  \
                                                                                               \
     public:                                                                                   \
         virtual void initialize(Realm&) override;                                             \
diff --git a/Libraries/LibJS/Runtime/ExecutionContext.cpp b/Libraries/LibJS/Runtime/ExecutionContext.cpp
index 96f3bc01aa8..3baddb9fbe5 100644
--- a/Libraries/LibJS/Runtime/ExecutionContext.cpp
+++ b/Libraries/LibJS/Runtime/ExecutionContext.cpp
@@ -6,8 +6,8 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibGC/Heap.h>
 #include <LibJS/Bytecode/Executable.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/ExecutionContext.h>
 #include <LibJS/Runtime/FunctionObject.h>
 
diff --git a/Libraries/LibJS/Runtime/ExecutionContext.h b/Libraries/LibJS/Runtime/ExecutionContext.h
index 83dc66e03fa..7eb2ec6bf90 100644
--- a/Libraries/LibJS/Runtime/ExecutionContext.h
+++ b/Libraries/LibJS/Runtime/ExecutionContext.h
@@ -19,7 +19,7 @@
 
 namespace JS {
 
-using ScriptOrModule = Variant<Empty, NonnullGCPtr<Script>, NonnullGCPtr<Module>>;
+using ScriptOrModule = Variant<Empty, GC::Ref<Script>, GC::Ref<Module>>;
 
 struct CachedSourceRange : public RefCounted<CachedSourceRange> {
     CachedSourceRange(size_t program_counter, Variant<UnrealizedSourceRange, SourceRange> source_range)
@@ -48,24 +48,24 @@ private:
 public:
     void operator delete(void* ptr);
 
-    GCPtr<FunctionObject> function;                // [[Function]]
-    GCPtr<Realm> realm;                            // [[Realm]]
-    ScriptOrModule script_or_module;               // [[ScriptOrModule]]
-    GCPtr<Environment> lexical_environment;        // [[LexicalEnvironment]]
-    GCPtr<Environment> variable_environment;       // [[VariableEnvironment]]
-    GCPtr<PrivateEnvironment> private_environment; // [[PrivateEnvironment]]
+    GC::Ptr<FunctionObject> function;                // [[Function]]
+    GC::Ptr<Realm> realm;                            // [[Realm]]
+    ScriptOrModule script_or_module;                 // [[ScriptOrModule]]
+    GC::Ptr<Environment> lexical_environment;        // [[LexicalEnvironment]]
+    GC::Ptr<Environment> variable_environment;       // [[VariableEnvironment]]
+    GC::Ptr<PrivateEnvironment> private_environment; // [[PrivateEnvironment]]
 
     // Non-standard: This points at something that owns this ExecutionContext, in case it needs to be protected from GC.
-    GCPtr<Cell> context_owner;
+    GC::Ptr<Cell> context_owner;
 
     Optional<size_t> program_counter;
 
     mutable RefPtr<CachedSourceRange> cached_source_range;
 
-    GCPtr<PrimitiveString> function_name;
+    GC::Ptr<PrimitiveString> function_name;
     Value this_value;
 
-    GCPtr<Bytecode::Executable> executable;
+    GC::Ptr<Bytecode::Executable> executable;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#skip-when-determining-incumbent-counter
     // FIXME: Move this out of LibJS (e.g. by using the CustomData concept), as it's used exclusively by LibWeb.
@@ -90,7 +90,7 @@ public:
     Vector<Value> registers_and_constants_and_locals;
     Vector<Bytecode::UnwindInfo> unwind_contexts;
     Vector<Optional<size_t>> previously_scheduled_jumps;
-    Vector<GCPtr<Environment>> saved_lexical_environments;
+    Vector<GC::Ptr<Environment>> saved_lexical_environments;
 };
 
 struct StackTraceElement {
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistry.cpp b/Libraries/LibJS/Runtime/FinalizationRegistry.cpp
index e3b2b02624a..8e5047ea481 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistry.cpp
+++ b/Libraries/LibJS/Runtime/FinalizationRegistry.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FinalizationRegistry);
+GC_DEFINE_ALLOCATOR(FinalizationRegistry);
 
-FinalizationRegistry::FinalizationRegistry(Realm& realm, NonnullGCPtr<JobCallback> cleanup_callback, Object& prototype)
+FinalizationRegistry::FinalizationRegistry(Realm& realm, GC::Ref<JobCallback> cleanup_callback, Object& prototype)
     : Object(ConstructWithPrototypeTag::Tag, prototype)
     , WeakContainer(heap())
     , m_realm(realm)
@@ -47,7 +47,7 @@ bool FinalizationRegistry::remove_by_token(Cell& unregister_token)
     return removed;
 }
 
-void FinalizationRegistry::remove_dead_cells(Badge<Heap>)
+void FinalizationRegistry::remove_dead_cells(Badge<GC::Heap>)
 {
     auto any_cells_were_removed = false;
     for (auto& record : m_records) {
@@ -62,7 +62,7 @@ void FinalizationRegistry::remove_dead_cells(Badge<Heap>)
 }
 
 // 9.13 CleanupFinalizationRegistry ( finalizationRegistry ), https://tc39.es/ecma262/#sec-cleanup-finalization-registry
-ThrowCompletionOr<void> FinalizationRegistry::cleanup(JS::GCPtr<JobCallback> callback)
+ThrowCompletionOr<void> FinalizationRegistry::cleanup(GC::Ptr<JobCallback> callback)
 {
     auto& vm = this->vm();
 
@@ -79,7 +79,7 @@ ThrowCompletionOr<void> FinalizationRegistry::cleanup(JS::GCPtr<JobCallback> cal
             continue;
 
         // b. Remove cell from finalizationRegistry.[[Cells]].
-        MarkedVector<Value> arguments(vm.heap());
+        GC::MarkedVector<Value> arguments(vm.heap());
         arguments.append(it->held_value);
         it.remove(m_records);
 
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistry.h b/Libraries/LibJS/Runtime/FinalizationRegistry.h
index 5f3527456ce..ff090143298 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistry.h
+++ b/Libraries/LibJS/Runtime/FinalizationRegistry.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/SinglyLinkedList.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/WeakContainer.h>
 #include <LibJS/Runtime/FunctionObject.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/JobCallback.h>
@@ -19,18 +19,18 @@ namespace JS {
 
 class FinalizationRegistry final
     : public Object
-    , public WeakContainer {
+    , public GC::WeakContainer {
     JS_OBJECT(FinalizationRegistry, Object);
-    JS_DECLARE_ALLOCATOR(FinalizationRegistry);
+    GC_DECLARE_ALLOCATOR(FinalizationRegistry);
 
 public:
     virtual ~FinalizationRegistry() override = default;
 
     void add_finalization_record(Cell& target, Value held_value, Cell* unregister_token);
     bool remove_by_token(Cell& unregister_token);
-    ThrowCompletionOr<void> cleanup(GCPtr<JobCallback> = {});
+    ThrowCompletionOr<void> cleanup(GC::Ptr<JobCallback> = {});
 
-    virtual void remove_dead_cells(Badge<Heap>) override;
+    virtual void remove_dead_cells(Badge<GC::Heap>) override;
 
     Realm& realm() { return *m_realm; }
     Realm const& realm() const { return *m_realm; }
@@ -39,17 +39,17 @@ public:
     JobCallback const& cleanup_callback() const { return *m_cleanup_callback; }
 
 private:
-    FinalizationRegistry(Realm&, NonnullGCPtr<JobCallback>, Object& prototype);
+    FinalizationRegistry(Realm&, GC::Ref<JobCallback>, Object& prototype);
 
     virtual void visit_edges(Visitor& visitor) override;
 
-    NonnullGCPtr<Realm> m_realm;
-    NonnullGCPtr<JobCallback> m_cleanup_callback;
+    GC::Ref<Realm> m_realm;
+    GC::Ref<JobCallback> m_cleanup_callback;
 
     struct FinalizationRecord {
-        GCPtr<Cell> target;
+        GC::Ptr<Cell> target;
         Value held_value;
-        GCPtr<Cell> unregister_token;
+        GC::Ptr<Cell> unregister_token;
     };
     SinglyLinkedList<FinalizationRecord> m_records;
 };
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.cpp b/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.cpp
index c679a78ec58..62f85e62f58 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.cpp
+++ b/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FinalizationRegistryConstructor);
+GC_DEFINE_ALLOCATOR(FinalizationRegistryConstructor);
 
 FinalizationRegistryConstructor::FinalizationRegistryConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.FinalizationRegistry.as_string(), realm.intrinsics().function_prototype())
@@ -41,7 +41,7 @@ ThrowCompletionOr<Value> FinalizationRegistryConstructor::call()
 }
 
 // 26.2.1.1 FinalizationRegistry ( cleanupCallback ), https://tc39.es/ecma262/#sec-finalization-registry-cleanup-callback
-ThrowCompletionOr<NonnullGCPtr<Object>> FinalizationRegistryConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> FinalizationRegistryConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.h b/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.h
index 7ec4a3a22cf..ba26d81efd8 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.h
+++ b/Libraries/LibJS/Runtime/FinalizationRegistryConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class FinalizationRegistryConstructor final : public NativeFunction {
     JS_OBJECT(FinalizationRegistryConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(FinalizationRegistryConstructor);
+    GC_DECLARE_ALLOCATOR(FinalizationRegistryConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~FinalizationRegistryConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit FinalizationRegistryConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.cpp b/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.cpp
index 2ae5a6092e2..fca7ffc12f4 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.cpp
+++ b/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FinalizationRegistryPrototype);
+GC_DEFINE_ALLOCATOR(FinalizationRegistryPrototype);
 
 FinalizationRegistryPrototype::FinalizationRegistryPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
@@ -47,7 +47,7 @@ JS_DEFINE_NATIVE_FUNCTION(FinalizationRegistryPrototype::cleanup_some)
     // IMPLEMENTATION DEFINED: The specification for this function hasn't been updated to accommodate for JobCallback records.
     //                         This just follows how the constructor immediately converts the callback to a JobCallback using HostMakeJobCallback.
     // 4. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback).
-    TRY(finalization_registry->cleanup(callback.is_undefined() ? GCPtr<JobCallback> {} : vm.host_make_job_callback(callback.as_function())));
+    TRY(finalization_registry->cleanup(callback.is_undefined() ? GC::Ptr<JobCallback> {} : vm.host_make_job_callback(callback.as_function())));
 
     // 5. Return undefined.
     return js_undefined();
diff --git a/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.h b/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.h
index ba6dd01e650..ffe949be9c1 100644
--- a/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.h
+++ b/Libraries/LibJS/Runtime/FinalizationRegistryPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class FinalizationRegistryPrototype final : public PrototypeObject<FinalizationRegistryPrototype, FinalizationRegistry> {
     JS_PROTOTYPE_OBJECT(FinalizationRegistryPrototype, FinalizationRegistry, FinalizationRegistry);
-    JS_DECLARE_ALLOCATOR(FinalizationRegistryPrototype);
+    GC_DECLARE_ALLOCATOR(FinalizationRegistryPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/FunctionConstructor.cpp b/Libraries/LibJS/Runtime/FunctionConstructor.cpp
index fde9ae87125..4db94b25c7b 100644
--- a/Libraries/LibJS/Runtime/FunctionConstructor.cpp
+++ b/Libraries/LibJS/Runtime/FunctionConstructor.cpp
@@ -18,7 +18,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FunctionConstructor);
+GC_DEFINE_ALLOCATOR(FunctionConstructor);
 
 FunctionConstructor::FunctionConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Function.as_string(), realm.intrinsics().function_prototype())
@@ -62,14 +62,14 @@ ThrowCompletionOr<ParameterArgumentsAndBody> extract_parameter_arguments_and_bod
 }
 
 // 20.2.1.1.1 CreateDynamicFunction ( constructor, newTarget, kind, parameterArgs, bodyArg ), https://tc39.es/ecma262/#sec-createdynamicfunction
-ThrowCompletionOr<NonnullGCPtr<ECMAScriptFunctionObject>> FunctionConstructor::create_dynamic_function(VM& vm, FunctionObject& constructor, FunctionObject* new_target, FunctionKind kind, ReadonlySpan<String> parameter_strings, String const& body_string)
+ThrowCompletionOr<GC::Ref<ECMAScriptFunctionObject>> FunctionConstructor::create_dynamic_function(VM& vm, FunctionObject& constructor, FunctionObject* new_target, FunctionKind kind, ReadonlySpan<String> parameter_strings, String const& body_string)
 {
     // 1. If newTarget is undefined, set newTarget to constructor.
     if (new_target == nullptr)
         new_target = &constructor;
 
     StringView prefix;
-    NonnullGCPtr<Object> (Intrinsics::*fallback_prototype)() = nullptr;
+    GC::Ref<Object> (Intrinsics::*fallback_prototype)() = nullptr;
 
     switch (kind) {
     // 2. If kind is normal, then
@@ -260,7 +260,7 @@ ThrowCompletionOr<Value> FunctionConstructor::call()
 }
 
 // 20.2.1.1 Function ( ...parameterArgs, bodyArg ), https://tc39.es/ecma262/#sec-function-p1-p2-pn-body
-ThrowCompletionOr<NonnullGCPtr<Object>> FunctionConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> FunctionConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/FunctionConstructor.h b/Libraries/LibJS/Runtime/FunctionConstructor.h
index 8ddef827d17..829be5976ee 100644
--- a/Libraries/LibJS/Runtime/FunctionConstructor.h
+++ b/Libraries/LibJS/Runtime/FunctionConstructor.h
@@ -20,16 +20,16 @@ ThrowCompletionOr<ParameterArgumentsAndBody> extract_parameter_arguments_and_bod
 
 class FunctionConstructor final : public NativeFunction {
     JS_OBJECT(FunctionConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(FunctionConstructor);
+    GC_DECLARE_ALLOCATOR(FunctionConstructor);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<ECMAScriptFunctionObject>> create_dynamic_function(VM&, FunctionObject& constructor, FunctionObject* new_target, FunctionKind kind, ReadonlySpan<String> parameter_args, String const& body_string);
+    static ThrowCompletionOr<GC::Ref<ECMAScriptFunctionObject>> create_dynamic_function(VM&, FunctionObject& constructor, FunctionObject* new_target, FunctionKind kind, ReadonlySpan<String> parameter_args, String const& body_string);
 
     virtual void initialize(Realm&) override;
     virtual ~FunctionConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit FunctionConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/FunctionEnvironment.cpp b/Libraries/LibJS/Runtime/FunctionEnvironment.cpp
index bfa9198b44f..734d2131857 100644
--- a/Libraries/LibJS/Runtime/FunctionEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/FunctionEnvironment.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FunctionEnvironment);
+GC_DEFINE_ALLOCATOR(FunctionEnvironment);
 
 FunctionEnvironment::FunctionEnvironment(Environment* parent_environment)
     : DeclarativeEnvironment(parent_environment)
diff --git a/Libraries/LibJS/Runtime/FunctionEnvironment.h b/Libraries/LibJS/Runtime/FunctionEnvironment.h
index a08b63f467a..d6a2f7e7e5c 100644
--- a/Libraries/LibJS/Runtime/FunctionEnvironment.h
+++ b/Libraries/LibJS/Runtime/FunctionEnvironment.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class FunctionEnvironment final : public DeclarativeEnvironment {
     JS_ENVIRONMENT(FunctionEnvironment, DeclarativeEnvironment);
-    JS_DECLARE_ALLOCATOR(FunctionEnvironment);
+    GC_DECLARE_ALLOCATOR(FunctionEnvironment);
 
 public:
     enum class ThisBindingStatus : u8 {
@@ -53,7 +53,7 @@ private:
 
     Value m_this_value;                                                           // [[ThisValue]]
     ThisBindingStatus m_this_binding_status { ThisBindingStatus::Uninitialized }; // [[ThisBindingStatus]]
-    GCPtr<ECMAScriptFunctionObject> m_function_object;                            // [[FunctionObject]]
+    GC::Ptr<ECMAScriptFunctionObject> m_function_object;                          // [[FunctionObject]]
     Value m_new_target { js_undefined() };                                        // [[NewTarget]]
 };
 
diff --git a/Libraries/LibJS/Runtime/FunctionObject.h b/Libraries/LibJS/Runtime/FunctionObject.h
index bf5e01deb99..629023f7ff7 100644
--- a/Libraries/LibJS/Runtime/FunctionObject.h
+++ b/Libraries/LibJS/Runtime/FunctionObject.h
@@ -24,7 +24,7 @@ public:
     // Table 7: Additional Essential Internal Methods of Function Objects, https://tc39.es/ecma262/#table-additional-essential-internal-methods-of-function-objects
 
     virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) = 0;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> internal_construct([[maybe_unused]] ReadonlySpan<Value> arguments_list, [[maybe_unused]] FunctionObject& new_target) { VERIFY_NOT_REACHED(); }
+    virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct([[maybe_unused]] ReadonlySpan<Value> arguments_list, [[maybe_unused]] FunctionObject& new_target) { VERIFY_NOT_REACHED(); }
 
     virtual DeprecatedFlyString const& name() const = 0;
 
diff --git a/Libraries/LibJS/Runtime/FunctionPrototype.cpp b/Libraries/LibJS/Runtime/FunctionPrototype.cpp
index b0759b9b254..5cbb5ce19f0 100644
--- a/Libraries/LibJS/Runtime/FunctionPrototype.cpp
+++ b/Libraries/LibJS/Runtime/FunctionPrototype.cpp
@@ -7,7 +7,7 @@
 #include <AK/Function.h>
 #include <AK/StringBuilder.h>
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/AbstractOperations.h>
 #include <LibJS/Runtime/BoundFunction.h>
 #include <LibJS/Runtime/ECMAScriptFunctionObject.h>
@@ -19,7 +19,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(FunctionPrototype);
+GC_DEFINE_ALLOCATOR(FunctionPrototype);
 
 FunctionPrototype::FunctionPrototype(Realm& realm)
     : FunctionObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/FunctionPrototype.h b/Libraries/LibJS/Runtime/FunctionPrototype.h
index ccd8b97a527..c37d64dea39 100644
--- a/Libraries/LibJS/Runtime/FunctionPrototype.h
+++ b/Libraries/LibJS/Runtime/FunctionPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class FunctionPrototype final : public FunctionObject {
     JS_OBJECT(FunctionPrototype, FunctionObject);
-    JS_DECLARE_ALLOCATOR(FunctionPrototype);
+    GC_DECLARE_ALLOCATOR(FunctionPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp b/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp
index cab1711c11b..2c0632d33ad 100644
--- a/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp
+++ b/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GeneratorFunctionConstructor);
+GC_DEFINE_ALLOCATOR(GeneratorFunctionConstructor);
 
 GeneratorFunctionConstructor::GeneratorFunctionConstructor(Realm& realm)
     : NativeFunction(static_cast<Object&>(realm.intrinsics().function_constructor()))
@@ -36,7 +36,7 @@ ThrowCompletionOr<Value> GeneratorFunctionConstructor::call()
 }
 
 // 27.3.1.1 GeneratorFunction ( ...parameterArgs, bodyArg ), https://tc39.es/ecma262/#sec-generatorfunction
-ThrowCompletionOr<NonnullGCPtr<Object>> GeneratorFunctionConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> GeneratorFunctionConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.h b/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.h
index 69afe6ebc85..17fa5d8213f 100644
--- a/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.h
+++ b/Libraries/LibJS/Runtime/GeneratorFunctionConstructor.h
@@ -13,14 +13,14 @@ namespace JS {
 // 27.3.1 %GeneratorFunction%, https://tc39.es/ecma262/#sec-generatorfunction-constructor
 class GeneratorFunctionConstructor final : public NativeFunction {
     JS_OBJECT(GeneratorFunctionConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(GeneratorFunctionConstructor);
+    GC_DECLARE_ALLOCATOR(GeneratorFunctionConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~GeneratorFunctionConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit GeneratorFunctionConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.cpp b/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.cpp
index c85d4154f6c..d53c7eb2fac 100644
--- a/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.cpp
+++ b/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GeneratorFunctionPrototype);
+GC_DEFINE_ALLOCATOR(GeneratorFunctionPrototype);
 
 GeneratorFunctionPrototype::GeneratorFunctionPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().function_prototype())
diff --git a/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.h b/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.h
index ecff00d2093..48d71d99206 100644
--- a/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.h
+++ b/Libraries/LibJS/Runtime/GeneratorFunctionPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 // 27.3.3 %GeneratorFunction.prototype%, https://tc39.es/ecma262/#sec-properties-of-the-generatorfunction-prototype-object
 class GeneratorFunctionPrototype final : public Object {
     JS_OBJECT(GeneratorFunctionPrototype, Object);
-    JS_DECLARE_ALLOCATOR(GeneratorFunctionPrototype);
+    GC_DECLARE_ALLOCATOR(GeneratorFunctionPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/GeneratorObject.cpp b/Libraries/LibJS/Runtime/GeneratorObject.cpp
index 75798ce6fce..76faa12d2db 100644
--- a/Libraries/LibJS/Runtime/GeneratorObject.cpp
+++ b/Libraries/LibJS/Runtime/GeneratorObject.cpp
@@ -14,9 +14,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GeneratorObject);
+GC_DEFINE_ALLOCATOR(GeneratorObject);
 
-ThrowCompletionOr<NonnullGCPtr<GeneratorObject>> GeneratorObject::create(Realm& realm, Value initial_value, ECMAScriptFunctionObject* generating_function, NonnullOwnPtr<ExecutionContext> execution_context)
+ThrowCompletionOr<GC::Ref<GeneratorObject>> GeneratorObject::create(Realm& realm, Value initial_value, ECMAScriptFunctionObject* generating_function, NonnullOwnPtr<ExecutionContext> execution_context)
 {
     auto& vm = realm.vm();
     // This is "g1.prototype" in figure-2 (https://tc39.es/ecma262/img/figure-2.png)
diff --git a/Libraries/LibJS/Runtime/GeneratorObject.h b/Libraries/LibJS/Runtime/GeneratorObject.h
index 48eb59e8679..ca3f59593ca 100644
--- a/Libraries/LibJS/Runtime/GeneratorObject.h
+++ b/Libraries/LibJS/Runtime/GeneratorObject.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class GeneratorObject : public Object {
     JS_OBJECT(GeneratorObject, Object);
-    JS_DECLARE_ALLOCATOR(GeneratorObject);
+    GC_DECLARE_ALLOCATOR(GeneratorObject);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<GeneratorObject>> create(Realm&, Value, ECMAScriptFunctionObject*, NonnullOwnPtr<ExecutionContext>);
+    static ThrowCompletionOr<GC::Ref<GeneratorObject>> create(Realm&, Value, ECMAScriptFunctionObject*, NonnullOwnPtr<ExecutionContext>);
     virtual ~GeneratorObject() override = default;
     void visit_edges(Cell::Visitor&) override;
 
@@ -41,7 +41,7 @@ protected:
 
 private:
     NonnullOwnPtr<ExecutionContext> m_execution_context;
-    GCPtr<ECMAScriptFunctionObject> m_generating_function;
+    GC::Ptr<ECMAScriptFunctionObject> m_generating_function;
     Value m_previous_value;
     GeneratorState m_generator_state { GeneratorState::SuspendedStart };
     Optional<StringView> m_generator_brand;
diff --git a/Libraries/LibJS/Runtime/GeneratorPrototype.cpp b/Libraries/LibJS/Runtime/GeneratorPrototype.cpp
index 6a65faf125f..2a971ad8629 100644
--- a/Libraries/LibJS/Runtime/GeneratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/GeneratorPrototype.cpp
@@ -9,7 +9,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GeneratorPrototype);
+GC_DEFINE_ALLOCATOR(GeneratorPrototype);
 
 GeneratorPrototype::GeneratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/GeneratorPrototype.h b/Libraries/LibJS/Runtime/GeneratorPrototype.h
index fd72f2243dd..1412008cb0f 100644
--- a/Libraries/LibJS/Runtime/GeneratorPrototype.h
+++ b/Libraries/LibJS/Runtime/GeneratorPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 // 27.5.1 Properties of the Generator Prototype Object, https://tc39.es/ecma262/#sec-properties-of-generator-prototype
 class GeneratorPrototype final : public PrototypeObject<GeneratorPrototype, GeneratorObject> {
     JS_PROTOTYPE_OBJECT(GeneratorPrototype, GeneratorObject, Generator);
-    JS_DECLARE_ALLOCATOR(GeneratorPrototype);
+    GC_DECLARE_ALLOCATOR(GeneratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/GlobalEnvironment.cpp b/Libraries/LibJS/Runtime/GlobalEnvironment.cpp
index 18600fc8e8f..35f6cc8ba65 100644
--- a/Libraries/LibJS/Runtime/GlobalEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/GlobalEnvironment.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GlobalEnvironment);
+GC_DEFINE_ALLOCATOR(GlobalEnvironment);
 
 // 9.1.2.5 NewGlobalEnvironment ( G, thisValue ), https://tc39.es/ecma262/#sec-newglobalenvironment
 GlobalEnvironment::GlobalEnvironment(Object& global_object, Object& this_value)
diff --git a/Libraries/LibJS/Runtime/GlobalEnvironment.h b/Libraries/LibJS/Runtime/GlobalEnvironment.h
index 13b65920649..b23fef7bb16 100644
--- a/Libraries/LibJS/Runtime/GlobalEnvironment.h
+++ b/Libraries/LibJS/Runtime/GlobalEnvironment.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class GlobalEnvironment final : public Environment {
     JS_ENVIRONMENT(GlobalEnvironment, Environment);
-    JS_DECLARE_ALLOCATOR(GlobalEnvironment);
+    GC_DECLARE_ALLOCATOR(GlobalEnvironment);
 
 public:
     virtual bool has_this_binding() const final { return true; }
@@ -44,10 +44,10 @@ private:
     virtual bool is_global_environment() const override { return true; }
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<ObjectEnvironment> m_object_record;           // [[ObjectRecord]]
-    GCPtr<Object> m_global_this_value;                  // [[GlobalThisValue]]
-    GCPtr<DeclarativeEnvironment> m_declarative_record; // [[DeclarativeRecord]]
-    Vector<DeprecatedFlyString> m_var_names;            // [[VarNames]]
+    GC::Ptr<ObjectEnvironment> m_object_record;           // [[ObjectRecord]]
+    GC::Ptr<Object> m_global_this_value;                  // [[GlobalThisValue]]
+    GC::Ptr<DeclarativeEnvironment> m_declarative_record; // [[DeclarativeRecord]]
+    Vector<DeprecatedFlyString> m_var_names;              // [[VarNames]]
 };
 
 template<>
diff --git a/Libraries/LibJS/Runtime/GlobalObject.cpp b/Libraries/LibJS/Runtime/GlobalObject.cpp
index e388f40d2ee..2f742f3274c 100644
--- a/Libraries/LibJS/Runtime/GlobalObject.cpp
+++ b/Libraries/LibJS/Runtime/GlobalObject.cpp
@@ -12,7 +12,7 @@
 #include <AK/UnicodeUtils.h>
 #include <AK/Utf16View.h>
 #include <AK/Utf8View.h>
-#include <LibJS/Heap/DeferGC.h>
+#include <LibGC/DeferGC.h>
 #include <LibJS/Runtime/AbstractOperations.h>
 #include <LibJS/Runtime/AggregateErrorConstructor.h>
 #include <LibJS/Runtime/ArrayBufferConstructor.h>
@@ -87,7 +87,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(GlobalObject);
+GC_DEFINE_ALLOCATOR(GlobalObject);
 
 GlobalObject::GlobalObject(Realm& realm)
     : Object(GlobalObjectTag::Tag, realm)
diff --git a/Libraries/LibJS/Runtime/GlobalObject.h b/Libraries/LibJS/Runtime/GlobalObject.h
index dc238ffb57c..2c527799604 100644
--- a/Libraries/LibJS/Runtime/GlobalObject.h
+++ b/Libraries/LibJS/Runtime/GlobalObject.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Environment.h>
 #include <LibJS/Runtime/VM.h>
 
@@ -15,7 +15,7 @@ namespace JS {
 
 class GlobalObject : public Object {
     JS_OBJECT(GlobalObject, Object);
-    JS_DECLARE_ALLOCATOR(GlobalObject);
+    GC_DECLARE_ALLOCATOR(GlobalObject);
 
     friend class Intrinsics;
 
@@ -52,12 +52,12 @@ template<typename... Args>
 [[nodiscard]] ALWAYS_INLINE ThrowCompletionOr<Value> Value::invoke(VM& vm, PropertyKey const& property_key, Args... args)
 {
     if constexpr (sizeof...(Args) > 0) {
-        MarkedVector<Value> arglist { vm.heap() };
+        GC::MarkedVector<Value> arglist { vm.heap() };
         (..., arglist.append(move(args)));
         return invoke_internal(vm, property_key, move(arglist));
     }
 
-    return invoke_internal(vm, property_key, Optional<MarkedVector<Value>> {});
+    return invoke_internal(vm, property_key, Optional<GC::MarkedVector<Value>> {});
 }
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/Collator.cpp b/Libraries/LibJS/Runtime/Intl/Collator.cpp
index eb7debf414f..db48b3982c6 100644
--- a/Libraries/LibJS/Runtime/Intl/Collator.cpp
+++ b/Libraries/LibJS/Runtime/Intl/Collator.cpp
@@ -8,7 +8,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(Collator);
+GC_DEFINE_ALLOCATOR(Collator);
 
 // 10 Collator Objects, https://tc39.es/ecma402/#collator-objects
 Collator::Collator(Object& prototype)
diff --git a/Libraries/LibJS/Runtime/Intl/Collator.h b/Libraries/LibJS/Runtime/Intl/Collator.h
index d4e508fa916..e17e9bcdcd0 100644
--- a/Libraries/LibJS/Runtime/Intl/Collator.h
+++ b/Libraries/LibJS/Runtime/Intl/Collator.h
@@ -17,7 +17,7 @@ namespace JS::Intl {
 
 class Collator final : public Object {
     JS_OBJECT(Collator, Object);
-    JS_DECLARE_ALLOCATOR(Collator);
+    GC_DECLARE_ALLOCATOR(Collator);
 
 public:
     static constexpr auto relevant_extension_keys()
@@ -71,7 +71,7 @@ private:
     String m_collation;                                                   // [[Collation]]
     bool m_ignore_punctuation { false };                                  // [[IgnorePunctuation]]
     bool m_numeric { false };                                             // [[Numeric]]
-    GCPtr<CollatorCompareFunction> m_bound_compare;                       // [[BoundCompare]]
+    GC::Ptr<CollatorCompareFunction> m_bound_compare;                     // [[BoundCompare]]
 
     // Non-standard. Stores the ICU collator for the Intl object's collation options.
     OwnPtr<Unicode::Collator> m_collator;
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp b/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp
index ea986787bd9..5441516b2c0 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp
+++ b/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.cpp
@@ -11,9 +11,9 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(CollatorCompareFunction);
+GC_DEFINE_ALLOCATOR(CollatorCompareFunction);
 
-NonnullGCPtr<CollatorCompareFunction> CollatorCompareFunction::create(Realm& realm, Collator& collator)
+GC::Ref<CollatorCompareFunction> CollatorCompareFunction::create(Realm& realm, Collator& collator)
 {
     return realm.create<CollatorCompareFunction>(realm, collator);
 }
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.h b/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.h
index e6c3d5417cf..8be16f2fbf2 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.h
+++ b/Libraries/LibJS/Runtime/Intl/CollatorCompareFunction.h
@@ -12,10 +12,10 @@ namespace JS::Intl {
 
 class CollatorCompareFunction : public NativeFunction {
     JS_OBJECT(CollatorCompareFunction, NativeFunction);
-    JS_DECLARE_ALLOCATOR(CollatorCompareFunction);
+    GC_DECLARE_ALLOCATOR(CollatorCompareFunction);
 
 public:
-    static NonnullGCPtr<CollatorCompareFunction> create(Realm&, Collator&);
+    static GC::Ref<CollatorCompareFunction> create(Realm&, Collator&);
 
     virtual void initialize(Realm&) override;
     virtual ~CollatorCompareFunction() override = default;
@@ -27,7 +27,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<Collator> m_collator; // [[Collator]]
+    GC::Ref<Collator> m_collator; // [[Collator]]
 };
 
 int compare_strings(Collator const&, StringView x, StringView y);
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorConstructor.cpp b/Libraries/LibJS/Runtime/Intl/CollatorConstructor.cpp
index 1244aacebcd..4e38374ac5c 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/CollatorConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(CollatorConstructor);
+GC_DEFINE_ALLOCATOR(CollatorConstructor);
 
 // 10.1 The Intl.Collator Constructor, https://tc39.es/ecma402/#sec-the-intl-collator-constructor
 CollatorConstructor::CollatorConstructor(Realm& realm)
@@ -44,7 +44,7 @@ ThrowCompletionOr<Value> CollatorConstructor::call()
 }
 
 // 10.1.1 Intl.Collator ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-intl.collator
-ThrowCompletionOr<NonnullGCPtr<Object>> CollatorConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> CollatorConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorConstructor.h b/Libraries/LibJS/Runtime/Intl/CollatorConstructor.h
index 0c0e91ce032..19b46921bca 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/CollatorConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class CollatorConstructor final : public NativeFunction {
     JS_OBJECT(CollatorConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(CollatorConstructor);
+    GC_DECLARE_ALLOCATOR(CollatorConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~CollatorConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit CollatorConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorPrototype.cpp b/Libraries/LibJS/Runtime/Intl/CollatorPrototype.cpp
index 22116ffdee9..169eff868ad 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/CollatorPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(CollatorPrototype);
+GC_DEFINE_ALLOCATOR(CollatorPrototype);
 
 // 10.3 Properties of the Intl.Collator Prototype Object, https://tc39.es/ecma402/#sec-properties-of-the-intl-collator-prototype-object
 CollatorPrototype::CollatorPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/CollatorPrototype.h b/Libraries/LibJS/Runtime/Intl/CollatorPrototype.h
index 8f8a6a3dcdf..9b941a768fe 100644
--- a/Libraries/LibJS/Runtime/Intl/CollatorPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/CollatorPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class CollatorPrototype final : public PrototypeObject<CollatorPrototype, Collator> {
     JS_PROTOTYPE_OBJECT(CollatorPrototype, Collator, Collator);
-    JS_DECLARE_ALLOCATOR(CollatorPrototype);
+    GC_DECLARE_ALLOCATOR(CollatorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormat.cpp b/Libraries/LibJS/Runtime/Intl/DateTimeFormat.cpp
index 135a280bd37..ffe25e715b9 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormat.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormat.cpp
@@ -12,7 +12,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DateTimeFormat);
+GC_DEFINE_ALLOCATOR(DateTimeFormat);
 
 // 11 DateTimeFormat Objects, https://tc39.es/ecma402/#datetimeformat-objects
 DateTimeFormat::DateTimeFormat(Object& prototype)
@@ -71,7 +71,7 @@ ThrowCompletionOr<String> format_date_time(VM& vm, DateTimeFormat& date_time_for
 }
 
 // 11.5.8 FormatDateTimeToParts ( dateTimeFormat, x ), https://tc39.es/ecma402/#sec-formatdatetimetoparts
-ThrowCompletionOr<NonnullGCPtr<Array>> format_date_time_to_parts(VM& vm, DateTimeFormat& date_time_format, double time)
+ThrowCompletionOr<GC::Ref<Array>> format_date_time_to_parts(VM& vm, DateTimeFormat& date_time_format, double time)
 {
     auto& realm = *vm.current_realm();
 
@@ -157,7 +157,7 @@ ThrowCompletionOr<String> format_date_time_range(VM& vm, DateTimeFormat& date_ti
 }
 
 // 11.5.11 FormatDateTimeRangeToParts ( dateTimeFormat, x, y ), https://tc39.es/ecma402/#sec-formatdatetimerangetoparts
-ThrowCompletionOr<NonnullGCPtr<Array>> format_date_time_range_to_parts(VM& vm, DateTimeFormat& date_time_format, double start, double end)
+ThrowCompletionOr<GC::Ref<Array>> format_date_time_range_to_parts(VM& vm, DateTimeFormat& date_time_format, double start, double end)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormat.h b/Libraries/LibJS/Runtime/Intl/DateTimeFormat.h
index 888c07fb5ba..0114c4b85de 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormat.h
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormat.h
@@ -20,7 +20,7 @@ namespace JS::Intl {
 
 class DateTimeFormat final : public Object {
     JS_OBJECT(DateTimeFormat, Object);
-    JS_DECLARE_ALLOCATOR(DateTimeFormat);
+    GC_DECLARE_ALLOCATOR(DateTimeFormat);
 
     using Patterns = Unicode::CalendarPattern;
 
@@ -77,7 +77,7 @@ private:
     Optional<Unicode::DateTimeStyle> m_date_style; // [[DateStyle]]
     Optional<Unicode::DateTimeStyle> m_time_style; // [[TimeStyle]]
     Unicode::CalendarPattern m_date_time_format;   // [[DateTimeFormat]]
-    GCPtr<NativeFunction> m_bound_format;          // [[BoundFormat]]
+    GC::Ptr<NativeFunction> m_bound_format;        // [[BoundFormat]]
 
     // Non-standard. Stores the ICU date-time formatter for the Intl object's formatting options.
     OwnPtr<Unicode::DateTimeFormat> m_formatter;
@@ -86,10 +86,10 @@ private:
 ThrowCompletionOr<Vector<Unicode::DateTimeFormat::Partition>> format_date_time_pattern(VM&, DateTimeFormat&, double time);
 ThrowCompletionOr<Vector<Unicode::DateTimeFormat::Partition>> partition_date_time_pattern(VM&, DateTimeFormat&, double time);
 ThrowCompletionOr<String> format_date_time(VM&, DateTimeFormat&, double time);
-ThrowCompletionOr<NonnullGCPtr<Array>> format_date_time_to_parts(VM&, DateTimeFormat&, double time);
+ThrowCompletionOr<GC::Ref<Array>> format_date_time_to_parts(VM&, DateTimeFormat&, double time);
 ThrowCompletionOr<Vector<Unicode::DateTimeFormat::Partition>> partition_date_time_range_pattern(VM&, DateTimeFormat&, double start, double end);
 ThrowCompletionOr<String> format_date_time_range(VM&, DateTimeFormat&, double start, double end);
-ThrowCompletionOr<NonnullGCPtr<Array>> format_date_time_range_to_parts(VM&, DateTimeFormat&, double start, double end);
+ThrowCompletionOr<GC::Ref<Array>> format_date_time_range_to_parts(VM&, DateTimeFormat&, double start, double end);
 
 template<typename Callback>
 ThrowCompletionOr<void> for_each_calendar_field(VM& vm, Unicode::CalendarPattern& pattern, Callback&& callback)
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.cpp b/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.cpp
index 343c64be84d..fb898df54e7 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.cpp
@@ -17,7 +17,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DateTimeFormatConstructor);
+GC_DEFINE_ALLOCATOR(DateTimeFormatConstructor);
 
 // 11.1 The Intl.DateTimeFormat Constructor, https://tc39.es/ecma402/#sec-intl-datetimeformat-constructor
 DateTimeFormatConstructor::DateTimeFormatConstructor(Realm& realm)
@@ -48,7 +48,7 @@ ThrowCompletionOr<Value> DateTimeFormatConstructor::call()
 }
 
 // 11.1.1 Intl.DateTimeFormat ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-intl.datetimeformat
-ThrowCompletionOr<NonnullGCPtr<Object>> DateTimeFormatConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DateTimeFormatConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -82,7 +82,7 @@ JS_DEFINE_NATIVE_FUNCTION(DateTimeFormatConstructor::supported_locales_of)
 }
 
 // 11.1.2 CreateDateTimeFormat ( newTarget, locales, options, required, defaults ), https://tc39.es/ecma402/#sec-createdatetimeformat
-ThrowCompletionOr<NonnullGCPtr<DateTimeFormat>> create_date_time_format(VM& vm, FunctionObject& new_target, Value locales_value, Value options_value, OptionRequired required, OptionDefaults defaults)
+ThrowCompletionOr<GC::Ref<DateTimeFormat>> create_date_time_format(VM& vm, FunctionObject& new_target, Value locales_value, Value options_value, OptionRequired required, OptionDefaults defaults)
 {
     // 1. Let dateTimeFormat be ? OrdinaryCreateFromConstructor(newTarget, "%Intl.DateTimeFormat.prototype%", « [[InitializedDateTimeFormat]], [[Locale]], [[Calendar]], [[NumberingSystem]], [[TimeZone]], [[HourCycle]], [[DateStyle]], [[TimeStyle]], [[DateTimeFormat]], [[BoundFormat]] »).
     auto date_time_format = TRY(ordinary_create_from_constructor<DateTimeFormat>(vm, new_target, &Intrinsics::intl_date_time_format_prototype));
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.h b/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.h
index 46893524a26..ea9d2cd0fb3 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class DateTimeFormatConstructor final : public NativeFunction {
     JS_OBJECT(DateTimeFormatConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DateTimeFormatConstructor);
+    GC_DECLARE_ALLOCATOR(DateTimeFormatConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DateTimeFormatConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit DateTimeFormatConstructor(Realm&);
@@ -41,7 +41,7 @@ enum class OptionDefaults {
     Time,
 };
 
-ThrowCompletionOr<NonnullGCPtr<DateTimeFormat>> create_date_time_format(VM&, FunctionObject& new_target, Value locales_value, Value options_value, OptionRequired, OptionDefaults);
+ThrowCompletionOr<GC::Ref<DateTimeFormat>> create_date_time_format(VM&, FunctionObject& new_target, Value locales_value, Value options_value, OptionRequired, OptionDefaults);
 String format_offset_time_zone_identifier(double offset_minutes);
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp b/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp
index abb869d468f..1b7b9073d6a 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.cpp
@@ -14,10 +14,10 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DateTimeFormatFunction);
+GC_DEFINE_ALLOCATOR(DateTimeFormatFunction);
 
 // 11.5.4 DateTime Format Functions, https://tc39.es/ecma402/#sec-datetime-format-functions
-NonnullGCPtr<DateTimeFormatFunction> DateTimeFormatFunction::create(Realm& realm, DateTimeFormat& date_time_format)
+GC::Ref<DateTimeFormatFunction> DateTimeFormatFunction::create(Realm& realm, DateTimeFormat& date_time_format)
 {
     return realm.create<DateTimeFormatFunction>(date_time_format, realm.intrinsics().function_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.h b/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.h
index ba0d60b2c1d..53298ec50ee 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.h
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatFunction.h
@@ -14,10 +14,10 @@ namespace JS::Intl {
 
 class DateTimeFormatFunction final : public NativeFunction {
     JS_OBJECT(DateTimeFormatFunction, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DateTimeFormatFunction);
+    GC_DECLARE_ALLOCATOR(DateTimeFormatFunction);
 
 public:
-    static NonnullGCPtr<DateTimeFormatFunction> create(Realm&, DateTimeFormat&);
+    static GC::Ref<DateTimeFormatFunction> create(Realm&, DateTimeFormat&);
 
     virtual ~DateTimeFormatFunction() override = default;
     virtual void initialize(Realm&) override;
@@ -29,7 +29,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<DateTimeFormat> m_date_time_format; // [[DateTimeFormat]]
+    GC::Ref<DateTimeFormat> m_date_time_format; // [[DateTimeFormat]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.cpp b/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.cpp
index 91f997e84e7..4f1c692cc9d 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DateTimeFormatPrototype);
+GC_DEFINE_ALLOCATOR(DateTimeFormatPrototype);
 
 // 11.3 Properties of the Intl.DateTimeFormat Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-datetimeformat-prototype-object
 DateTimeFormatPrototype::DateTimeFormatPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.h b/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.h
index 563d7c91b2b..9dd070c9b47 100644
--- a/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/DateTimeFormatPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class DateTimeFormatPrototype final : public PrototypeObject<DateTimeFormatPrototype, DateTimeFormat> {
     JS_PROTOTYPE_OBJECT(DateTimeFormatPrototype, DateTimeFormat, Intl.DateTimeFormat);
-    JS_DECLARE_ALLOCATOR(DateTimeFormatPrototype);
+    GC_DECLARE_ALLOCATOR(DateTimeFormatPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNames.cpp b/Libraries/LibJS/Runtime/Intl/DisplayNames.cpp
index 6ea371bfd85..cecb57a2b23 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNames.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNames.cpp
@@ -10,7 +10,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DisplayNames);
+GC_DEFINE_ALLOCATOR(DisplayNames);
 
 // 12 DisplayNames Objects, https://tc39.es/ecma402/#intl-displaynames-objects
 DisplayNames::DisplayNames(Object& prototype)
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNames.h b/Libraries/LibJS/Runtime/Intl/DisplayNames.h
index 0d3e903af05..611ce86db0f 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNames.h
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNames.h
@@ -17,7 +17,7 @@ namespace JS::Intl {
 
 class DisplayNames final : public Object {
     JS_OBJECT(DisplayNames, Object);
-    JS_DECLARE_ALLOCATOR(DisplayNames);
+    GC_DECLARE_ALLOCATOR(DisplayNames);
 
     enum class Type {
         Invalid,
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.cpp b/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.cpp
index 1ee3d8d2414..687cb81b9d3 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DisplayNamesConstructor);
+GC_DEFINE_ALLOCATOR(DisplayNamesConstructor);
 
 // 12.1 The Intl.DisplayNames Constructor, https://tc39.es/ecma402/#sec-intl-displaynames-constructor
 DisplayNamesConstructor::DisplayNamesConstructor(Realm& realm)
@@ -46,7 +46,7 @@ ThrowCompletionOr<Value> DisplayNamesConstructor::call()
 }
 
 // 12.1.1 Intl.DisplayNames ( locales, options ), https://tc39.es/ecma402/#sec-Intl.DisplayNames
-ThrowCompletionOr<NonnullGCPtr<Object>> DisplayNamesConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DisplayNamesConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.h b/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.h
index c1dcf1a4f29..e9daabcd3f7 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNamesConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class DisplayNamesConstructor final : public NativeFunction {
     JS_OBJECT(DisplayNamesConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DisplayNamesConstructor);
+    GC_DECLARE_ALLOCATOR(DisplayNamesConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DisplayNamesConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit DisplayNamesConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.cpp b/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.cpp
index 585b5d7eca3..14b774af7a0 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DisplayNamesPrototype);
+GC_DEFINE_ALLOCATOR(DisplayNamesPrototype);
 
 // 12.3 Properties of the Intl.DisplayNames Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-displaynames-prototype-object
 DisplayNamesPrototype::DisplayNamesPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.h b/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.h
index 8c543bb0f3b..8d1705b9a70 100644
--- a/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/DisplayNamesPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class DisplayNamesPrototype final : public PrototypeObject<DisplayNamesPrototype, DisplayNames> {
     JS_PROTOTYPE_OBJECT(DisplayNamesPrototype, DisplayNames, Intl.DisplayNames);
-    JS_DECLARE_ALLOCATOR(DisplayNamesPrototype);
+    GC_DECLARE_ALLOCATOR(DisplayNamesPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormat.cpp b/Libraries/LibJS/Runtime/Intl/DurationFormat.cpp
index f9f1b48239d..6b9884de230 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormat.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormat.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DurationFormat);
+GC_DEFINE_ALLOCATOR(DurationFormat);
 
 // 1 DurationFormat Objects, https://tc39.es/proposal-intl-duration-format/#durationformat-objects
 DurationFormat::DurationFormat(Object& prototype)
@@ -140,7 +140,7 @@ StringView DurationFormat::display_to_string(Display display)
     }
 }
 
-static NonnullGCPtr<NumberFormat> construct_number_format(VM& vm, DurationFormat const& duration_format, NonnullGCPtr<Object> options)
+static GC::Ref<NumberFormat> construct_number_format(VM& vm, DurationFormat const& duration_format, GC::Ref<Object> options)
 {
     auto& realm = *vm.current_realm();
 
@@ -148,7 +148,7 @@ static NonnullGCPtr<NumberFormat> construct_number_format(VM& vm, DurationFormat
     return static_cast<NumberFormat&>(*number_format);
 }
 
-static NonnullGCPtr<ListFormat> construct_list_format(VM& vm, DurationFormat const& duration_format, NonnullGCPtr<Object> options)
+static GC::Ref<ListFormat> construct_list_format(VM& vm, DurationFormat const& duration_format, GC::Ref<Object> options)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormat.h b/Libraries/LibJS/Runtime/Intl/DurationFormat.h
index 39780b83298..cbaaae1db44 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormat.h
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormat.h
@@ -18,7 +18,7 @@ namespace JS::Intl {
 
 class DurationFormat final : public Object {
     JS_OBJECT(DurationFormat, Object);
-    JS_DECLARE_ALLOCATOR(DurationFormat);
+    GC_DECLARE_ALLOCATOR(DurationFormat);
 
 public:
     enum class Style {
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.cpp b/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.cpp
index ec683a81a06..0bed08fd2bc 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DurationFormatConstructor);
+GC_DEFINE_ALLOCATOR(DurationFormatConstructor);
 
 // 1.2 The Intl.DurationFormat Constructor, https://tc39.es/proposal-intl-duration-format/#sec-intl-durationformat-constructor
 DurationFormatConstructor::DurationFormatConstructor(Realm& realm)
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> DurationFormatConstructor::call()
 }
 
 // 1.2.1 Intl.DurationFormat ( [ locales [ , options ] ] ), https://tc39.es/proposal-intl-duration-format/#sec-Intl.DurationFormat
-ThrowCompletionOr<NonnullGCPtr<Object>> DurationFormatConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DurationFormatConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.h b/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.h
index 35018a41c83..b67f8876f48 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormatConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class DurationFormatConstructor final : public NativeFunction {
     JS_OBJECT(DurationFormatConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DurationFormatConstructor);
+    GC_DECLARE_ALLOCATOR(DurationFormatConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DurationFormatConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit DurationFormatConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.cpp b/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.cpp
index d17e7ef4ecf..fc1ed17fd0d 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(DurationFormatPrototype);
+GC_DEFINE_ALLOCATOR(DurationFormatPrototype);
 
 // 1.4 Properties of the Intl.DurationFormat Prototype Object, https://tc39.es/proposal-intl-duration-format/#sec-properties-of-intl-durationformat-prototype-object
 DurationFormatPrototype::DurationFormatPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.h b/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.h
index 364bd370d16..48247af5ecd 100644
--- a/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/DurationFormatPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class DurationFormatPrototype final : public PrototypeObject<DurationFormatPrototype, DurationFormat> {
     JS_PROTOTYPE_OBJECT(DurationFormatPrototype, DurationFormat, Intl.DurationFormat);
-    JS_DECLARE_ALLOCATOR(DurationFormatPrototype);
+    GC_DECLARE_ALLOCATOR(DurationFormatPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/Intl.cpp b/Libraries/LibJS/Runtime/Intl/Intl.cpp
index 19ca735541b..a753ebbeeae 100644
--- a/Libraries/LibJS/Runtime/Intl/Intl.cpp
+++ b/Libraries/LibJS/Runtime/Intl/Intl.cpp
@@ -30,7 +30,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(Intl);
+GC_DEFINE_ALLOCATOR(Intl);
 
 // 8 The Intl Object, https://tc39.es/ecma402/#intl-object
 Intl::Intl(Realm& realm)
@@ -73,7 +73,7 @@ JS_DEFINE_NATIVE_FUNCTION(Intl::get_canonical_locales)
     // 1. Let ll be ? CanonicalizeLocaleList(locales).
     auto locale_list = TRY(canonicalize_locale_list(vm, locales));
 
-    MarkedVector<Value> marked_locale_list { vm.heap() };
+    GC::MarkedVector<Value> marked_locale_list { vm.heap() };
     marked_locale_list.ensure_capacity(locale_list.size());
 
     for (auto& locale : locale_list)
diff --git a/Libraries/LibJS/Runtime/Intl/Intl.h b/Libraries/LibJS/Runtime/Intl/Intl.h
index 87660f44fa0..ff48b384dd1 100644
--- a/Libraries/LibJS/Runtime/Intl/Intl.h
+++ b/Libraries/LibJS/Runtime/Intl/Intl.h
@@ -12,7 +12,7 @@ namespace JS::Intl {
 
 class Intl final : public Object {
     JS_OBJECT(Intl, Object);
-    JS_DECLARE_ALLOCATOR(Intl);
+    GC_DECLARE_ALLOCATOR(Intl);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormat.cpp b/Libraries/LibJS/Runtime/Intl/ListFormat.cpp
index 27ba0e98f08..474529e05ed 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormat.cpp
+++ b/Libraries/LibJS/Runtime/Intl/ListFormat.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(ListFormat);
+GC_DEFINE_ALLOCATOR(ListFormat);
 
 // 13 ListFormat Objects, https://tc39.es/ecma402/#listformat-objects
 ListFormat::ListFormat(Object& prototype)
@@ -39,7 +39,7 @@ String format_list(ListFormat const& list_format, ReadonlySpan<String> list)
 }
 
 // 13.5.4 FormatListToParts ( listFormat, list ), https://tc39.es/ecma402/#sec-formatlisttoparts
-NonnullGCPtr<Array> format_list_to_parts(VM& vm, ListFormat const& list_format, ReadonlySpan<String> list)
+GC::Ref<Array> format_list_to_parts(VM& vm, ListFormat const& list_format, ReadonlySpan<String> list)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormat.h b/Libraries/LibJS/Runtime/Intl/ListFormat.h
index e83e394c1d8..5be25d83389 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormat.h
+++ b/Libraries/LibJS/Runtime/Intl/ListFormat.h
@@ -18,7 +18,7 @@ namespace JS::Intl {
 
 class ListFormat final : public Object {
     JS_OBJECT(ListFormat, Object);
-    JS_DECLARE_ALLOCATOR(ListFormat);
+    GC_DECLARE_ALLOCATOR(ListFormat);
 
 public:
     enum class Type {
@@ -57,7 +57,7 @@ private:
 
 Vector<Unicode::ListFormat::Partition> create_parts_from_list(ListFormat const&, ReadonlySpan<String> list);
 String format_list(ListFormat const&, ReadonlySpan<String> list);
-NonnullGCPtr<Array> format_list_to_parts(VM&, ListFormat const&, ReadonlySpan<String> list);
+GC::Ref<Array> format_list_to_parts(VM&, ListFormat const&, ReadonlySpan<String> list);
 ThrowCompletionOr<Vector<String>> string_list_from_iterable(VM&, Value iterable);
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.cpp b/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.cpp
index 6430df79d67..a6d7b63695c 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(ListFormatConstructor);
+GC_DEFINE_ALLOCATOR(ListFormatConstructor);
 
 // 13.1 The Intl.ListFormat Constructor, https://tc39.es/ecma402/#sec-intl-listformat-constructor
 ListFormatConstructor::ListFormatConstructor(Realm& realm)
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> ListFormatConstructor::call()
 }
 
 // 13.1.1 Intl.ListFormat ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-Intl.ListFormat
-ThrowCompletionOr<NonnullGCPtr<Object>> ListFormatConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ListFormatConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.h b/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.h
index 1c1171119b7..0028e2b17f2 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/ListFormatConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class ListFormatConstructor final : public NativeFunction {
     JS_OBJECT(ListFormatConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ListFormatConstructor);
+    GC_DECLARE_ALLOCATOR(ListFormatConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ListFormatConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ListFormatConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.cpp b/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.cpp
index 7d6df56082f..d0305efc054 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(ListFormatPrototype);
+GC_DEFINE_ALLOCATOR(ListFormatPrototype);
 
 // 13.3 Properties of the Intl.ListFormat Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-listformat-prototype-object
 ListFormatPrototype::ListFormatPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.h b/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.h
index 7c1c9de3563..311bcfaf17f 100644
--- a/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/ListFormatPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class ListFormatPrototype final : public PrototypeObject<ListFormatPrototype, ListFormat> {
     JS_PROTOTYPE_OBJECT(ListFormatPrototype, ListFormat, Intl.ListFormat);
-    JS_DECLARE_ALLOCATOR(ListFormatPrototype);
+    GC_DECLARE_ALLOCATOR(ListFormatPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/Locale.cpp b/Libraries/LibJS/Runtime/Intl/Locale.cpp
index 83a7cb25646..14ad97488ae 100644
--- a/Libraries/LibJS/Runtime/Intl/Locale.cpp
+++ b/Libraries/LibJS/Runtime/Intl/Locale.cpp
@@ -15,9 +15,9 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(Locale);
+GC_DEFINE_ALLOCATOR(Locale);
 
-NonnullGCPtr<Locale> Locale::create(Realm& realm, NonnullGCPtr<Locale> source_locale, String locale_tag)
+GC::Ref<Locale> Locale::create(Realm& realm, GC::Ref<Locale> source_locale, String locale_tag)
 {
     auto locale = realm.create<Locale>(realm.intrinsics().intl_locale_prototype());
 
@@ -39,7 +39,7 @@ Locale::Locale(Object& prototype)
 }
 
 // 1.1.1 CreateArrayFromListOrRestricted ( list , restricted )
-static NonnullGCPtr<Array> create_array_from_list_or_restricted(VM& vm, Vector<String> list, Optional<String> restricted)
+static GC::Ref<Array> create_array_from_list_or_restricted(VM& vm, Vector<String> list, Optional<String> restricted)
 {
     auto& realm = *vm.current_realm();
 
@@ -56,7 +56,7 @@ static NonnullGCPtr<Array> create_array_from_list_or_restricted(VM& vm, Vector<S
 }
 
 // 1.1.2 CalendarsOfLocale ( loc ), https://tc39.es/proposal-intl-locale-info/#sec-calendars-of-locale
-NonnullGCPtr<Array> calendars_of_locale(VM& vm, Locale const& locale_object)
+GC::Ref<Array> calendars_of_locale(VM& vm, Locale const& locale_object)
 {
     // 1. Let restricted be loc.[[Calendar]].
     Optional<String> restricted = locale_object.has_calendar() ? locale_object.calendar() : Optional<String> {};
@@ -75,7 +75,7 @@ NonnullGCPtr<Array> calendars_of_locale(VM& vm, Locale const& locale_object)
 }
 
 // 1.1.3 CollationsOfLocale ( loc ), https://tc39.es/proposal-intl-locale-info/#sec-collations-of-locale
-NonnullGCPtr<Array> collations_of_locale(VM& vm, Locale const& locale_object)
+GC::Ref<Array> collations_of_locale(VM& vm, Locale const& locale_object)
 {
     // 1. Let restricted be loc.[[Collation]].
     Optional<String> restricted = locale_object.has_collation() ? locale_object.collation() : Optional<String> {};
@@ -94,7 +94,7 @@ NonnullGCPtr<Array> collations_of_locale(VM& vm, Locale const& locale_object)
 }
 
 // 1.1.4 HourCyclesOfLocale ( loc ), https://tc39.es/proposal-intl-locale-info/#sec-hour-cycles-of-locale
-NonnullGCPtr<Array> hour_cycles_of_locale(VM& vm, Locale const& locale_object)
+GC::Ref<Array> hour_cycles_of_locale(VM& vm, Locale const& locale_object)
 {
     // 1. Let restricted be loc.[[HourCycle]].
     Optional<String> restricted = locale_object.has_hour_cycle() ? locale_object.hour_cycle() : Optional<String> {};
@@ -113,7 +113,7 @@ NonnullGCPtr<Array> hour_cycles_of_locale(VM& vm, Locale const& locale_object)
 }
 
 // 1.1.5 NumberingSystemsOfLocale ( loc ), https://tc39.es/proposal-intl-locale-info/#sec-numbering-systems-of-locale
-NonnullGCPtr<Array> numbering_systems_of_locale(VM& vm, Locale const& locale_object)
+GC::Ref<Array> numbering_systems_of_locale(VM& vm, Locale const& locale_object)
 {
     // 1. Let restricted be loc.[[NumberingSystem]].
     Optional<String> restricted = locale_object.has_numbering_system() ? locale_object.numbering_system() : Optional<String> {};
@@ -133,7 +133,7 @@ NonnullGCPtr<Array> numbering_systems_of_locale(VM& vm, Locale const& locale_obj
 
 // 1.1.6 TimeZonesOfLocale ( loc ), https://tc39.es/proposal-intl-locale-info/#sec-time-zones-of-locale
 // NOTE: Our implementation takes a region rather than a Locale object to avoid needlessly parsing the locale twice.
-NonnullGCPtr<Array> time_zones_of_locale(VM& vm, StringView region)
+GC::Ref<Array> time_zones_of_locale(VM& vm, StringView region)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/Locale.h b/Libraries/LibJS/Runtime/Intl/Locale.h
index a3f6c17032b..8cc5e1f0fdb 100644
--- a/Libraries/LibJS/Runtime/Intl/Locale.h
+++ b/Libraries/LibJS/Runtime/Intl/Locale.h
@@ -10,7 +10,7 @@
 #include <AK/Optional.h>
 #include <AK/String.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Object.h>
 #include <LibJS/Runtime/Value.h>
@@ -20,10 +20,10 @@ namespace JS::Intl {
 
 class Locale final : public Object {
     JS_OBJECT(Locale, Object);
-    JS_DECLARE_ALLOCATOR(Locale);
+    GC_DECLARE_ALLOCATOR(Locale);
 
 public:
-    static NonnullGCPtr<Locale> create(Realm&, NonnullGCPtr<Locale> source_locale, String);
+    static GC::Ref<Locale> create(Realm&, GC::Ref<Locale> source_locale, String);
 
     static constexpr auto relevant_extension_keys()
     {
@@ -89,11 +89,11 @@ struct WeekInfo {
     Vector<u8> weekend;    // [[Weekend]]
 };
 
-NonnullGCPtr<Array> calendars_of_locale(VM&, Locale const&);
-NonnullGCPtr<Array> collations_of_locale(VM&, Locale const& locale);
-NonnullGCPtr<Array> hour_cycles_of_locale(VM&, Locale const& locale);
-NonnullGCPtr<Array> numbering_systems_of_locale(VM&, Locale const&);
-NonnullGCPtr<Array> time_zones_of_locale(VM&, StringView region);
+GC::Ref<Array> calendars_of_locale(VM&, Locale const&);
+GC::Ref<Array> collations_of_locale(VM&, Locale const& locale);
+GC::Ref<Array> hour_cycles_of_locale(VM&, Locale const& locale);
+GC::Ref<Array> numbering_systems_of_locale(VM&, Locale const&);
+GC::Ref<Array> time_zones_of_locale(VM&, StringView region);
 StringView character_direction_of_locale(Locale const&);
 StringView weekday_to_string(StringView weekday);
 Optional<u8> string_to_weekday_value(StringView weekday);
diff --git a/Libraries/LibJS/Runtime/Intl/LocaleConstructor.cpp b/Libraries/LibJS/Runtime/Intl/LocaleConstructor.cpp
index 5597579ec47..15e867645fc 100644
--- a/Libraries/LibJS/Runtime/Intl/LocaleConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/LocaleConstructor.cpp
@@ -16,7 +16,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(LocaleConstructor);
+GC_DEFINE_ALLOCATOR(LocaleConstructor);
 
 struct LocaleAndKeys {
     String locale;
@@ -244,7 +244,7 @@ ThrowCompletionOr<Value> LocaleConstructor::call()
 
 // 14.1.1 Intl.Locale ( tag [ , options ] ), https://tc39.es/ecma402/#sec-Intl.Locale
 // 1.2.3 Intl.Locale ( tag [ , options ] ), https://tc39.es/proposal-intl-locale-info/#sec-Intl.Locale
-ThrowCompletionOr<NonnullGCPtr<Object>> LocaleConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> LocaleConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/LocaleConstructor.h b/Libraries/LibJS/Runtime/Intl/LocaleConstructor.h
index d91176dda40..2829671d077 100644
--- a/Libraries/LibJS/Runtime/Intl/LocaleConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/LocaleConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class LocaleConstructor final : public NativeFunction {
     JS_OBJECT(LocaleConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(LocaleConstructor);
+    GC_DECLARE_ALLOCATOR(LocaleConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~LocaleConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit LocaleConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/LocalePrototype.cpp b/Libraries/LibJS/Runtime/Intl/LocalePrototype.cpp
index 1cbdabc00f2..76824a90660 100644
--- a/Libraries/LibJS/Runtime/Intl/LocalePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/LocalePrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(LocalePrototype);
+GC_DEFINE_ALLOCATOR(LocalePrototype);
 
 // 14.3 Properties of the Intl.Locale Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-locale-prototype-object
 LocalePrototype::LocalePrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/LocalePrototype.h b/Libraries/LibJS/Runtime/Intl/LocalePrototype.h
index cc81a3d251d..790e28b62b4 100644
--- a/Libraries/LibJS/Runtime/Intl/LocalePrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/LocalePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class LocalePrototype final : public PrototypeObject<LocalePrototype, Locale> {
     JS_PROTOTYPE_OBJECT(LocalePrototype, Locale, Intl.Locale);
-    JS_DECLARE_ALLOCATOR(LocalePrototype);
+    GC_DECLARE_ALLOCATOR(LocalePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormat.cpp b/Libraries/LibJS/Runtime/Intl/NumberFormat.cpp
index da33643fdb8..b79cb931905 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormat.cpp
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormat.cpp
@@ -23,8 +23,8 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(NumberFormatBase);
-JS_DEFINE_ALLOCATOR(NumberFormat);
+GC_DEFINE_ALLOCATOR(NumberFormatBase);
+GC_DEFINE_ALLOCATOR(NumberFormat);
 
 NumberFormatBase::NumberFormatBase(Object& prototype)
     : Object(ConstructWithPrototypeTag::Tag, prototype)
@@ -149,7 +149,7 @@ String format_numeric(NumberFormat const& number_format, MathematicalValue const
 }
 
 // 15.5.7 FormatNumericToParts ( numberFormat, x ), https://tc39.es/ecma402/#sec-formatnumbertoparts
-NonnullGCPtr<Array> format_numeric_to_parts(VM& vm, NumberFormat const& number_format, MathematicalValue const& number)
+GC::Ref<Array> format_numeric_to_parts(VM& vm, NumberFormat const& number_format, MathematicalValue const& number)
 {
     auto& realm = *vm.current_realm();
 
@@ -266,7 +266,7 @@ ThrowCompletionOr<String> format_numeric_range(VM& vm, NumberFormat const& numbe
 }
 
 // 15.5.23 FormatNumericRangeToParts ( numberFormat, x, y ), https://tc39.es/ecma402/#sec-formatnumericrangetoparts
-ThrowCompletionOr<NonnullGCPtr<Array>> format_numeric_range_to_parts(VM& vm, NumberFormat const& number_format, MathematicalValue const& start, MathematicalValue const& end)
+ThrowCompletionOr<GC::Ref<Array>> format_numeric_range_to_parts(VM& vm, NumberFormat const& number_format, MathematicalValue const& start, MathematicalValue const& end)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormat.h b/Libraries/LibJS/Runtime/Intl/NumberFormat.h
index 38e9446573f..faf4a1c0206 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormat.h
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormat.h
@@ -19,7 +19,7 @@ namespace JS::Intl {
 
 class NumberFormatBase : public Object {
     JS_OBJECT(NumberFormatBase, Object);
-    JS_DECLARE_ALLOCATOR(NumberFormatBase);
+    GC_DECLARE_ALLOCATOR(NumberFormatBase);
 
 public:
     enum class ComputedRoundingPriority {
@@ -99,7 +99,7 @@ private:
 
 class NumberFormat final : public NumberFormatBase {
     JS_OBJECT(NumberFormat, NumberFormatBase);
-    JS_DECLARE_ALLOCATOR(NumberFormat);
+    GC_DECLARE_ALLOCATOR(NumberFormat);
 
 public:
     static constexpr auto relevant_extension_keys()
@@ -180,17 +180,17 @@ private:
     Unicode::Notation m_notation;                                  // [[Notation]]
     Optional<Unicode::CompactDisplay> m_compact_display;           // [[CompactDisplay]]
     Unicode::SignDisplay m_sign_display;                           // [[SignDisplay]]
-    GCPtr<NativeFunction> m_bound_format;                          // [[BoundFormat]]
+    GC::Ptr<NativeFunction> m_bound_format;                        // [[BoundFormat]]
 };
 
 int currency_digits(StringView currency);
 String format_numeric_to_string(NumberFormatBase const& intl_object, MathematicalValue const& number);
 Vector<Unicode::NumberFormat::Partition> partition_number_pattern(NumberFormat const&, MathematicalValue const& number);
 String format_numeric(NumberFormat const&, MathematicalValue const& number);
-NonnullGCPtr<Array> format_numeric_to_parts(VM&, NumberFormat const&, MathematicalValue const& number);
+GC::Ref<Array> format_numeric_to_parts(VM&, NumberFormat const&, MathematicalValue const& number);
 ThrowCompletionOr<MathematicalValue> to_intl_mathematical_value(VM&, Value value);
 ThrowCompletionOr<Vector<Unicode::NumberFormat::Partition>> partition_number_range_pattern(VM&, NumberFormat const&, MathematicalValue const& start, MathematicalValue const& end);
 ThrowCompletionOr<String> format_numeric_range(VM&, NumberFormat const&, MathematicalValue const& start, MathematicalValue const& end);
-ThrowCompletionOr<NonnullGCPtr<Array>> format_numeric_range_to_parts(VM&, NumberFormat const&, MathematicalValue const& start, MathematicalValue const& end);
+ThrowCompletionOr<GC::Ref<Array>> format_numeric_range_to_parts(VM&, NumberFormat const&, MathematicalValue const& start, MathematicalValue const& end);
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.cpp b/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.cpp
index 74ba217197e..49b2a9253b3 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(NumberFormatConstructor);
+GC_DEFINE_ALLOCATOR(NumberFormatConstructor);
 
 // 15.1 The Intl.NumberFormat Constructor, https://tc39.es/ecma402/#sec-intl-numberformat-constructor
 NumberFormatConstructor::NumberFormatConstructor(Realm& realm)
@@ -44,7 +44,7 @@ ThrowCompletionOr<Value> NumberFormatConstructor::call()
 }
 
 // 15.1.1 Intl.NumberFormat ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-intl.numberformat
-ThrowCompletionOr<NonnullGCPtr<Object>> NumberFormatConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> NumberFormatConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.h b/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.h
index 2b780296043..86e53ebadc0 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatConstructor.h
@@ -13,14 +13,14 @@ namespace JS::Intl {
 
 class NumberFormatConstructor final : public NativeFunction {
     JS_OBJECT(NumberFormatConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(NumberFormatConstructor);
+    GC_DECLARE_ALLOCATOR(NumberFormatConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~NumberFormatConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit NumberFormatConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp b/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp
index 488a35ec69b..37eaf4b438e 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.cpp
@@ -10,10 +10,10 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(NumberFormatFunction);
+GC_DEFINE_ALLOCATOR(NumberFormatFunction);
 
 // 15.5.2 Number Format Functions, https://tc39.es/ecma402/#sec-number-format-functions
-NonnullGCPtr<NumberFormatFunction> NumberFormatFunction::create(Realm& realm, NumberFormat& number_format)
+GC::Ref<NumberFormatFunction> NumberFormatFunction::create(Realm& realm, NumberFormat& number_format)
 {
     return realm.create<NumberFormatFunction>(number_format, realm.intrinsics().function_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.h b/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.h
index 0bf141f3169..490188a49f2 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.h
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatFunction.h
@@ -14,10 +14,10 @@ namespace JS::Intl {
 
 class NumberFormatFunction final : public NativeFunction {
     JS_OBJECT(NumberFormatFunction, NativeFunction);
-    JS_DECLARE_ALLOCATOR(NumberFormatFunction);
+    GC_DECLARE_ALLOCATOR(NumberFormatFunction);
 
 public:
-    static NonnullGCPtr<NumberFormatFunction> create(Realm&, NumberFormat&);
+    static GC::Ref<NumberFormatFunction> create(Realm&, NumberFormat&);
 
     virtual ~NumberFormatFunction() override = default;
     virtual void initialize(Realm&) override;
@@ -29,7 +29,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<NumberFormat> m_number_format; // [[NumberFormat]]
+    GC::Ref<NumberFormat> m_number_format; // [[NumberFormat]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.cpp b/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.cpp
index 294eb0b5d7b..c70d5251071 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(NumberFormatPrototype);
+GC_DEFINE_ALLOCATOR(NumberFormatPrototype);
 
 // 15.3 Properties of the Intl.NumberFormat Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-numberformat-prototype-object
 NumberFormatPrototype::NumberFormatPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.h b/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.h
index 6f892cf8a54..db56050b10d 100644
--- a/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/NumberFormatPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class NumberFormatPrototype final : public PrototypeObject<NumberFormatPrototype, NumberFormat> {
     JS_PROTOTYPE_OBJECT(NumberFormatPrototype, NumberFormat, Intl.NumberFormat);
-    JS_DECLARE_ALLOCATOR(NumberFormatPrototype);
+    GC_DECLARE_ALLOCATOR(NumberFormatPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRules.cpp b/Libraries/LibJS/Runtime/Intl/PluralRules.cpp
index 726edbe3c78..c53382f46f2 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRules.cpp
+++ b/Libraries/LibJS/Runtime/Intl/PluralRules.cpp
@@ -8,7 +8,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(PluralRules);
+GC_DEFINE_ALLOCATOR(PluralRules);
 
 // 16 PluralRules Objects, https://tc39.es/ecma402/#pluralrules-objects
 PluralRules::PluralRules(Object& prototype)
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRules.h b/Libraries/LibJS/Runtime/Intl/PluralRules.h
index 4902cc3a0cb..9880257356e 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRules.h
+++ b/Libraries/LibJS/Runtime/Intl/PluralRules.h
@@ -16,7 +16,7 @@ namespace JS::Intl {
 
 class PluralRules final : public NumberFormatBase {
     JS_OBJECT(PluralRules, NumberFormatBase);
-    JS_DECLARE_ALLOCATOR(PluralRules);
+    GC_DECLARE_ALLOCATOR(PluralRules);
 
 public:
     virtual ~PluralRules() override = default;
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.cpp b/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.cpp
index 032feb3a420..3c38ccfbec7 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(PluralRulesConstructor);
+GC_DEFINE_ALLOCATOR(PluralRulesConstructor);
 
 // 16.1 The Intl.PluralRules Constructor, https://tc39.es/ecma402/#sec-intl-pluralrules-constructor
 PluralRulesConstructor::PluralRulesConstructor(Realm& realm)
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> PluralRulesConstructor::call()
 }
 
 // 16.1.1 Intl.PluralRules ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-intl.pluralrules
-ThrowCompletionOr<NonnullGCPtr<Object>> PluralRulesConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PluralRulesConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.h b/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.h
index f595d69d22c..d5af22c23c8 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/PluralRulesConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class PluralRulesConstructor final : public NativeFunction {
     JS_OBJECT(PluralRulesConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PluralRulesConstructor);
+    GC_DECLARE_ALLOCATOR(PluralRulesConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PluralRulesConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PluralRulesConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.cpp b/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.cpp
index 48d5b84636a..b01108797ae 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/Array.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/Intl/PluralRulesPrototype.h>
@@ -13,7 +13,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(PluralRulesPrototype);
+GC_DEFINE_ALLOCATOR(PluralRulesPrototype);
 
 // 16.3 Properties of the Intl.PluralRules Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-pluralrules-prototype-object
 PluralRulesPrototype::PluralRulesPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.h b/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.h
index 42254554df6..66b5c09155d 100644
--- a/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class PluralRulesPrototype final : public PrototypeObject<PluralRulesPrototype, PluralRules> {
     JS_PROTOTYPE_OBJECT(PluralRulesPrototype, PluralRules, Intl.PluralRules);
-    JS_DECLARE_ALLOCATOR(PluralRulesPrototype);
+    GC_DECLARE_ALLOCATOR(PluralRulesPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp
index 1722ffc328d..d552c608468 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.cpp
@@ -16,7 +16,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(RelativeTimeFormat);
+GC_DEFINE_ALLOCATOR(RelativeTimeFormat);
 
 // 17 RelativeTimeFormat Objects, https://tc39.es/ecma402/#relativetimeformat-objects
 RelativeTimeFormat::RelativeTimeFormat(Object& prototype)
@@ -96,7 +96,7 @@ ThrowCompletionOr<String> format_relative_time(VM& vm, RelativeTimeFormat& relat
 }
 
 // 17.5.5 FormatRelativeTimeToParts ( relativeTimeFormat, value, unit ), https://tc39.es/ecma402/#sec-FormatRelativeTimeToParts
-ThrowCompletionOr<NonnullGCPtr<Array>> format_relative_time_to_parts(VM& vm, RelativeTimeFormat& relative_time_format, double value, StringView unit)
+ThrowCompletionOr<GC::Ref<Array>> format_relative_time_to_parts(VM& vm, RelativeTimeFormat& relative_time_format, double value, StringView unit)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h
index f184b81db11..306871d80c3 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormat.h
@@ -20,7 +20,7 @@ namespace JS::Intl {
 
 class RelativeTimeFormat final : public Object {
     JS_OBJECT(RelativeTimeFormat, Object);
-    JS_DECLARE_ALLOCATOR(RelativeTimeFormat);
+    GC_DECLARE_ALLOCATOR(RelativeTimeFormat);
 
 public:
     static constexpr auto relevant_extension_keys()
@@ -64,6 +64,6 @@ private:
 ThrowCompletionOr<Unicode::TimeUnit> singular_relative_time_unit(VM&, StringView unit);
 ThrowCompletionOr<Vector<Unicode::RelativeTimeFormat::Partition>> partition_relative_time_pattern(VM&, RelativeTimeFormat&, double value, StringView unit);
 ThrowCompletionOr<String> format_relative_time(VM&, RelativeTimeFormat&, double value, StringView unit);
-ThrowCompletionOr<NonnullGCPtr<Array>> format_relative_time_to_parts(VM&, RelativeTimeFormat&, double value, StringView unit);
+ThrowCompletionOr<GC::Ref<Array>> format_relative_time_to_parts(VM&, RelativeTimeFormat&, double value, StringView unit);
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.cpp b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.cpp
index 0f5e1bd915c..fbe8a5ef2c4 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(RelativeTimeFormatConstructor);
+GC_DEFINE_ALLOCATOR(RelativeTimeFormatConstructor);
 
 // 17.1 The Intl.RelativeTimeFormat Constructor, https://tc39.es/ecma402/#sec-intl-relativetimeformat-constructor
 RelativeTimeFormatConstructor::RelativeTimeFormatConstructor(Realm& realm)
@@ -44,7 +44,7 @@ ThrowCompletionOr<Value> RelativeTimeFormatConstructor::call()
 }
 
 // 17.1.1 Intl.RelativeTimeFormat ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-Intl.RelativeTimeFormat
-ThrowCompletionOr<NonnullGCPtr<Object>> RelativeTimeFormatConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> RelativeTimeFormatConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.h b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.h
index 7fb063e7443..d913c9dbe28 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class RelativeTimeFormatConstructor final : public NativeFunction {
     JS_OBJECT(RelativeTimeFormatConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(RelativeTimeFormatConstructor);
+    GC_DECLARE_ALLOCATOR(RelativeTimeFormatConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~RelativeTimeFormatConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit RelativeTimeFormatConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp
index 8e434dc5986..2c05df12931 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(RelativeTimeFormatPrototype);
+GC_DEFINE_ALLOCATOR(RelativeTimeFormatPrototype);
 
 // 17.3 Properties of the Intl.RelativeTimeFormat Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-relativetimeformat-prototype-object
 RelativeTimeFormatPrototype::RelativeTimeFormatPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h
index 51ce13ee088..1aa1c457de8 100644
--- a/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/RelativeTimeFormatPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class RelativeTimeFormatPrototype final : public PrototypeObject<RelativeTimeFormatPrototype, RelativeTimeFormat> {
     JS_PROTOTYPE_OBJECT(RelativeTimeFormatPrototype, RelativeTimeFormat, Intl.RelativeTimeFormat);
-    JS_DECLARE_ALLOCATOR(RelativeTimeFormatPrototype);
+    GC_DECLARE_ALLOCATOR(RelativeTimeFormatPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp b/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp
index 3ea77f5e882..fcd9bbec8af 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp
+++ b/Libraries/LibJS/Runtime/Intl/SegmentIterator.cpp
@@ -10,10 +10,10 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(SegmentIterator);
+GC_DEFINE_ALLOCATOR(SegmentIterator);
 
 // 18.6.1 CreateSegmentIterator ( segmenter, string ), https://tc39.es/ecma402/#sec-createsegmentsobject
-NonnullGCPtr<SegmentIterator> SegmentIterator::create(Realm& realm, Unicode::Segmenter const& segmenter, Utf16View const& string, Segments const& segments)
+GC::Ref<SegmentIterator> SegmentIterator::create(Realm& realm, Unicode::Segmenter const& segmenter, Utf16View const& string, Segments const& segments)
 {
     // 1. Let internalSlotsList be « [[IteratingSegmenter]], [[IteratedString]], [[IteratedStringNextSegmentCodeUnitIndex]] ».
     // 2. Let iterator be OrdinaryObjectCreate(%SegmentIteratorPrototype%, internalSlotsList).
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentIterator.h b/Libraries/LibJS/Runtime/Intl/SegmentIterator.h
index 7796f9e5c9c..98d80cb8faf 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentIterator.h
+++ b/Libraries/LibJS/Runtime/Intl/SegmentIterator.h
@@ -15,10 +15,10 @@ namespace JS::Intl {
 
 class SegmentIterator final : public Object {
     JS_OBJECT(SegmentIterator, Object);
-    JS_DECLARE_ALLOCATOR(SegmentIterator);
+    GC_DECLARE_ALLOCATOR(SegmentIterator);
 
 public:
-    static NonnullGCPtr<SegmentIterator> create(Realm&, Unicode::Segmenter const&, Utf16View const&, Segments const&);
+    static GC::Ref<SegmentIterator> create(Realm&, Unicode::Segmenter const&, Utf16View const&, Segments const&);
 
     virtual ~SegmentIterator() override = default;
 
@@ -36,7 +36,7 @@ private:
     NonnullOwnPtr<Unicode::Segmenter> m_iterating_segmenter; // [[IteratingSegmenter]]
     Utf16View m_iterated_string;                             // [[IteratedString]]
 
-    NonnullGCPtr<Segments const> m_segments;
+    GC::Ref<Segments const> m_segments;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.cpp b/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.cpp
index e28b918994e..6a58857e7bd 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(SegmentIteratorPrototype);
+GC_DEFINE_ALLOCATOR(SegmentIteratorPrototype);
 
 // 18.6.2 The %SegmentIteratorPrototype% Object, https://tc39.es/ecma402/#sec-%segmentiteratorprototype%-object
 SegmentIteratorPrototype::SegmentIteratorPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.h b/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.h
index c8c318adba9..aedb2e45777 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/SegmentIteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class SegmentIteratorPrototype final : public PrototypeObject<SegmentIteratorPrototype, SegmentIterator> {
     JS_PROTOTYPE_OBJECT(SegmentIteratorPrototype, SegmentIterator, SegmentIterator);
-    JS_DECLARE_ALLOCATOR(SegmentIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(SegmentIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/Segmenter.cpp b/Libraries/LibJS/Runtime/Intl/Segmenter.cpp
index 3402f0bd97d..ba3be63b67b 100644
--- a/Libraries/LibJS/Runtime/Intl/Segmenter.cpp
+++ b/Libraries/LibJS/Runtime/Intl/Segmenter.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(Segmenter);
+GC_DEFINE_ALLOCATOR(Segmenter);
 
 // 18 Segmenter Objects, https://tc39.es/ecma402/#segmenter-objects
 Segmenter::Segmenter(Object& prototype)
@@ -20,7 +20,7 @@ Segmenter::Segmenter(Object& prototype)
 }
 
 // 18.7.1 CreateSegmentDataObject ( segmenter, string, startIndex, endIndex ), https://tc39.es/ecma402/#sec-createsegmentdataobject
-ThrowCompletionOr<NonnullGCPtr<Object>> create_segment_data_object(VM& vm, Unicode::Segmenter const& segmenter, Utf16View const& string, size_t start_index, size_t end_index)
+ThrowCompletionOr<GC::Ref<Object>> create_segment_data_object(VM& vm, Unicode::Segmenter const& segmenter, Utf16View const& string, size_t start_index, size_t end_index)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/Segmenter.h b/Libraries/LibJS/Runtime/Intl/Segmenter.h
index 25b72f8fe40..3a1fd7c3076 100644
--- a/Libraries/LibJS/Runtime/Intl/Segmenter.h
+++ b/Libraries/LibJS/Runtime/Intl/Segmenter.h
@@ -15,7 +15,7 @@ namespace JS::Intl {
 
 class Segmenter final : public Object {
     JS_OBJECT(Segmenter, Object);
-    JS_DECLARE_ALLOCATOR(Segmenter);
+    GC_DECLARE_ALLOCATOR(Segmenter);
 
 public:
     virtual ~Segmenter() override = default;
@@ -40,7 +40,7 @@ private:
     OwnPtr<Unicode::Segmenter> m_segmenter;
 };
 
-ThrowCompletionOr<NonnullGCPtr<Object>> create_segment_data_object(VM&, Unicode::Segmenter const&, Utf16View const&, size_t start_index, size_t end_index);
+ThrowCompletionOr<GC::Ref<Object>> create_segment_data_object(VM&, Unicode::Segmenter const&, Utf16View const&, size_t start_index, size_t end_index);
 
 enum class Direction {
     Before,
diff --git a/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.cpp b/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.cpp
index b6126db85a5..f380c2452b4 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(SegmenterConstructor);
+GC_DEFINE_ALLOCATOR(SegmenterConstructor);
 
 // 18.1 The Intl.Segmenter Constructor, https://tc39.es/ecma402/#sec-intl-segmenter-constructor
 SegmenterConstructor::SegmenterConstructor(Realm& realm)
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> SegmenterConstructor::call()
 }
 
 // 18.1.1 Intl.Segmenter ( [ locales [ , options ] ] ), https://tc39.es/ecma402/#sec-intl.segmenter
-ThrowCompletionOr<NonnullGCPtr<Object>> SegmenterConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> SegmenterConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.h b/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.h
index 76c4d17d858..24c6b94f88a 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.h
+++ b/Libraries/LibJS/Runtime/Intl/SegmenterConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Intl {
 
 class SegmenterConstructor final : public NativeFunction {
     JS_OBJECT(SegmenterConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(SegmenterConstructor);
+    GC_DECLARE_ALLOCATOR(SegmenterConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~SegmenterConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit SegmenterConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.cpp b/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.cpp
index e46d9a85357..59dda55cb12 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(SegmenterPrototype);
+GC_DEFINE_ALLOCATOR(SegmenterPrototype);
 
 // 18.3 Properties of the Intl.Segmenter Prototype Object, https://tc39.es/ecma402/#sec-properties-of-intl-segmenter-prototype-object
 SegmenterPrototype::SegmenterPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.h b/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.h
index b47bcd796da..b5f62582121 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/SegmenterPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class SegmenterPrototype final : public PrototypeObject<SegmenterPrototype, Segmenter> {
     JS_PROTOTYPE_OBJECT(SegmenterPrototype, Segmenter, Segmenter);
-    JS_DECLARE_ALLOCATOR(SegmenterPrototype);
+    GC_DECLARE_ALLOCATOR(SegmenterPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intl/Segments.cpp b/Libraries/LibJS/Runtime/Intl/Segments.cpp
index 51d7f6001c7..bd7f027b236 100644
--- a/Libraries/LibJS/Runtime/Intl/Segments.cpp
+++ b/Libraries/LibJS/Runtime/Intl/Segments.cpp
@@ -10,10 +10,10 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(Segments);
+GC_DEFINE_ALLOCATOR(Segments);
 
 // 18.5.1 CreateSegmentsObject ( segmenter, string ), https://tc39.es/ecma402/#sec-createsegmentsobject
-NonnullGCPtr<Segments> Segments::create(Realm& realm, Unicode::Segmenter const& segmenter, Utf16String string)
+GC::Ref<Segments> Segments::create(Realm& realm, Unicode::Segmenter const& segmenter, Utf16String string)
 {
     // 1. Let internalSlotsList be « [[SegmentsSegmenter]], [[SegmentsString]] ».
     // 2. Let segments be OrdinaryObjectCreate(%SegmentsPrototype%, internalSlotsList).
diff --git a/Libraries/LibJS/Runtime/Intl/Segments.h b/Libraries/LibJS/Runtime/Intl/Segments.h
index 5c3864ef267..16c0c8e4313 100644
--- a/Libraries/LibJS/Runtime/Intl/Segments.h
+++ b/Libraries/LibJS/Runtime/Intl/Segments.h
@@ -15,10 +15,10 @@ namespace JS::Intl {
 
 class Segments final : public Object {
     JS_OBJECT(Segments, Object);
-    JS_DECLARE_ALLOCATOR(Segments);
+    GC_DECLARE_ALLOCATOR(Segments);
 
 public:
-    static NonnullGCPtr<Segments> create(Realm&, Unicode::Segmenter const&, Utf16String);
+    static GC::Ref<Segments> create(Realm&, Unicode::Segmenter const&, Utf16String);
 
     virtual ~Segments() override = default;
 
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.cpp b/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.cpp
index d93ec3307e3..80f54df07d1 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Intl {
 
-JS_DEFINE_ALLOCATOR(SegmentsPrototype);
+GC_DEFINE_ALLOCATOR(SegmentsPrototype);
 
 // 18.5.2 The %SegmentsPrototype% Object, https://tc39.es/ecma402/#sec-%segmentsprototype%-object
 SegmentsPrototype::SegmentsPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.h b/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.h
index a7a8beae4a7..93653cd75d1 100644
--- a/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.h
+++ b/Libraries/LibJS/Runtime/Intl/SegmentsPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Intl {
 
 class SegmentsPrototype final : public PrototypeObject<SegmentsPrototype, Segments> {
     JS_PROTOTYPE_OBJECT(SegmentsPrototype, Segments, Segments);
-    JS_DECLARE_ALLOCATOR(SegmentsPrototype);
+    GC_DECLARE_ALLOCATOR(SegmentsPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Intrinsics.cpp b/Libraries/LibJS/Runtime/Intrinsics.cpp
index ea9a793154d..92e6b6d9b1e 100644
--- a/Libraries/LibJS/Runtime/Intrinsics.cpp
+++ b/Libraries/LibJS/Runtime/Intrinsics.cpp
@@ -133,7 +133,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Intrinsics);
+GC_DEFINE_ALLOCATOR(Intrinsics);
 
 static void initialize_constructor(VM& vm, PropertyKey const& property_key, Object& constructor, Object* prototype, PropertyAttributes constructor_property_attributes = Attribute::Writable | Attribute::Configurable)
 {
@@ -143,7 +143,7 @@ static void initialize_constructor(VM& vm, PropertyKey const& property_key, Obje
 }
 
 // 9.3.2 CreateIntrinsics ( realmRec ), https://tc39.es/ecma262/#sec-createintrinsics
-ThrowCompletionOr<NonnullGCPtr<Intrinsics>> Intrinsics::create(Realm& realm)
+ThrowCompletionOr<GC::Ref<Intrinsics>> Intrinsics::create(Realm& realm)
 {
     auto& vm = realm.vm();
 
@@ -320,14 +320,14 @@ JS_ENUMERATE_TYPED_ARRAYS
             initialize_constructor(vm, vm.names.ClassName, *m_##snake_namespace##snake_name##_constructor, m_##snake_namespace##snake_name##_prototype); \
     }                                                                                                                                                    \
                                                                                                                                                          \
-    NonnullGCPtr<Namespace::ConstructorName> Intrinsics::snake_namespace##snake_name##_constructor()                                                     \
+    GC::Ref<Namespace::ConstructorName> Intrinsics::snake_namespace##snake_name##_constructor()                                                          \
     {                                                                                                                                                    \
         if (!m_##snake_namespace##snake_name##_constructor)                                                                                              \
             initialize_##snake_namespace##snake_name();                                                                                                  \
         return *m_##snake_namespace##snake_name##_constructor;                                                                                           \
     }                                                                                                                                                    \
                                                                                                                                                          \
-    NonnullGCPtr<Object> Intrinsics::snake_namespace##snake_name##_prototype()                                                                           \
+    GC::Ref<Object> Intrinsics::snake_namespace##snake_name##_prototype()                                                                                \
     {                                                                                                                                                    \
         if (!m_##snake_namespace##snake_name##_prototype)                                                                                                \
             initialize_##snake_namespace##snake_name();                                                                                                  \
@@ -352,7 +352,7 @@ JS_ENUMERATE_TEMPORAL_OBJECTS
 #undef __JS_ENUMERATE_INNER
 
 #define __JS_ENUMERATE(ClassName, snake_name)                              \
-    NonnullGCPtr<ClassName> Intrinsics::snake_name##_object()              \
+    GC::Ref<ClassName> Intrinsics::snake_name##_object()                   \
     {                                                                      \
         if (!m_##snake_name##_object)                                      \
             m_##snake_name##_object = m_realm->create<ClassName>(m_realm); \
diff --git a/Libraries/LibJS/Runtime/Intrinsics.h b/Libraries/LibJS/Runtime/Intrinsics.h
index 5b2ff4f4937..68f29ffb334 100644
--- a/Libraries/LibJS/Runtime/Intrinsics.h
+++ b/Libraries/LibJS/Runtime/Intrinsics.h
@@ -12,85 +12,85 @@
 namespace JS {
 
 class Intrinsics final : public Cell {
-    JS_CELL(Intrinsics, Cell);
-    JS_DECLARE_ALLOCATOR(Intrinsics);
+    GC_CELL(Intrinsics, Cell);
+    GC_DECLARE_ALLOCATOR(Intrinsics);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<Intrinsics>> create(Realm&);
+    static ThrowCompletionOr<GC::Ref<Intrinsics>> create(Realm&);
 
-    NonnullGCPtr<Shape> empty_object_shape() { return *m_empty_object_shape; }
+    GC::Ref<Shape> empty_object_shape() { return *m_empty_object_shape; }
 
-    NonnullGCPtr<Shape> new_object_shape() { return *m_new_object_shape; }
+    GC::Ref<Shape> new_object_shape() { return *m_new_object_shape; }
 
-    [[nodiscard]] NonnullGCPtr<Shape> iterator_result_object_shape() { return *m_iterator_result_object_shape; }
+    [[nodiscard]] GC::Ref<Shape> iterator_result_object_shape() { return *m_iterator_result_object_shape; }
     [[nodiscard]] u32 iterator_result_object_value_offset() { return m_iterator_result_object_value_offset; }
     [[nodiscard]] u32 iterator_result_object_done_offset() { return m_iterator_result_object_done_offset; }
 
     // Not included in JS_ENUMERATE_NATIVE_OBJECTS due to missing distinct prototype
-    NonnullGCPtr<ProxyConstructor> proxy_constructor() { return *m_proxy_constructor; }
+    GC::Ref<ProxyConstructor> proxy_constructor() { return *m_proxy_constructor; }
 
     // Not included in JS_ENUMERATE_NATIVE_OBJECTS due to missing distinct constructor
-    NonnullGCPtr<Object> async_from_sync_iterator_prototype() { return *m_async_from_sync_iterator_prototype; }
-    NonnullGCPtr<Object> async_generator_prototype() { return *m_async_generator_prototype; }
-    NonnullGCPtr<Object> generator_prototype() { return *m_generator_prototype; }
-    NonnullGCPtr<Object> wrap_for_valid_iterator_prototype() { return *m_wrap_for_valid_iterator_prototype; }
+    GC::Ref<Object> async_from_sync_iterator_prototype() { return *m_async_from_sync_iterator_prototype; }
+    GC::Ref<Object> async_generator_prototype() { return *m_async_generator_prototype; }
+    GC::Ref<Object> generator_prototype() { return *m_generator_prototype; }
+    GC::Ref<Object> wrap_for_valid_iterator_prototype() { return *m_wrap_for_valid_iterator_prototype; }
 
     // Alias for the AsyncGenerator Prototype Object used by the spec (%AsyncGeneratorFunction.prototype.prototype%)
-    NonnullGCPtr<Object> async_generator_function_prototype_prototype() { return *m_async_generator_prototype; }
+    GC::Ref<Object> async_generator_function_prototype_prototype() { return *m_async_generator_prototype; }
     // Alias for the Generator Prototype Object used by the spec (%GeneratorFunction.prototype.prototype%)
-    NonnullGCPtr<Object> generator_function_prototype_prototype() { return *m_generator_prototype; }
+    GC::Ref<Object> generator_function_prototype_prototype() { return *m_generator_prototype; }
 
     // Not included in JS_ENUMERATE_INTL_OBJECTS due to missing distinct constructor
-    NonnullGCPtr<Object> intl_segments_prototype() { return *m_intl_segments_prototype; }
+    GC::Ref<Object> intl_segments_prototype() { return *m_intl_segments_prototype; }
 
     // Global object functions
-    NonnullGCPtr<FunctionObject> eval_function() const { return *m_eval_function; }
-    NonnullGCPtr<FunctionObject> is_finite_function() const { return *m_is_finite_function; }
-    NonnullGCPtr<FunctionObject> is_nan_function() const { return *m_is_nan_function; }
-    NonnullGCPtr<FunctionObject> parse_float_function() const { return *m_parse_float_function; }
-    NonnullGCPtr<FunctionObject> parse_int_function() const { return *m_parse_int_function; }
-    NonnullGCPtr<FunctionObject> decode_uri_function() const { return *m_decode_uri_function; }
-    NonnullGCPtr<FunctionObject> decode_uri_component_function() const { return *m_decode_uri_component_function; }
-    NonnullGCPtr<FunctionObject> encode_uri_function() const { return *m_encode_uri_function; }
-    NonnullGCPtr<FunctionObject> encode_uri_component_function() const { return *m_encode_uri_component_function; }
-    NonnullGCPtr<FunctionObject> escape_function() const { return *m_escape_function; }
-    NonnullGCPtr<FunctionObject> unescape_function() const { return *m_unescape_function; }
+    GC::Ref<FunctionObject> eval_function() const { return *m_eval_function; }
+    GC::Ref<FunctionObject> is_finite_function() const { return *m_is_finite_function; }
+    GC::Ref<FunctionObject> is_nan_function() const { return *m_is_nan_function; }
+    GC::Ref<FunctionObject> parse_float_function() const { return *m_parse_float_function; }
+    GC::Ref<FunctionObject> parse_int_function() const { return *m_parse_int_function; }
+    GC::Ref<FunctionObject> decode_uri_function() const { return *m_decode_uri_function; }
+    GC::Ref<FunctionObject> decode_uri_component_function() const { return *m_decode_uri_component_function; }
+    GC::Ref<FunctionObject> encode_uri_function() const { return *m_encode_uri_function; }
+    GC::Ref<FunctionObject> encode_uri_component_function() const { return *m_encode_uri_component_function; }
+    GC::Ref<FunctionObject> escape_function() const { return *m_escape_function; }
+    GC::Ref<FunctionObject> unescape_function() const { return *m_unescape_function; }
 
     // Namespace/constructor object functions
-    NonnullGCPtr<FunctionObject> array_prototype_values_function() const { return *m_array_prototype_values_function; }
-    NonnullGCPtr<FunctionObject> date_constructor_now_function() const { return *m_date_constructor_now_function; }
-    NonnullGCPtr<FunctionObject> json_parse_function() const { return *m_json_parse_function; }
-    NonnullGCPtr<FunctionObject> json_stringify_function() const { return *m_json_stringify_function; }
-    NonnullGCPtr<FunctionObject> object_prototype_to_string_function() const { return *m_object_prototype_to_string_function; }
-    NonnullGCPtr<FunctionObject> throw_type_error_function() const { return *m_throw_type_error_function; }
+    GC::Ref<FunctionObject> array_prototype_values_function() const { return *m_array_prototype_values_function; }
+    GC::Ref<FunctionObject> date_constructor_now_function() const { return *m_date_constructor_now_function; }
+    GC::Ref<FunctionObject> json_parse_function() const { return *m_json_parse_function; }
+    GC::Ref<FunctionObject> json_stringify_function() const { return *m_json_stringify_function; }
+    GC::Ref<FunctionObject> object_prototype_to_string_function() const { return *m_object_prototype_to_string_function; }
+    GC::Ref<FunctionObject> throw_type_error_function() const { return *m_throw_type_error_function; }
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
-    NonnullGCPtr<ConstructorName> snake_name##_constructor();                            \
-    NonnullGCPtr<Object> snake_name##_prototype();
+    GC::Ref<ConstructorName> snake_name##_constructor();                                 \
+    GC::Ref<Object> snake_name##_prototype();
     JS_ENUMERATE_BUILTIN_TYPES
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName) \
-    NonnullGCPtr<Intl::ConstructorName> intl_##snake_name##_constructor();    \
-    NonnullGCPtr<Object> intl_##snake_name##_prototype();
+    GC::Ref<Intl::ConstructorName> intl_##snake_name##_constructor();         \
+    GC::Ref<Object> intl_##snake_name##_prototype();
     JS_ENUMERATE_INTL_OBJECTS
 #undef __JS_ENUMERATE
 
-#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName)      \
-    NonnullGCPtr<Temporal::ConstructorName> temporal_##snake_name##_constructor(); \
-    NonnullGCPtr<Object> temporal_##snake_name##_prototype();
+#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName) \
+    GC::Ref<Temporal::ConstructorName> temporal_##snake_name##_constructor(); \
+    GC::Ref<Object> temporal_##snake_name##_prototype();
     JS_ENUMERATE_TEMPORAL_OBJECTS
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name) \
-    NonnullGCPtr<ClassName> snake_name##_object();
+    GC::Ref<ClassName> snake_name##_object();
     JS_ENUMERATE_BUILTIN_NAMESPACE_OBJECTS
 #undef __JS_ENUMERATE
 
-#define __JS_ENUMERATE(ClassName, snake_name)     \
-    NonnullGCPtr<Object> snake_name##_prototype() \
-    {                                             \
-        return *m_##snake_name##_prototype;       \
+#define __JS_ENUMERATE(ClassName, snake_name) \
+    GC::Ref<Object> snake_name##_prototype()  \
+    {                                         \
+        return *m_##snake_name##_prototype;   \
     }
     JS_ENUMERATE_ITERATOR_PROTOTYPES
 #undef __JS_ENUMERATE
@@ -120,73 +120,73 @@ private:
     JS_ENUMERATE_TEMPORAL_OBJECTS
 #undef __JS_ENUMERATE
 
-    NonnullGCPtr<Realm> m_realm;
+    GC::Ref<Realm> m_realm;
 
-    GCPtr<Shape> m_empty_object_shape;
-    GCPtr<Shape> m_new_object_shape;
+    GC::Ptr<Shape> m_empty_object_shape;
+    GC::Ptr<Shape> m_new_object_shape;
 
-    GCPtr<Shape> m_iterator_result_object_shape;
+    GC::Ptr<Shape> m_iterator_result_object_shape;
     u32 m_iterator_result_object_value_offset { 0 };
     u32 m_iterator_result_object_done_offset { 0 };
 
     // Not included in JS_ENUMERATE_NATIVE_OBJECTS due to missing distinct prototype
-    GCPtr<ProxyConstructor> m_proxy_constructor;
+    GC::Ptr<ProxyConstructor> m_proxy_constructor;
 
     // Not included in JS_ENUMERATE_NATIVE_OBJECTS due to missing distinct constructor
-    GCPtr<Object> m_async_from_sync_iterator_prototype;
-    GCPtr<Object> m_async_generator_prototype;
-    GCPtr<Object> m_generator_prototype;
-    GCPtr<Object> m_wrap_for_valid_iterator_prototype;
+    GC::Ptr<Object> m_async_from_sync_iterator_prototype;
+    GC::Ptr<Object> m_async_generator_prototype;
+    GC::Ptr<Object> m_generator_prototype;
+    GC::Ptr<Object> m_wrap_for_valid_iterator_prototype;
 
     // Not included in JS_ENUMERATE_INTL_OBJECTS due to missing distinct constructor
-    GCPtr<Object> m_intl_segments_prototype;
+    GC::Ptr<Object> m_intl_segments_prototype;
 
     // Global object functions
-    GCPtr<FunctionObject> m_eval_function;
-    GCPtr<FunctionObject> m_is_finite_function;
-    GCPtr<FunctionObject> m_is_nan_function;
-    GCPtr<FunctionObject> m_parse_float_function;
-    GCPtr<FunctionObject> m_parse_int_function;
-    GCPtr<FunctionObject> m_decode_uri_function;
-    GCPtr<FunctionObject> m_decode_uri_component_function;
-    GCPtr<FunctionObject> m_encode_uri_function;
-    GCPtr<FunctionObject> m_encode_uri_component_function;
-    GCPtr<FunctionObject> m_escape_function;
-    GCPtr<FunctionObject> m_unescape_function;
+    GC::Ptr<FunctionObject> m_eval_function;
+    GC::Ptr<FunctionObject> m_is_finite_function;
+    GC::Ptr<FunctionObject> m_is_nan_function;
+    GC::Ptr<FunctionObject> m_parse_float_function;
+    GC::Ptr<FunctionObject> m_parse_int_function;
+    GC::Ptr<FunctionObject> m_decode_uri_function;
+    GC::Ptr<FunctionObject> m_decode_uri_component_function;
+    GC::Ptr<FunctionObject> m_encode_uri_function;
+    GC::Ptr<FunctionObject> m_encode_uri_component_function;
+    GC::Ptr<FunctionObject> m_escape_function;
+    GC::Ptr<FunctionObject> m_unescape_function;
 
     // Namespace/constructor object functions
-    GCPtr<FunctionObject> m_array_prototype_values_function;
-    GCPtr<FunctionObject> m_date_constructor_now_function;
-    GCPtr<FunctionObject> m_json_parse_function;
-    GCPtr<FunctionObject> m_json_stringify_function;
-    GCPtr<FunctionObject> m_object_prototype_to_string_function;
-    GCPtr<FunctionObject> m_throw_type_error_function;
+    GC::Ptr<FunctionObject> m_array_prototype_values_function;
+    GC::Ptr<FunctionObject> m_date_constructor_now_function;
+    GC::Ptr<FunctionObject> m_json_parse_function;
+    GC::Ptr<FunctionObject> m_json_stringify_function;
+    GC::Ptr<FunctionObject> m_object_prototype_to_string_function;
+    GC::Ptr<FunctionObject> m_throw_type_error_function;
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
-    GCPtr<ConstructorName> m_##snake_name##_constructor;                                 \
-    GCPtr<Object> m_##snake_name##_prototype;
+    GC::Ptr<ConstructorName> m_##snake_name##_constructor;                               \
+    GC::Ptr<Object> m_##snake_name##_prototype;
     JS_ENUMERATE_BUILTIN_TYPES
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName) \
-    GCPtr<Intl::ConstructorName> m_intl_##snake_name##_constructor;           \
-    GCPtr<Object> m_intl_##snake_name##_prototype;
+    GC::Ptr<Intl::ConstructorName> m_intl_##snake_name##_constructor;         \
+    GC::Ptr<Object> m_intl_##snake_name##_prototype;
     JS_ENUMERATE_INTL_OBJECTS
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName) \
-    GCPtr<Temporal::ConstructorName> m_temporal_##snake_name##_constructor;   \
-    GCPtr<Object> m_temporal_##snake_name##_prototype;
+    GC::Ptr<Temporal::ConstructorName> m_temporal_##snake_name##_constructor; \
+    GC::Ptr<Object> m_temporal_##snake_name##_prototype;
     JS_ENUMERATE_TEMPORAL_OBJECTS
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name) \
-    GCPtr<ClassName> m_##snake_name##_object;
+    GC::Ptr<ClassName> m_##snake_name##_object;
     JS_ENUMERATE_BUILTIN_NAMESPACE_OBJECTS
 #undef __JS_ENUMERATE
 
 #define __JS_ENUMERATE(ClassName, snake_name) \
-    GCPtr<Object> m_##snake_name##_prototype;
+    GC::Ptr<Object> m_##snake_name##_prototype;
     JS_ENUMERATE_ITERATOR_PROTOTYPES
 #undef __JS_ENUMERATE
 };
diff --git a/Libraries/LibJS/Runtime/Iterator.cpp b/Libraries/LibJS/Runtime/Iterator.cpp
index 720a71d714c..1c03b5221da 100644
--- a/Libraries/LibJS/Runtime/Iterator.cpp
+++ b/Libraries/LibJS/Runtime/Iterator.cpp
@@ -16,15 +16,15 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Iterator);
-JS_DEFINE_ALLOCATOR(IteratorRecord);
+GC_DEFINE_ALLOCATOR(Iterator);
+GC_DEFINE_ALLOCATOR(IteratorRecord);
 
-NonnullGCPtr<Iterator> Iterator::create(Realm& realm, Object& prototype, NonnullGCPtr<IteratorRecord> iterated)
+GC::Ref<Iterator> Iterator::create(Realm& realm, Object& prototype, GC::Ref<IteratorRecord> iterated)
 {
     return realm.create<Iterator>(prototype, move(iterated));
 }
 
-Iterator::Iterator(Object& prototype, NonnullGCPtr<IteratorRecord> iterated)
+Iterator::Iterator(Object& prototype, GC::Ref<IteratorRecord> iterated)
     : Object(ConstructWithPrototypeTag::Tag, prototype)
     , m_iterated(move(iterated))
 {
@@ -36,7 +36,7 @@ Iterator::Iterator(Object& prototype)
 }
 
 // 7.4.2 GetIteratorDirect ( obj ), https://tc39.es/ecma262/#sec-getiteratordirect
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_direct(VM& vm, Object& object)
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_direct(VM& vm, Object& object)
 {
     // 1. Let nextMethod be ? Get(obj, "next").
     auto next_method = TRY(object.get(vm.names.next));
@@ -48,7 +48,7 @@ ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_direct(VM& vm, Obje
 }
 
 // 7.4.3 GetIteratorFromMethod ( obj, method ), https://tc39.es/ecma262/#sec-getiteratorfrommethod
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_from_method(VM& vm, Value object, NonnullGCPtr<FunctionObject> method)
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_from_method(VM& vm, Value object, GC::Ref<FunctionObject> method)
 {
     // 1. Let iterator be ? Call(method, obj).
     auto iterator = TRY(call(vm, *method, object));
@@ -69,9 +69,9 @@ ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_from_method(VM& vm,
 }
 
 // 7.4.4 GetIterator ( obj, kind ), https://tc39.es/ecma262/#sec-getiterator
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator(VM& vm, Value object, IteratorHint kind)
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator(VM& vm, Value object, IteratorHint kind)
 {
-    JS::GCPtr<FunctionObject> method;
+    GC::Ptr<FunctionObject> method;
 
     // 1. If kind is async, then
     if (kind == IteratorHint::Async) {
@@ -109,7 +109,7 @@ ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator(VM& vm, Value objec
 }
 
 // 7.4.5 GetIteratorFlattenable ( obj, primitiveHandling ), https://tc39.es/ecma262/#sec-getiteratorflattenable
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_flattenable(VM& vm, Value object, PrimitiveHandling primitive_handling)
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_flattenable(VM& vm, Value object, PrimitiveHandling primitive_handling)
 {
     // 1. If obj is not an Object, then
     if (!object.is_object()) {
@@ -150,7 +150,7 @@ ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_flattenable(VM& vm,
 }
 
 // 7.4.6 IteratorNext ( iteratorRecord [ , value ] ), https://tc39.es/ecma262/#sec-iteratornext
-ThrowCompletionOr<NonnullGCPtr<Object>> iterator_next(VM& vm, IteratorRecord& iterator_record, Optional<Value> value)
+ThrowCompletionOr<GC::Ref<Object>> iterator_next(VM& vm, IteratorRecord& iterator_record, Optional<Value> value)
 {
     auto result = [&]() {
         // 1. If value is not present, then
@@ -205,7 +205,7 @@ ThrowCompletionOr<Value> iterator_value(VM& vm, Object& iterator_result)
 }
 
 // 7.4.9 IteratorStep ( iteratorRecord ), https://tc39.es/ecma262/#sec-iteratorstep
-ThrowCompletionOr<GCPtr<Object>> iterator_step(VM& vm, IteratorRecord& iterator_record)
+ThrowCompletionOr<GC::Ptr<Object>> iterator_step(VM& vm, IteratorRecord& iterator_record)
 {
     // 1. Let result be ? IteratorNext(iteratorRecord).
     auto result = TRY(iterator_next(vm, iterator_record));
@@ -327,7 +327,7 @@ Completion async_iterator_close(VM& vm, IteratorRecord const& iterator_record, C
 }
 
 // 7.4.14 CreateIteratorResultObject ( value, done ), https://tc39.es/ecma262/#sec-createiterresultobject
-NonnullGCPtr<Object> create_iterator_result_object(VM& vm, Value value, bool done)
+GC::Ref<Object> create_iterator_result_object(VM& vm, Value value, bool done)
 {
     auto& realm = *vm.current_realm();
 
@@ -345,10 +345,10 @@ NonnullGCPtr<Object> create_iterator_result_object(VM& vm, Value value, bool don
 }
 
 // 7.4.16 IteratorToList ( iteratorRecord ), https://tc39.es/ecma262/#sec-iteratortolist
-ThrowCompletionOr<MarkedVector<Value>> iterator_to_list(VM& vm, IteratorRecord& iterator_record)
+ThrowCompletionOr<GC::MarkedVector<Value>> iterator_to_list(VM& vm, IteratorRecord& iterator_record)
 {
     // 1. Let values be a new empty List.
-    MarkedVector<Value> values(vm.heap());
+    GC::MarkedVector<Value> values(vm.heap());
 
     // 2. Repeat,
     while (true) {
diff --git a/Libraries/LibJS/Runtime/Iterator.h b/Libraries/LibJS/Runtime/Iterator.h
index d409772e25d..893d41ba4f3 100644
--- a/Libraries/LibJS/Runtime/Iterator.h
+++ b/Libraries/LibJS/Runtime/Iterator.h
@@ -19,10 +19,10 @@ namespace JS {
 // 7.4.1 Iterator Records, https://tc39.es/ecma262/#sec-iterator-records
 class IteratorRecord final : public Object {
     JS_OBJECT(IteratorRecord, Object);
-    JS_DECLARE_ALLOCATOR(IteratorRecord);
+    GC_DECLARE_ALLOCATOR(IteratorRecord);
 
 public:
-    IteratorRecord(Realm& realm, GCPtr<Object> iterator, Value next_method, bool done)
+    IteratorRecord(Realm& realm, GC::Ptr<Object> iterator, Value next_method, bool done)
         : Object(ConstructWithoutPrototypeTag::Tag, realm)
         , iterator(iterator)
         , next_method(next_method)
@@ -30,9 +30,9 @@ public:
     {
     }
 
-    GCPtr<Object> iterator; // [[Iterator]]
-    Value next_method;      // [[NextMethod]]
-    bool done { false };    // [[Done]]
+    GC::Ptr<Object> iterator; // [[Iterator]]
+    Value next_method;        // [[NextMethod]]
+    bool done { false };      // [[Done]]
 
 private:
     virtual void visit_edges(Cell::Visitor&) override;
@@ -44,20 +44,20 @@ inline bool Object::fast_is<IteratorRecord>() const { return is_iterator_record(
 
 class Iterator : public Object {
     JS_OBJECT(Iterator, Object);
-    JS_DECLARE_ALLOCATOR(Iterator);
+    GC_DECLARE_ALLOCATOR(Iterator);
 
 public:
-    static NonnullGCPtr<Iterator> create(Realm&, Object& prototype, NonnullGCPtr<IteratorRecord> iterated);
+    static GC::Ref<Iterator> create(Realm&, Object& prototype, GC::Ref<IteratorRecord> iterated);
 
     IteratorRecord const& iterated() const { return m_iterated; }
 
 private:
-    Iterator(Object& prototype, NonnullGCPtr<IteratorRecord> iterated);
+    Iterator(Object& prototype, GC::Ref<IteratorRecord> iterated);
     explicit Iterator(Object& prototype);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    NonnullGCPtr<IteratorRecord> m_iterated; // [[Iterated]]
+    GC::Ref<IteratorRecord> m_iterated; // [[Iterated]]
 };
 
 enum class IteratorHint {
@@ -70,19 +70,19 @@ enum class PrimitiveHandling {
     RejectPrimitives,
 };
 
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_direct(VM&, Object&);
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_from_method(VM&, Value, NonnullGCPtr<FunctionObject>);
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator(VM&, Value, IteratorHint);
-ThrowCompletionOr<NonnullGCPtr<IteratorRecord>> get_iterator_flattenable(VM&, Value, PrimitiveHandling);
-ThrowCompletionOr<NonnullGCPtr<Object>> iterator_next(VM&, IteratorRecord&, Optional<Value> = {});
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_direct(VM&, Object&);
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_from_method(VM&, Value, GC::Ref<FunctionObject>);
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator(VM&, Value, IteratorHint);
+ThrowCompletionOr<GC::Ref<IteratorRecord>> get_iterator_flattenable(VM&, Value, PrimitiveHandling);
+ThrowCompletionOr<GC::Ref<Object>> iterator_next(VM&, IteratorRecord&, Optional<Value> = {});
 ThrowCompletionOr<bool> iterator_complete(VM&, Object& iterator_result);
 ThrowCompletionOr<Value> iterator_value(VM&, Object& iterator_result);
-ThrowCompletionOr<GCPtr<Object>> iterator_step(VM&, IteratorRecord&);
+ThrowCompletionOr<GC::Ptr<Object>> iterator_step(VM&, IteratorRecord&);
 ThrowCompletionOr<Optional<Value>> iterator_step_value(VM&, IteratorRecord&);
 Completion iterator_close(VM&, IteratorRecord const&, Completion);
 Completion async_iterator_close(VM&, IteratorRecord const&, Completion);
-NonnullGCPtr<Object> create_iterator_result_object(VM&, Value, bool done);
-ThrowCompletionOr<MarkedVector<Value>> iterator_to_list(VM&, IteratorRecord&);
+GC::Ref<Object> create_iterator_result_object(VM&, Value, bool done);
+ThrowCompletionOr<GC::MarkedVector<Value>> iterator_to_list(VM&, IteratorRecord&);
 ThrowCompletionOr<void> setter_that_ignores_prototype_properties(VM&, Value this_, Object const& home, PropertyKey const& property, Value value);
 
 using IteratorValueCallback = Function<Optional<Completion>(Value)>;
diff --git a/Libraries/LibJS/Runtime/IteratorConstructor.cpp b/Libraries/LibJS/Runtime/IteratorConstructor.cpp
index dcc70b6a050..e4940a29ff7 100644
--- a/Libraries/LibJS/Runtime/IteratorConstructor.cpp
+++ b/Libraries/LibJS/Runtime/IteratorConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(IteratorConstructor);
+GC_DEFINE_ALLOCATOR(IteratorConstructor);
 
 // 27.1.3.1 The Iterator Constructor, https://tc39.es/ecma262/#sec-iterator-constructor
 IteratorConstructor::IteratorConstructor(Realm& realm)
@@ -47,7 +47,7 @@ ThrowCompletionOr<Value> IteratorConstructor::call()
 }
 
 // 27.1.3.1.1 Iterator ( ), https://tc39.es/ecma262/#sec-iterator
-ThrowCompletionOr<NonnullGCPtr<Object>> IteratorConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> IteratorConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/IteratorConstructor.h b/Libraries/LibJS/Runtime/IteratorConstructor.h
index f798405a2a6..88828f9019e 100644
--- a/Libraries/LibJS/Runtime/IteratorConstructor.h
+++ b/Libraries/LibJS/Runtime/IteratorConstructor.h
@@ -13,13 +13,13 @@ namespace JS {
 
 class IteratorConstructor : public NativeFunction {
     JS_OBJECT(IteratorConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(IteratorConstructor);
+    GC_DECLARE_ALLOCATOR(IteratorConstructor);
 
 public:
     virtual void initialize(Realm&) override;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit IteratorConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/IteratorHelper.cpp b/Libraries/LibJS/Runtime/IteratorHelper.cpp
index 7365f7fbacf..0e325fb9fd7 100644
--- a/Libraries/LibJS/Runtime/IteratorHelper.cpp
+++ b/Libraries/LibJS/Runtime/IteratorHelper.cpp
@@ -11,14 +11,14 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(IteratorHelper);
+GC_DEFINE_ALLOCATOR(IteratorHelper);
 
-ThrowCompletionOr<NonnullGCPtr<IteratorHelper>> IteratorHelper::create(Realm& realm, NonnullGCPtr<IteratorRecord> underlying_iterator, NonnullGCPtr<Closure> closure, GCPtr<AbruptClosure> abrupt_closure)
+ThrowCompletionOr<GC::Ref<IteratorHelper>> IteratorHelper::create(Realm& realm, GC::Ref<IteratorRecord> underlying_iterator, GC::Ref<Closure> closure, GC::Ptr<AbruptClosure> abrupt_closure)
 {
     return realm.create<IteratorHelper>(realm, realm.intrinsics().iterator_helper_prototype(), move(underlying_iterator), closure, abrupt_closure);
 }
 
-IteratorHelper::IteratorHelper(Realm& realm, Object& prototype, NonnullGCPtr<IteratorRecord> underlying_iterator, NonnullGCPtr<Closure> closure, GCPtr<AbruptClosure> abrupt_closure)
+IteratorHelper::IteratorHelper(Realm& realm, Object& prototype, GC::Ref<IteratorRecord> underlying_iterator, GC::Ref<Closure> closure, GC::Ptr<AbruptClosure> abrupt_closure)
     : GeneratorObject(realm, prototype, realm.vm().running_execution_context().copy(), "Iterator Helper"sv)
     , m_underlying_iterator(move(underlying_iterator))
     , m_closure(closure)
diff --git a/Libraries/LibJS/Runtime/IteratorHelper.h b/Libraries/LibJS/Runtime/IteratorHelper.h
index 161a83ceb64..2ee4e7b64e6 100644
--- a/Libraries/LibJS/Runtime/IteratorHelper.h
+++ b/Libraries/LibJS/Runtime/IteratorHelper.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/GeneratorObject.h>
 #include <LibJS/Runtime/Iterator.h>
@@ -16,13 +16,13 @@ namespace JS {
 
 class IteratorHelper final : public GeneratorObject {
     JS_OBJECT(IteratorHelper, GeneratorObject);
-    JS_DECLARE_ALLOCATOR(IteratorHelper);
+    GC_DECLARE_ALLOCATOR(IteratorHelper);
 
 public:
-    using Closure = JS::HeapFunction<ThrowCompletionOr<Value>(VM&, IteratorHelper&)>;
-    using AbruptClosure = JS::HeapFunction<ThrowCompletionOr<Value>(VM&, IteratorHelper&, Completion const&)>;
+    using Closure = GC::Function<ThrowCompletionOr<Value>(VM&, IteratorHelper&)>;
+    using AbruptClosure = GC::Function<ThrowCompletionOr<Value>(VM&, IteratorHelper&, Completion const&)>;
 
-    static ThrowCompletionOr<NonnullGCPtr<IteratorHelper>> create(Realm&, NonnullGCPtr<IteratorRecord>, NonnullGCPtr<Closure>, GCPtr<AbruptClosure> = {});
+    static ThrowCompletionOr<GC::Ref<IteratorHelper>> create(Realm&, GC::Ref<IteratorRecord>, GC::Ref<Closure>, GC::Ptr<AbruptClosure> = {});
 
     IteratorRecord& underlying_iterator() { return m_underlying_iterator; }
     IteratorRecord const& underlying_iterator() const { return m_underlying_iterator; }
@@ -34,14 +34,14 @@ public:
     ThrowCompletionOr<Value> close_result(VM&, Completion);
 
 private:
-    IteratorHelper(Realm&, Object& prototype, NonnullGCPtr<IteratorRecord>, NonnullGCPtr<Closure>, GCPtr<AbruptClosure>);
+    IteratorHelper(Realm&, Object& prototype, GC::Ref<IteratorRecord>, GC::Ref<Closure>, GC::Ptr<AbruptClosure>);
 
     virtual void visit_edges(Visitor&) override;
     virtual ThrowCompletionOr<Value> execute(VM&, JS::Completion const& completion) override;
 
-    NonnullGCPtr<IteratorRecord> m_underlying_iterator; // [[UnderlyingIterator]]
-    NonnullGCPtr<Closure> m_closure;
-    GCPtr<AbruptClosure> m_abrupt_closure;
+    GC::Ref<IteratorRecord> m_underlying_iterator; // [[UnderlyingIterator]]
+    GC::Ref<Closure> m_closure;
+    GC::Ptr<AbruptClosure> m_abrupt_closure;
 
     size_t m_counter { 0 };
     bool m_done { false };
diff --git a/Libraries/LibJS/Runtime/IteratorHelperPrototype.cpp b/Libraries/LibJS/Runtime/IteratorHelperPrototype.cpp
index 1b932a2a97d..22506ada634 100644
--- a/Libraries/LibJS/Runtime/IteratorHelperPrototype.cpp
+++ b/Libraries/LibJS/Runtime/IteratorHelperPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(IteratorHelperPrototype);
+GC_DEFINE_ALLOCATOR(IteratorHelperPrototype);
 
 // 27.1.2.1 The %IteratorHelperPrototype% Object, https://tc39.es/ecma262/#sec-%iteratorhelperprototype%-object
 IteratorHelperPrototype::IteratorHelperPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/IteratorHelperPrototype.h b/Libraries/LibJS/Runtime/IteratorHelperPrototype.h
index ad27504c211..ee344bbbe51 100644
--- a/Libraries/LibJS/Runtime/IteratorHelperPrototype.h
+++ b/Libraries/LibJS/Runtime/IteratorHelperPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class IteratorHelperPrototype final : public PrototypeObject<IteratorHelperPrototype, IteratorHelper> {
     JS_PROTOTYPE_OBJECT(IteratorHelperPrototype, IteratorHelper, IteratorHelper);
-    JS_DECLARE_ALLOCATOR(IteratorHelperPrototype);
+    GC_DECLARE_ALLOCATOR(IteratorHelperPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/IteratorPrototype.cpp b/Libraries/LibJS/Runtime/IteratorPrototype.cpp
index c4172fe5d12..3e152582d19 100644
--- a/Libraries/LibJS/Runtime/IteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/IteratorPrototype.cpp
@@ -18,7 +18,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(IteratorPrototype);
+GC_DEFINE_ALLOCATOR(IteratorPrototype);
 
 // 27.1.2 The %IteratorPrototype% Object, https://tc39.es/ecma262/#sec-%iteratorprototype%-object
 IteratorPrototype::IteratorPrototype(Realm& realm)
@@ -102,7 +102,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::drop)
     auto iterated = TRY(get_iterator_direct(vm, object));
 
     // 8. Let closure be a new Abstract Closure with no parameters that captures iterated and integerLimit and performs the following steps when called:
-    auto closure = JS::create_heap_function(realm.heap(), [integer_limit](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
+    auto closure = GC::create_function(realm.heap(), [integer_limit](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
         auto& iterated = iterator.underlying_iterator();
 
         // a. Let remaining be integerLimit.
@@ -205,7 +205,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::filter)
     auto iterated = TRY(get_iterator_direct(vm, object));
 
     // 5. Let closure be a new Abstract Closure with no parameters that captures iterated and predicate and performs the following steps when called:
-    auto closure = JS::create_heap_function(realm.heap(), [predicate = NonnullGCPtr { predicate.as_function() }](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
+    auto closure = GC::create_function(realm.heap(), [predicate = GC::Ref { predicate.as_function() }](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
         auto& iterated = iterator.underlying_iterator();
 
         // a. Let counter be 0.
@@ -292,8 +292,8 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::find)
 }
 
 class FlatMapIterator : public Cell {
-    JS_CELL(FlatMapIterator, Cell);
-    JS_DECLARE_ALLOCATOR(FlatMapIterator);
+    GC_CELL(FlatMapIterator, Cell);
+    GC_DECLARE_ALLOCATOR(FlatMapIterator);
 
 public:
     ThrowCompletionOr<Value> next(VM& vm, IteratorRecord& iterated, IteratorHelper& iterator, FunctionObject& mapper)
@@ -390,10 +390,10 @@ private:
         }
     }
 
-    GCPtr<IteratorRecord> m_inner_iterator;
+    GC::Ptr<IteratorRecord> m_inner_iterator;
 };
 
-JS_DEFINE_ALLOCATOR(FlatMapIterator);
+GC_DEFINE_ALLOCATOR(FlatMapIterator);
 
 // 27.1.4.6 Iterator.prototype.flatMap ( mapper ), https://tc39.es/ecma262/#sec-iterator.prototype.flatmap
 JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::flat_map)
@@ -416,12 +416,12 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::flat_map)
     auto flat_map_iterator = realm.create<FlatMapIterator>();
 
     // 5. Let closure be a new Abstract Closure with no parameters that captures iterated and mapper and performs the following steps when called:
-    auto closure = JS::create_heap_function(realm.heap(), [flat_map_iterator, mapper = NonnullGCPtr { mapper.as_function() }](VM& vm, IteratorHelper& iterator) mutable -> ThrowCompletionOr<Value> {
+    auto closure = GC::create_function(realm.heap(), [flat_map_iterator, mapper = GC::Ref { mapper.as_function() }](VM& vm, IteratorHelper& iterator) mutable -> ThrowCompletionOr<Value> {
         auto& iterated = iterator.underlying_iterator();
         return flat_map_iterator->next(vm, iterated, iterator, *mapper);
     });
 
-    auto abrupt_closure = JS::create_heap_function(realm.heap(), [flat_map_iterator](VM& vm, IteratorHelper& iterator, Completion const& completion) -> ThrowCompletionOr<Value> {
+    auto abrupt_closure = GC::create_function(realm.heap(), [flat_map_iterator](VM& vm, IteratorHelper& iterator, Completion const& completion) -> ThrowCompletionOr<Value> {
         return flat_map_iterator->on_abrupt_completion(vm, iterator, completion);
     });
 
@@ -492,7 +492,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::map)
     auto iterated = TRY(get_iterator_direct(vm, object));
 
     // 5. Let closure be a new Abstract Closure with no parameters that captures iterated and mapper and performs the following steps when called:
-    auto closure = JS::create_heap_function(realm.heap(), [mapper = NonnullGCPtr { mapper.as_function() }](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
+    auto closure = GC::create_function(realm.heap(), [mapper = GC::Ref { mapper.as_function() }](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
         auto& iterated = iterator.underlying_iterator();
 
         // a. Let counter be 0.
@@ -668,7 +668,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::take)
     auto iterated = TRY(get_iterator_direct(vm, object));
 
     // 8. Let closure be a new Abstract Closure with no parameters that captures iterated and integerLimit and performs the following steps when called:
-    auto closure = JS::create_heap_function(realm.heap(), [integer_limit](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
+    auto closure = GC::create_function(realm.heap(), [integer_limit](VM& vm, IteratorHelper& iterator) -> ThrowCompletionOr<Value> {
         auto& iterated = iterator.underlying_iterator();
 
         // a. Let remaining be integerLimit.
@@ -717,7 +717,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::to_array)
     auto iterated = TRY(get_iterator_direct(vm, object));
 
     // 4. Let items be a new empty List.
-    MarkedVector<Value> items(realm.heap());
+    GC::MarkedVector<Value> items(realm.heap());
 
     // 5. Repeat,
     while (true) {
diff --git a/Libraries/LibJS/Runtime/IteratorPrototype.h b/Libraries/LibJS/Runtime/IteratorPrototype.h
index 744422feb73..11f1087ce5f 100644
--- a/Libraries/LibJS/Runtime/IteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/IteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class IteratorPrototype : public PrototypeObject<IteratorPrototype, Iterator> {
     JS_PROTOTYPE_OBJECT(IteratorPrototype, Iterator, Iterator);
-    JS_DECLARE_ALLOCATOR(IteratorPrototype);
+    GC_DECLARE_ALLOCATOR(IteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/JSONObject.cpp b/Libraries/LibJS/Runtime/JSONObject.cpp
index 45a0722a755..b2fe3a34fd8 100644
--- a/Libraries/LibJS/Runtime/JSONObject.cpp
+++ b/Libraries/LibJS/Runtime/JSONObject.cpp
@@ -27,7 +27,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(JSONObject);
+GC_DEFINE_ALLOCATOR(JSONObject);
 
 JSONObject::JSONObject(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/JSONObject.h b/Libraries/LibJS/Runtime/JSONObject.h
index a3cbc4482b7..fd1f0cfbcd6 100644
--- a/Libraries/LibJS/Runtime/JSONObject.h
+++ b/Libraries/LibJS/Runtime/JSONObject.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class JSONObject final : public Object {
     JS_OBJECT(JSONObject, Object);
-    JS_DECLARE_ALLOCATOR(JSONObject);
+    GC_DECLARE_ALLOCATOR(JSONObject);
 
 public:
     virtual void initialize(Realm&) override;
@@ -28,8 +28,8 @@ private:
     explicit JSONObject(Realm&);
 
     struct StringifyState {
-        GCPtr<FunctionObject> replacer_function;
-        HashTable<GCPtr<Object>> seen_objects;
+        GC::Ptr<FunctionObject> replacer_function;
+        HashTable<GC::Ptr<Object>> seen_objects;
         ByteString indent { ByteString::empty() };
         ByteString gap;
         Optional<Vector<ByteString>> property_list;
diff --git a/Libraries/LibJS/Runtime/JobCallback.cpp b/Libraries/LibJS/Runtime/JobCallback.cpp
index ea22ce88473..f560bd69925 100644
--- a/Libraries/LibJS/Runtime/JobCallback.cpp
+++ b/Libraries/LibJS/Runtime/JobCallback.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(JobCallback);
+GC_DEFINE_ALLOCATOR(JobCallback);
 
-JS::NonnullGCPtr<JobCallback> JobCallback::create(JS::VM& vm, FunctionObject& callback, OwnPtr<CustomData> custom_data)
+GC::Ref<JobCallback> JobCallback::create(JS::VM& vm, FunctionObject& callback, OwnPtr<CustomData> custom_data)
 {
     return vm.heap().allocate<JobCallback>(callback, move(custom_data));
 }
@@ -23,14 +23,14 @@ void JobCallback::visit_edges(Visitor& visitor)
 }
 
 // 9.5.2 HostMakeJobCallback ( callback ), https://tc39.es/ecma262/#sec-hostmakejobcallback
-JS::NonnullGCPtr<JobCallback> make_job_callback(FunctionObject& callback)
+GC::Ref<JobCallback> make_job_callback(FunctionObject& callback)
 {
     // 1. Return the JobCallback Record { [[Callback]]: callback, [[HostDefined]]: empty }.
     return JobCallback::create(callback.vm(), callback, {});
 }
 
 // 9.5.3 HostCallJobCallback ( jobCallback, V, argumentsList ), https://tc39.es/ecma262/#sec-hostcalljobcallback
-ThrowCompletionOr<Value> call_job_callback(VM& vm, JS::NonnullGCPtr<JobCallback> job_callback, Value this_value, ReadonlySpan<Value> arguments_list)
+ThrowCompletionOr<Value> call_job_callback(VM& vm, GC::Ref<JobCallback> job_callback, Value this_value, ReadonlySpan<Value> arguments_list)
 {
     // 1. Assert: IsCallable(jobCallback.[[Callback]]) is true.
 
diff --git a/Libraries/LibJS/Runtime/JobCallback.h b/Libraries/LibJS/Runtime/JobCallback.h
index 2c0da5a739f..5279492a1ca 100644
--- a/Libraries/LibJS/Runtime/JobCallback.h
+++ b/Libraries/LibJS/Runtime/JobCallback.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/OwnPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/FunctionObject.h>
 #include <LibJS/Runtime/VM.h>
@@ -16,15 +16,15 @@ namespace JS {
 
 // 9.5.1 JobCallback Records, https://tc39.es/ecma262/#sec-jobcallback-records
 class JobCallback : public JS::Cell {
-    JS_CELL(JobCallback, JS::Cell);
-    JS_DECLARE_ALLOCATOR(JobCallback);
+    GC_CELL(JobCallback, JS::Cell);
+    GC_DECLARE_ALLOCATOR(JobCallback);
 
 public:
     struct CustomData {
         virtual ~CustomData() = default;
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<JobCallback> create(JS::VM& vm, FunctionObject& callback, OwnPtr<CustomData> custom_data);
+    [[nodiscard]] static GC::Ref<JobCallback> create(JS::VM& vm, FunctionObject& callback, OwnPtr<CustomData> custom_data);
 
     JobCallback(FunctionObject& callback, OwnPtr<CustomData> custom_data)
         : m_callback(callback)
@@ -38,11 +38,11 @@ public:
     CustomData* custom_data() { return m_custom_data; }
 
 private:
-    JS::NonnullGCPtr<FunctionObject> m_callback;
+    GC::Ref<FunctionObject> m_callback;
     OwnPtr<CustomData> m_custom_data { nullptr };
 };
 
-JS::NonnullGCPtr<JobCallback> make_job_callback(FunctionObject& callback);
-ThrowCompletionOr<Value> call_job_callback(VM&, JS::NonnullGCPtr<JobCallback>, Value this_value, ReadonlySpan<Value> arguments_list);
+GC::Ref<JobCallback> make_job_callback(FunctionObject& callback);
+ThrowCompletionOr<Value> call_job_callback(VM&, GC::Ref<JobCallback>, Value this_value, ReadonlySpan<Value> arguments_list);
 
 }
diff --git a/Libraries/LibJS/Runtime/Map.cpp b/Libraries/LibJS/Runtime/Map.cpp
index ef00c7f3728..bec3bc65f7c 100644
--- a/Libraries/LibJS/Runtime/Map.cpp
+++ b/Libraries/LibJS/Runtime/Map.cpp
@@ -8,9 +8,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Map);
+GC_DEFINE_ALLOCATOR(Map);
 
-NonnullGCPtr<Map> Map::create(Realm& realm)
+GC::Ref<Map> Map::create(Realm& realm)
 {
     return realm.create<Map>(realm.intrinsics().map_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/Map.h b/Libraries/LibJS/Runtime/Map.h
index af01a1fd2b5..bc020407c72 100644
--- a/Libraries/LibJS/Runtime/Map.h
+++ b/Libraries/LibJS/Runtime/Map.h
@@ -17,10 +17,10 @@ namespace JS {
 
 class Map : public Object {
     JS_OBJECT(Map, Object);
-    JS_DECLARE_ALLOCATOR(Map);
+    GC_DECLARE_ALLOCATOR(Map);
 
 public:
-    static NonnullGCPtr<Map> create(Realm&);
+    static GC::Ref<Map> create(Realm&);
 
     virtual ~Map() override = default;
 
@@ -95,7 +95,7 @@ public:
                 m_index = it.key();
         }
 
-        Conditional<IsConst, NonnullGCPtr<Map const>, NonnullGCPtr<Map>> m_map;
+        Conditional<IsConst, GC::Ref<Map const>, GC::Ref<Map>> m_map;
         mutable size_t m_index { 0 };
     };
 
diff --git a/Libraries/LibJS/Runtime/MapConstructor.cpp b/Libraries/LibJS/Runtime/MapConstructor.cpp
index a0ed4d40efb..db2bb7f77c1 100644
--- a/Libraries/LibJS/Runtime/MapConstructor.cpp
+++ b/Libraries/LibJS/Runtime/MapConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(MapConstructor);
+GC_DEFINE_ALLOCATOR(MapConstructor);
 
 MapConstructor::MapConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Map.as_string(), realm.intrinsics().function_prototype())
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> MapConstructor::call()
 }
 
 // 24.1.1.1 Map ( [ iterable ] ), https://tc39.es/ecma262/#sec-map-iterable
-ThrowCompletionOr<NonnullGCPtr<Object>> MapConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> MapConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -80,13 +80,13 @@ JS_DEFINE_NATIVE_FUNCTION(MapConstructor::group_by)
     auto items = vm.argument(0);
     auto callback_function = vm.argument(1);
 
-    struct KeyedGroupTraits : public Traits<Handle<Value>> {
-        static unsigned hash(Handle<Value> const& value_handle)
+    struct KeyedGroupTraits : public Traits<GC::Root<Value>> {
+        static unsigned hash(GC::Root<Value> const& value_handle)
         {
             return ValueTraits::hash(value_handle.value());
         }
 
-        static bool equals(Handle<Value> const& a, Handle<Value> const& b)
+        static bool equals(GC::Root<Value> const& a, GC::Root<Value> const& b)
         {
             // AddValueToKeyedGroup uses SameValue on the keys on Step 1.a.
             return same_value(a.value(), b.value());
@@ -94,7 +94,7 @@ JS_DEFINE_NATIVE_FUNCTION(MapConstructor::group_by)
     };
 
     // 1. Let groups be ? GroupBy(items, callbackfn, zero).
-    auto groups = TRY((JS::group_by<OrderedHashMap<Handle<Value>, MarkedVector<Value>, KeyedGroupTraits>, void>(vm, items, callback_function)));
+    auto groups = TRY((JS::group_by<OrderedHashMap<GC::Root<Value>, GC::MarkedVector<Value>, KeyedGroupTraits>, void>(vm, items, callback_function)));
 
     // 2. Let map be ! Construct(%Map%).
     auto map = Map::create(realm);
diff --git a/Libraries/LibJS/Runtime/MapConstructor.h b/Libraries/LibJS/Runtime/MapConstructor.h
index 4b1707bdcdf..ce9929bc5f1 100644
--- a/Libraries/LibJS/Runtime/MapConstructor.h
+++ b/Libraries/LibJS/Runtime/MapConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class MapConstructor final : public NativeFunction {
     JS_OBJECT(MapConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(MapConstructor);
+    GC_DECLARE_ALLOCATOR(MapConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~MapConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit MapConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/MapIterator.cpp b/Libraries/LibJS/Runtime/MapIterator.cpp
index eb8755a2f60..7d498813972 100644
--- a/Libraries/LibJS/Runtime/MapIterator.cpp
+++ b/Libraries/LibJS/Runtime/MapIterator.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(MapIterator);
+GC_DEFINE_ALLOCATOR(MapIterator);
 
-NonnullGCPtr<MapIterator> MapIterator::create(Realm& realm, Map& map, Object::PropertyKind iteration_kind)
+GC::Ref<MapIterator> MapIterator::create(Realm& realm, Map& map, Object::PropertyKind iteration_kind)
 {
     return realm.create<MapIterator>(map, iteration_kind, realm.intrinsics().map_iterator_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/MapIterator.h b/Libraries/LibJS/Runtime/MapIterator.h
index ac31c06c0bd..224dec301fb 100644
--- a/Libraries/LibJS/Runtime/MapIterator.h
+++ b/Libraries/LibJS/Runtime/MapIterator.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class MapIterator final : public Object {
     JS_OBJECT(MapIterator, Object);
-    JS_DECLARE_ALLOCATOR(MapIterator);
+    GC_DECLARE_ALLOCATOR(MapIterator);
 
 public:
-    static NonnullGCPtr<MapIterator> create(Realm&, Map& map, Object::PropertyKind iteration_kind);
+    static GC::Ref<MapIterator> create(Realm&, Map& map, Object::PropertyKind iteration_kind);
 
     virtual ~MapIterator() override = default;
 
@@ -32,7 +32,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    NonnullGCPtr<Map> m_map;
+    GC::Ref<Map> m_map;
     bool m_done { false };
     Object::PropertyKind m_iteration_kind;
     Map::ConstIterator m_iterator;
diff --git a/Libraries/LibJS/Runtime/MapIteratorPrototype.cpp b/Libraries/LibJS/Runtime/MapIteratorPrototype.cpp
index 0aff979af4e..806122776e9 100644
--- a/Libraries/LibJS/Runtime/MapIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/MapIteratorPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(MapIteratorPrototype);
+GC_DEFINE_ALLOCATOR(MapIteratorPrototype);
 
 MapIteratorPrototype::MapIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/MapIteratorPrototype.h b/Libraries/LibJS/Runtime/MapIteratorPrototype.h
index e585f9e454c..e51a3f2d88b 100644
--- a/Libraries/LibJS/Runtime/MapIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/MapIteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class MapIteratorPrototype final : public PrototypeObject<MapIteratorPrototype, MapIterator> {
     JS_PROTOTYPE_OBJECT(MapIteratorPrototype, MapIterator, MapIterator);
-    JS_DECLARE_ALLOCATOR(MapIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(MapIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/MapPrototype.cpp b/Libraries/LibJS/Runtime/MapPrototype.cpp
index f0be4140f0e..048e891f7fe 100644
--- a/Libraries/LibJS/Runtime/MapPrototype.cpp
+++ b/Libraries/LibJS/Runtime/MapPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(MapPrototype);
+GC_DEFINE_ALLOCATOR(MapPrototype);
 
 MapPrototype::MapPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/MapPrototype.h b/Libraries/LibJS/Runtime/MapPrototype.h
index 6cd6cfce65d..5b241a3ece1 100644
--- a/Libraries/LibJS/Runtime/MapPrototype.h
+++ b/Libraries/LibJS/Runtime/MapPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class MapPrototype final : public PrototypeObject<MapPrototype, Map> {
     JS_PROTOTYPE_OBJECT(MapPrototype, Map, Map);
-    JS_DECLARE_ALLOCATOR(MapPrototype);
+    GC_DECLARE_ALLOCATOR(MapPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/MathObject.cpp b/Libraries/LibJS/Runtime/MathObject.cpp
index e588c762b1b..dc671cd80db 100644
--- a/Libraries/LibJS/Runtime/MathObject.cpp
+++ b/Libraries/LibJS/Runtime/MathObject.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(MathObject);
+GC_DEFINE_ALLOCATOR(MathObject);
 
 MathObject::MathObject(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/MathObject.h b/Libraries/LibJS/Runtime/MathObject.h
index 14dfb79ba6d..c5705faf770 100644
--- a/Libraries/LibJS/Runtime/MathObject.h
+++ b/Libraries/LibJS/Runtime/MathObject.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class MathObject final : public Object {
     JS_OBJECT(MathObject, Object);
-    JS_DECLARE_ALLOCATOR(MathObject);
+    GC_DECLARE_ALLOCATOR(MathObject);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ModuleEnvironment.cpp b/Libraries/LibJS/Runtime/ModuleEnvironment.cpp
index 43d6b13522b..d663da1e1fa 100644
--- a/Libraries/LibJS/Runtime/ModuleEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/ModuleEnvironment.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ModuleEnvironment);
+GC_DEFINE_ALLOCATOR(ModuleEnvironment);
 
 // 9.1.2.6 NewModuleEnvironment ( E ), https://tc39.es/ecma262/#sec-newmoduleenvironment
 ModuleEnvironment::ModuleEnvironment(Environment* outer_environment)
diff --git a/Libraries/LibJS/Runtime/ModuleEnvironment.h b/Libraries/LibJS/Runtime/ModuleEnvironment.h
index 398080798e5..35de87de90c 100644
--- a/Libraries/LibJS/Runtime/ModuleEnvironment.h
+++ b/Libraries/LibJS/Runtime/ModuleEnvironment.h
@@ -15,7 +15,7 @@ namespace JS {
 // 9.1.1.5 Module Environment Records, https://tc39.es/ecma262/#sec-module-environment-records
 class ModuleEnvironment final : public DeclarativeEnvironment {
     JS_ENVIRONMENT(ModuleEnvironment, DeclarativeEnvironment);
-    JS_DECLARE_ALLOCATOR(ModuleEnvironment);
+    GC_DECLARE_ALLOCATOR(ModuleEnvironment);
 
 public:
     // Note: Module Environment Records support all of the declarative Environment Record methods listed
@@ -35,7 +35,7 @@ private:
 
     struct IndirectBinding {
         DeprecatedFlyString name;
-        GCPtr<Module> module;
+        GC::Ptr<Module> module;
         DeprecatedFlyString binding_name;
     };
     IndirectBinding const* get_indirect_binding(DeprecatedFlyString const& name) const;
diff --git a/Libraries/LibJS/Runtime/ModuleNamespaceObject.cpp b/Libraries/LibJS/Runtime/ModuleNamespaceObject.cpp
index 69e9cde9c15..3043312b2ed 100644
--- a/Libraries/LibJS/Runtime/ModuleNamespaceObject.cpp
+++ b/Libraries/LibJS/Runtime/ModuleNamespaceObject.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ModuleNamespaceObject);
+GC_DEFINE_ALLOCATOR(ModuleNamespaceObject);
 
 ModuleNamespaceObject::ModuleNamespaceObject(Realm& realm, Module* module, Vector<DeprecatedFlyString> exports)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype(), MayInterfereWithIndexedPropertyAccess::Yes)
@@ -210,11 +210,11 @@ ThrowCompletionOr<bool> ModuleNamespaceObject::internal_delete(PropertyKey const
 }
 
 // 10.4.6.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-module-namespace-exotic-objects-ownpropertykeys
-ThrowCompletionOr<MarkedVector<Value>> ModuleNamespaceObject::internal_own_property_keys() const
+ThrowCompletionOr<GC::MarkedVector<Value>> ModuleNamespaceObject::internal_own_property_keys() const
 {
     // 1. Let exports be O.[[Exports]].
     // NOTE: We only add the exports after we know the size of symbolKeys
-    MarkedVector<Value> exports { vm().heap() };
+    GC::MarkedVector<Value> exports { vm().heap() };
 
     // 2. Let symbolKeys be OrdinaryOwnPropertyKeys(O).
     auto symbol_keys = MUST(Object::internal_own_property_keys());
diff --git a/Libraries/LibJS/Runtime/ModuleNamespaceObject.h b/Libraries/LibJS/Runtime/ModuleNamespaceObject.h
index be38f934717..dba75fe9609 100644
--- a/Libraries/LibJS/Runtime/ModuleNamespaceObject.h
+++ b/Libraries/LibJS/Runtime/ModuleNamespaceObject.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class ModuleNamespaceObject final : public Object {
     JS_OBJECT(ModuleNamespaceObject, Object);
-    JS_DECLARE_ALLOCATOR(ModuleNamespaceObject);
+    GC_DECLARE_ALLOCATOR(ModuleNamespaceObject);
 
 public:
     // 10.4.6 Module Namespace Exotic Objects, https://tc39.es/ecma262/#sec-module-namespace-exotic-objects
@@ -29,7 +29,7 @@ public:
     virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty) const override;
     virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata*) override;
     virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const override;
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
     virtual void initialize(Realm&) override;
 
 private:
@@ -37,7 +37,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<Module> m_module;                // [[Module]]
+    GC::Ptr<Module> m_module;              // [[Module]]
     Vector<DeprecatedFlyString> m_exports; // [[Exports]]
 };
 
diff --git a/Libraries/LibJS/Runtime/ModuleRequest.h b/Libraries/LibJS/Runtime/ModuleRequest.h
index 1f1f1d1834d..3a447b1d3f0 100644
--- a/Libraries/LibJS/Runtime/ModuleRequest.h
+++ b/Libraries/LibJS/Runtime/ModuleRequest.h
@@ -14,8 +14,8 @@
 namespace JS {
 
 struct ModuleWithSpecifier {
-    ByteString specifier;        // [[Specifier]]
-    NonnullGCPtr<Module> module; // [[Module]]
+    ByteString specifier;   // [[Specifier]]
+    GC::Ref<Module> module; // [[Module]]
 };
 
 // https://tc39.es/proposal-import-attributes/#importattribute-record
diff --git a/Libraries/LibJS/Runtime/NativeFunction.cpp b/Libraries/LibJS/Runtime/NativeFunction.cpp
index 10773e008c6..f82a735a6f2 100644
--- a/Libraries/LibJS/Runtime/NativeFunction.cpp
+++ b/Libraries/LibJS/Runtime/NativeFunction.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(NativeFunction);
+GC_DEFINE_ALLOCATOR(NativeFunction);
 
 void NativeFunction::initialize(Realm& realm)
 {
@@ -33,7 +33,7 @@ void NativeFunction::visit_edges(Cell::Visitor& visitor)
 
 // 10.3.3 CreateBuiltinFunction ( behaviour, length, name, additionalInternalSlotsList [ , realm [ , prototype [ , prefix ] ] ] ), https://tc39.es/ecma262/#sec-createbuiltinfunction
 // NOTE: This doesn't consider additionalInternalSlotsList, which is rarely used, and can either be implemented using only the `function` lambda, or needs a NativeFunction subclass.
-NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& allocating_realm, Function<ThrowCompletionOr<Value>(VM&)> behaviour, i32 length, PropertyKey const& name, Optional<Realm*> realm, Optional<Object*> prototype, Optional<StringView> const& prefix)
+GC::Ref<NativeFunction> NativeFunction::create(Realm& allocating_realm, Function<ThrowCompletionOr<Value>(VM&)> behaviour, i32 length, PropertyKey const& name, Optional<Realm*> realm, Optional<Object*> prototype, Optional<StringView> const& prefix)
 {
     auto& vm = allocating_realm.vm();
 
@@ -53,7 +53,7 @@ NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& allocating_realm, Fun
     // 7. Set func.[[Extensible]] to true.
     // 8. Set func.[[Realm]] to realm.
     // 9. Set func.[[InitialName]] to null.
-    auto function = allocating_realm.create<NativeFunction>(JS::create_heap_function(vm.heap(), move(behaviour)), prototype.value(), *realm.value());
+    auto function = allocating_realm.create<NativeFunction>(GC::create_function(vm.heap(), move(behaviour)), prototype.value(), *realm.value());
 
     // 10. Perform SetFunctionLength(func, length).
     function->set_function_length(length);
@@ -68,12 +68,12 @@ NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& allocating_realm, Fun
     return function;
 }
 
-NonnullGCPtr<NativeFunction> NativeFunction::create(Realm& realm, DeprecatedFlyString const& name, Function<ThrowCompletionOr<Value>(VM&)> function)
+GC::Ref<NativeFunction> NativeFunction::create(Realm& realm, DeprecatedFlyString const& name, Function<ThrowCompletionOr<Value>(VM&)> function)
 {
-    return realm.create<NativeFunction>(name, JS::create_heap_function(realm.heap(), move(function)), realm.intrinsics().function_prototype());
+    return realm.create<NativeFunction>(name, GC::create_function(realm.heap(), move(function)), realm.intrinsics().function_prototype());
 }
 
-NativeFunction::NativeFunction(JS::GCPtr<JS::HeapFunction<ThrowCompletionOr<Value>(VM&)>> native_function, Object* prototype, Realm& realm)
+NativeFunction::NativeFunction(GC::Ptr<GC::Function<ThrowCompletionOr<Value>(VM&)>> native_function, Object* prototype, Realm& realm)
     : FunctionObject(realm, prototype)
     , m_native_function(move(native_function))
     , m_realm(&realm)
@@ -90,7 +90,7 @@ NativeFunction::NativeFunction(Object& prototype)
 {
 }
 
-NativeFunction::NativeFunction(DeprecatedFlyString name, JS::GCPtr<JS::HeapFunction<ThrowCompletionOr<Value>(VM&)>> native_function, Object& prototype)
+NativeFunction::NativeFunction(DeprecatedFlyString name, GC::Ptr<GC::Function<ThrowCompletionOr<Value>(VM&)>> native_function, Object& prototype)
     : FunctionObject(prototype)
     , m_name(move(name))
     , m_native_function(move(native_function))
@@ -173,7 +173,7 @@ ThrowCompletionOr<Value> NativeFunction::internal_call(Value this_argument, Read
 }
 
 // 10.3.2 [[Construct]] ( argumentsList, newTarget ), https://tc39.es/ecma262/#sec-built-in-function-objects-construct-argumentslist-newtarget
-ThrowCompletionOr<NonnullGCPtr<Object>> NativeFunction::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> NativeFunction::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
@@ -237,7 +237,7 @@ ThrowCompletionOr<Value> NativeFunction::call()
     return m_native_function->function()(vm());
 }
 
-ThrowCompletionOr<NonnullGCPtr<Object>> NativeFunction::construct(FunctionObject&)
+ThrowCompletionOr<GC::Ref<Object>> NativeFunction::construct(FunctionObject&)
 {
     // Needs to be overridden if [[Construct]] is needed.
     VERIFY_NOT_REACHED();
diff --git a/Libraries/LibJS/Runtime/NativeFunction.h b/Libraries/LibJS/Runtime/NativeFunction.h
index 2865990412b..114668fbe38 100644
--- a/Libraries/LibJS/Runtime/NativeFunction.h
+++ b/Libraries/LibJS/Runtime/NativeFunction.h
@@ -9,7 +9,7 @@
 
 #include <AK/Badge.h>
 #include <AK/Optional.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/FunctionObject.h>
 #include <LibJS/Runtime/PropertyKey.h>
@@ -18,21 +18,21 @@ namespace JS {
 
 class NativeFunction : public FunctionObject {
     JS_OBJECT(NativeFunction, FunctionObject);
-    JS_DECLARE_ALLOCATOR(NativeFunction);
+    GC_DECLARE_ALLOCATOR(NativeFunction);
 
 public:
-    static NonnullGCPtr<NativeFunction> create(Realm&, ESCAPING Function<ThrowCompletionOr<Value>(VM&)> behaviour, i32 length, PropertyKey const& name, Optional<Realm*> = {}, Optional<Object*> prototype = {}, Optional<StringView> const& prefix = {});
-    static NonnullGCPtr<NativeFunction> create(Realm&, DeprecatedFlyString const& name, ESCAPING Function<ThrowCompletionOr<Value>(VM&)>);
+    static GC::Ref<NativeFunction> create(Realm&, ESCAPING Function<ThrowCompletionOr<Value>(VM&)> behaviour, i32 length, PropertyKey const& name, Optional<Realm*> = {}, Optional<Object*> prototype = {}, Optional<StringView> const& prefix = {});
+    static GC::Ref<NativeFunction> create(Realm&, DeprecatedFlyString const& name, ESCAPING Function<ThrowCompletionOr<Value>(VM&)>);
 
     virtual ~NativeFunction() override = default;
 
     virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
 
     // Used for [[Call]] / [[Construct]]'s "...result of evaluating F in a manner that conforms to the specification of F".
     // Needs to be overridden by all NativeFunctions without an m_native_function.
     virtual ThrowCompletionOr<Value> call();
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target);
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target);
 
     virtual DeprecatedFlyString const& name() const override { return m_name; }
     virtual bool is_strict_mode() const override;
@@ -44,8 +44,8 @@ public:
 
 protected:
     NativeFunction(DeprecatedFlyString name, Object& prototype);
-    NativeFunction(JS::GCPtr<JS::HeapFunction<ThrowCompletionOr<Value>(VM&)>>, Object* prototype, Realm& realm);
-    NativeFunction(DeprecatedFlyString name, JS::GCPtr<JS::HeapFunction<ThrowCompletionOr<Value>(VM&)>>, Object& prototype);
+    NativeFunction(GC::Ptr<GC::Function<ThrowCompletionOr<Value>(VM&)>>, Object* prototype, Realm& realm);
+    NativeFunction(DeprecatedFlyString name, GC::Ptr<GC::Function<ThrowCompletionOr<Value>(VM&)>>, Object& prototype);
     explicit NativeFunction(Object& prototype);
 
     virtual void initialize(Realm&) override;
@@ -55,10 +55,10 @@ private:
     virtual bool is_native_function() const final { return true; }
 
     DeprecatedFlyString m_name;
-    GCPtr<PrimitiveString> m_name_string;
+    GC::Ptr<PrimitiveString> m_name_string;
     Optional<DeprecatedFlyString> m_initial_name; // [[InitialName]]
-    JS::GCPtr<JS::HeapFunction<ThrowCompletionOr<Value>(VM&)>> m_native_function;
-    GCPtr<Realm> m_realm;
+    GC::Ptr<GC::Function<ThrowCompletionOr<Value>(VM&)>> m_native_function;
+    GC::Ptr<Realm> m_realm;
 };
 
 template<>
diff --git a/Libraries/LibJS/Runtime/NumberConstructor.cpp b/Libraries/LibJS/Runtime/NumberConstructor.cpp
index 8a476e1367e..2cebc155c06 100644
--- a/Libraries/LibJS/Runtime/NumberConstructor.cpp
+++ b/Libraries/LibJS/Runtime/NumberConstructor.cpp
@@ -25,7 +25,7 @@ constexpr double const MIN_SAFE_INTEGER_VALUE { -(__builtin_exp2(53) - 1) };
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(NumberConstructor);
+GC_DEFINE_ALLOCATOR(NumberConstructor);
 
 NumberConstructor::NumberConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Number.as_string(), realm.intrinsics().function_prototype())
@@ -94,7 +94,7 @@ ThrowCompletionOr<Value> NumberConstructor::call()
 }
 
 // 21.1.1.1 Number ( value ), https://tc39.es/ecma262/#sec-number-constructor-number-value
-ThrowCompletionOr<NonnullGCPtr<Object>> NumberConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> NumberConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     // NOTE: get_value_from_constructor_argument performs steps 1 and 2 and returns n.
diff --git a/Libraries/LibJS/Runtime/NumberConstructor.h b/Libraries/LibJS/Runtime/NumberConstructor.h
index 1aa4c174c66..9ed3331a296 100644
--- a/Libraries/LibJS/Runtime/NumberConstructor.h
+++ b/Libraries/LibJS/Runtime/NumberConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class NumberConstructor final : public NativeFunction {
     JS_OBJECT(NumberConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(NumberConstructor);
+    GC_DECLARE_ALLOCATOR(NumberConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~NumberConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit NumberConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/NumberObject.cpp b/Libraries/LibJS/Runtime/NumberObject.cpp
index 3b1a5d6b696..94b6fb95969 100644
--- a/Libraries/LibJS/Runtime/NumberObject.cpp
+++ b/Libraries/LibJS/Runtime/NumberObject.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(NumberObject);
+GC_DEFINE_ALLOCATOR(NumberObject);
 
-NonnullGCPtr<NumberObject> NumberObject::create(Realm& realm, double value)
+GC::Ref<NumberObject> NumberObject::create(Realm& realm, double value)
 {
     return realm.create<NumberObject>(value, realm.intrinsics().number_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/NumberObject.h b/Libraries/LibJS/Runtime/NumberObject.h
index 9efcdddccc0..13fb041c2d0 100644
--- a/Libraries/LibJS/Runtime/NumberObject.h
+++ b/Libraries/LibJS/Runtime/NumberObject.h
@@ -12,10 +12,10 @@ namespace JS {
 
 class NumberObject : public Object {
     JS_OBJECT(NumberObject, Object);
-    JS_DECLARE_ALLOCATOR(NumberObject);
+    GC_DECLARE_ALLOCATOR(NumberObject);
 
 public:
-    static NonnullGCPtr<NumberObject> create(Realm&, double);
+    static GC::Ref<NumberObject> create(Realm&, double);
 
     virtual ~NumberObject() override = default;
 
diff --git a/Libraries/LibJS/Runtime/NumberPrototype.cpp b/Libraries/LibJS/Runtime/NumberPrototype.cpp
index 80ba7b564dd..c51892b9b89 100644
--- a/Libraries/LibJS/Runtime/NumberPrototype.cpp
+++ b/Libraries/LibJS/Runtime/NumberPrototype.cpp
@@ -22,7 +22,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(NumberPrototype);
+GC_DEFINE_ALLOCATOR(NumberPrototype);
 
 static constexpr AK::Array<u8, 37> max_precision_for_radix = {
     // clang-format off
diff --git a/Libraries/LibJS/Runtime/NumberPrototype.h b/Libraries/LibJS/Runtime/NumberPrototype.h
index 23306b528ab..c8a79107cd5 100644
--- a/Libraries/LibJS/Runtime/NumberPrototype.h
+++ b/Libraries/LibJS/Runtime/NumberPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class NumberPrototype final : public NumberObject {
     JS_OBJECT(NumberPrototype, NumberObject);
-    JS_DECLARE_ALLOCATOR(NumberPrototype);
+    GC_DECLARE_ALLOCATOR(NumberPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Object.cpp b/Libraries/LibJS/Runtime/Object.cpp
index aa6450cca7f..16b14613df3 100644
--- a/Libraries/LibJS/Runtime/Object.cpp
+++ b/Libraries/LibJS/Runtime/Object.cpp
@@ -23,12 +23,12 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Object);
+GC_DEFINE_ALLOCATOR(Object);
 
-static HashMap<GCPtr<Object const>, HashMap<DeprecatedFlyString, Object::IntrinsicAccessor>> s_intrinsics;
+static HashMap<GC::Ptr<Object const>, HashMap<DeprecatedFlyString, Object::IntrinsicAccessor>> s_intrinsics;
 
 // 10.1.12 OrdinaryObjectCreate ( proto [ , additionalInternalSlotsList ] ), https://tc39.es/ecma262/#sec-ordinaryobjectcreate
-NonnullGCPtr<Object> Object::create(Realm& realm, Object* prototype)
+GC::Ref<Object> Object::create(Realm& realm, Object* prototype)
 {
     if (!prototype)
         return realm.create<Object>(realm.intrinsics().empty_object_shape());
@@ -37,7 +37,7 @@ NonnullGCPtr<Object> Object::create(Realm& realm, Object* prototype)
     return realm.create<Object>(ConstructWithPrototypeTag::Tag, *prototype);
 }
 
-NonnullGCPtr<Object> Object::create_prototype(Realm& realm, Object* prototype)
+GC::Ref<Object> Object::create_prototype(Realm& realm, Object* prototype)
 {
     auto shape = realm.heap().allocate<Shape>(realm);
     if (prototype)
@@ -45,7 +45,7 @@ NonnullGCPtr<Object> Object::create_prototype(Realm& realm, Object* prototype)
     return realm.create<Object>(shape);
 }
 
-NonnullGCPtr<Object> Object::create_with_premade_shape(Shape& shape)
+GC::Ref<Object> Object::create_with_premade_shape(Shape& shape)
 {
     return shape.realm().create<Object>(shape);
 }
@@ -371,7 +371,7 @@ ThrowCompletionOr<bool> Object::test_integrity_level(IntegrityLevel level) const
 }
 
 // 7.3.24 EnumerableOwnPropertyNames ( O, kind ), https://tc39.es/ecma262/#sec-enumerableownpropertynames
-ThrowCompletionOr<MarkedVector<Value>> Object::enumerable_own_property_names(PropertyKind kind) const
+ThrowCompletionOr<GC::MarkedVector<Value>> Object::enumerable_own_property_names(PropertyKind kind) const
 {
     // NOTE: This has been flattened for readability, so some `else` branches in the
     //       spec text have been replaced with `continue`s in the loop below.
@@ -383,7 +383,7 @@ ThrowCompletionOr<MarkedVector<Value>> Object::enumerable_own_property_names(Pro
     auto own_keys = TRY(internal_own_property_keys());
 
     // 2. Let properties be a new empty List.
-    auto properties = MarkedVector<Value> { heap() };
+    auto properties = GC::MarkedVector<Value> { heap() };
 
     // 3. For each element key of ownKeys, do
     for (auto& key : own_keys) {
@@ -480,7 +480,7 @@ ThrowCompletionOr<void> Object::copy_data_properties(VM& vm, Value source, HashT
 }
 
 // 14.7 SnapshotOwnProperties ( source, proto [ , excludedKeys [ , excludedValues ] ] ), https://tc39.es/proposal-temporal/#sec-snapshotownproperties
-ThrowCompletionOr<NonnullGCPtr<Object>> Object::snapshot_own_properties(VM& vm, GCPtr<Object> prototype, HashTable<PropertyKey> const& excluded_keys, HashTable<Value> const& excluded_values)
+ThrowCompletionOr<GC::Ref<Object>> Object::snapshot_own_properties(VM& vm, GC::Ptr<Object> prototype, HashTable<PropertyKey> const& excluded_keys, HashTable<Value> const& excluded_values)
 {
     auto& realm = *vm.current_realm();
 
@@ -1070,12 +1070,12 @@ ThrowCompletionOr<bool> Object::internal_delete(PropertyKey const& property_key)
 }
 
 // 10.1.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
-ThrowCompletionOr<MarkedVector<Value>> Object::internal_own_property_keys() const
+ThrowCompletionOr<GC::MarkedVector<Value>> Object::internal_own_property_keys() const
 {
     auto& vm = this->vm();
 
     // 1. Let keys be a new empty List.
-    MarkedVector<Value> keys { heap() };
+    GC::MarkedVector<Value> keys { heap() };
 
     // 2. For each own property key P of O such that P is an array index, in ascending numeric index order, do
     for (auto& entry : m_indexed_properties) {
diff --git a/Libraries/LibJS/Runtime/Object.h b/Libraries/LibJS/Runtime/Object.h
index 3459cfcbefb..606d86fb9e6 100644
--- a/Libraries/LibJS/Runtime/Object.h
+++ b/Libraries/LibJS/Runtime/Object.h
@@ -10,10 +10,10 @@
 #include <AK/Badge.h>
 #include <AK/HashMap.h>
 #include <AK/StringView.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/IndexedProperties.h>
 #include <LibJS/Runtime/PrimitiveString.h>
@@ -25,7 +25,7 @@
 
 namespace JS {
 
-#define JS_OBJECT(class_, base_class) JS_CELL(class_, base_class)
+#define JS_OBJECT(class_, base_class) GC_CELL(class_, base_class)
 
 struct PrivateElement {
     enum class Kind {
@@ -49,17 +49,17 @@ struct CacheablePropertyMetadata {
     };
     Type type { Type::NotCacheable };
     Optional<u32> property_offset;
-    GCPtr<Object const> prototype;
+    GC::Ptr<Object const> prototype;
 };
 
 class Object : public Cell {
-    JS_CELL(Object, Cell);
-    JS_DECLARE_ALLOCATOR(Object);
+    GC_CELL(Object, Cell);
+    GC_DECLARE_ALLOCATOR(Object);
 
 public:
-    static NonnullGCPtr<Object> create_prototype(Realm&, Object* prototype);
-    static NonnullGCPtr<Object> create(Realm&, Object* prototype);
-    static NonnullGCPtr<Object> create_with_premade_shape(Shape&);
+    static GC::Ref<Object> create_prototype(Realm&, Object* prototype);
+    static GC::Ref<Object> create(Realm&, Object* prototype);
+    static GC::Ref<Object> create_with_premade_shape(Shape&);
 
     virtual void initialize(Realm&) override;
     virtual ~Object();
@@ -119,9 +119,9 @@ public:
     ThrowCompletionOr<bool> has_own_property(PropertyKey const&) const;
     ThrowCompletionOr<bool> set_integrity_level(IntegrityLevel);
     ThrowCompletionOr<bool> test_integrity_level(IntegrityLevel) const;
-    ThrowCompletionOr<MarkedVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
+    ThrowCompletionOr<GC::MarkedVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
     ThrowCompletionOr<void> copy_data_properties(VM&, Value source, HashTable<PropertyKey> const& excluded_keys, HashTable<JS::Value> const& excluded_values = {});
-    ThrowCompletionOr<NonnullGCPtr<Object>> snapshot_own_properties(VM&, GCPtr<Object> prototype, HashTable<PropertyKey> const& excluded_keys = {}, HashTable<Value> const& excluded_values = {});
+    ThrowCompletionOr<GC::Ref<Object>> snapshot_own_properties(VM&, GC::Ptr<Object> prototype, HashTable<PropertyKey> const& excluded_keys = {}, HashTable<Value> const& excluded_values = {});
 
     PrivateElement* private_element_find(PrivateName const& name);
     ThrowCompletionOr<void> private_field_add(PrivateName const& name, Value value);
@@ -147,7 +147,7 @@ public:
     virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty) const;
     virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata* = nullptr);
     virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&);
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const;
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const;
 
     // NOTE: Any subclass of Object that overrides property access slots ([[Get]], [[Set]] etc)
     //       to customize access to indexed properties (properties where the name is a positive integer)
@@ -262,7 +262,7 @@ private:
     // True if this object has lazily allocated intrinsic properties.
     bool m_has_intrinsic_accessors { false };
 
-    GCPtr<Shape> m_shape;
+    GC::Ptr<Shape> m_shape;
     Vector<Value> m_storage;
     IndexedProperties m_indexed_properties;
     OwnPtr<Vector<PrivateElement>> m_private_elements; // [[PrivateElements]]
diff --git a/Libraries/LibJS/Runtime/ObjectConstructor.cpp b/Libraries/LibJS/Runtime/ObjectConstructor.cpp
index 6cb4aafc6fc..1bcfe4d7d08 100644
--- a/Libraries/LibJS/Runtime/ObjectConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ObjectConstructor.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ObjectConstructor);
+GC_DEFINE_ALLOCATOR(ObjectConstructor);
 
 ObjectConstructor::ObjectConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Object.as_string(), realm.intrinsics().function_prototype())
@@ -67,7 +67,7 @@ ThrowCompletionOr<Value> ObjectConstructor::call()
 }
 
 // 20.1.1.1 Object ( [ value ] ), https://tc39.es/ecma262/#sec-object-value
-ThrowCompletionOr<NonnullGCPtr<Object>> ObjectConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ObjectConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
@@ -93,7 +93,7 @@ enum class GetOwnPropertyKeysType {
 };
 
 // 20.1.2.11.1 GetOwnPropertyKeys ( O, type ), https://tc39.es/ecma262/#sec-getownpropertykeys
-static ThrowCompletionOr<MarkedVector<Value>> get_own_property_keys(VM& vm, Value value, GetOwnPropertyKeysType type)
+static ThrowCompletionOr<GC::MarkedVector<Value>> get_own_property_keys(VM& vm, Value value, GetOwnPropertyKeysType type)
 {
     // 1. Let obj be ? ToObject(O).
     auto object = TRY(value.to_object(vm));
@@ -102,7 +102,7 @@ static ThrowCompletionOr<MarkedVector<Value>> get_own_property_keys(VM& vm, Valu
     auto keys = TRY(object->internal_own_property_keys());
 
     // 3. Let nameList be a new empty List.
-    auto name_list = MarkedVector<Value> { vm.heap() };
+    auto name_list = GC::MarkedVector<Value> { vm.heap() };
 
     // 4. For each element nextKey of keys, do
     for (auto& next_key : keys) {
@@ -382,7 +382,7 @@ JS_DEFINE_NATIVE_FUNCTION(ObjectConstructor::group_by)
     auto callback_function = vm.argument(1);
 
     // 1. Let groups be ? GroupBy(items, callbackfn, property).
-    auto groups = TRY((JS::group_by<OrderedHashMap<PropertyKey, MarkedVector<Value>>, PropertyKey>(vm, items, callback_function)));
+    auto groups = TRY((JS::group_by<OrderedHashMap<PropertyKey, GC::MarkedVector<Value>>, PropertyKey>(vm, items, callback_function)));
 
     // 2. Let obj be OrdinaryObjectCreate(null).
     auto object = Object::create(realm, nullptr);
diff --git a/Libraries/LibJS/Runtime/ObjectConstructor.h b/Libraries/LibJS/Runtime/ObjectConstructor.h
index 1aff80ae18e..6d2544f4874 100644
--- a/Libraries/LibJS/Runtime/ObjectConstructor.h
+++ b/Libraries/LibJS/Runtime/ObjectConstructor.h
@@ -13,14 +13,14 @@ namespace JS {
 
 class ObjectConstructor final : public NativeFunction {
     JS_OBJECT(ObjectConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ObjectConstructor);
+    GC_DECLARE_ALLOCATOR(ObjectConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ObjectConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ObjectConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/ObjectEnvironment.cpp b/Libraries/LibJS/Runtime/ObjectEnvironment.cpp
index 5999a391621..da5571ff22a 100644
--- a/Libraries/LibJS/Runtime/ObjectEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/ObjectEnvironment.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ObjectEnvironment);
+GC_DEFINE_ALLOCATOR(ObjectEnvironment);
 
 ObjectEnvironment::ObjectEnvironment(Object& binding_object, IsWithEnvironment is_with_environment, Environment* outer_environment)
     : Environment(outer_environment)
diff --git a/Libraries/LibJS/Runtime/ObjectEnvironment.h b/Libraries/LibJS/Runtime/ObjectEnvironment.h
index 93a20db3d75..b739f060d63 100644
--- a/Libraries/LibJS/Runtime/ObjectEnvironment.h
+++ b/Libraries/LibJS/Runtime/ObjectEnvironment.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class ObjectEnvironment final : public Environment {
     JS_ENVIRONMENT(ObjectEnvironment, Environment);
-    JS_DECLARE_ALLOCATOR(ObjectEnvironment);
+    GC_DECLARE_ALLOCATOR(ObjectEnvironment);
 
 public:
     enum class IsWithEnvironment {
@@ -47,7 +47,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<Object> m_binding_object;
+    GC::Ref<Object> m_binding_object;
     bool m_with_environment { false };
 };
 
diff --git a/Libraries/LibJS/Runtime/ObjectPrototype.cpp b/Libraries/LibJS/Runtime/ObjectPrototype.cpp
index 2c45d4cd579..5669a9bdd43 100644
--- a/Libraries/LibJS/Runtime/ObjectPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ObjectPrototype.cpp
@@ -21,7 +21,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ObjectPrototype);
+GC_DEFINE_ALLOCATOR(ObjectPrototype);
 
 ObjectPrototype::ObjectPrototype(Realm& realm)
     : Object(Object::ConstructWithoutPrototypeTag::Tag, realm)
@@ -300,7 +300,7 @@ JS_DEFINE_NATIVE_FUNCTION(ObjectPrototype::lookup_getter)
     auto property = vm.argument(0);
 
     // 1. Let O be ? ToObject(this value).
-    auto object = GCPtr { TRY(vm.this_value().to_object(vm)) };
+    auto object = GC::Ptr { TRY(vm.this_value().to_object(vm)) };
 
     // 2. Let key be ? ToPropertyKey(P).
     auto key = TRY(property.to_property_key(vm));
@@ -334,7 +334,7 @@ JS_DEFINE_NATIVE_FUNCTION(ObjectPrototype::lookup_setter)
     auto property = vm.argument(0);
 
     // 1. Let O be ? ToObject(this value).
-    auto object = GCPtr { TRY(vm.this_value().to_object(vm)) };
+    auto object = GC::Ptr { TRY(vm.this_value().to_object(vm)) };
 
     // 2. Let key be ? ToPropertyKey(P).
     auto key = TRY(property.to_property_key(vm));
diff --git a/Libraries/LibJS/Runtime/ObjectPrototype.h b/Libraries/LibJS/Runtime/ObjectPrototype.h
index d3ee1d5c82a..622b307b455 100644
--- a/Libraries/LibJS/Runtime/ObjectPrototype.h
+++ b/Libraries/LibJS/Runtime/ObjectPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class ObjectPrototype final : public Object {
     JS_OBJECT(ObjectPrototype, Object);
-    JS_DECLARE_ALLOCATOR(ObjectPrototype);
+    GC_DECLARE_ALLOCATOR(ObjectPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/PrimitiveString.cpp b/Libraries/LibJS/Runtime/PrimitiveString.cpp
index 558152cc08c..fd50a038f8f 100644
--- a/Libraries/LibJS/Runtime/PrimitiveString.cpp
+++ b/Libraries/LibJS/Runtime/PrimitiveString.cpp
@@ -19,7 +19,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PrimitiveString);
+GC_DEFINE_ALLOCATOR(PrimitiveString);
 
 PrimitiveString::PrimitiveString(PrimitiveString& lhs, PrimitiveString& rhs)
     : m_is_rope(true)
@@ -158,7 +158,7 @@ ThrowCompletionOr<Optional<Value>> PrimitiveString::get(VM& vm, PropertyKey cons
     return create(vm, Utf16String::create(str.substring_view(index.as_index(), 1)));
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, Utf16String string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, Utf16String string)
 {
     if (string.is_empty())
         return vm.empty_string();
@@ -178,7 +178,7 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, Utf16String string
     return *new_string;
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, String string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, String string)
 {
     if (string.is_empty())
         return vm.empty_string();
@@ -198,17 +198,17 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, String string)
     return *new_string;
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, FlyString const& string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, FlyString const& string)
 {
     return create(vm, string.to_string());
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, StringView string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, StringView string)
 {
     return create(vm, String::from_utf8(string).release_value());
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, ByteString string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, ByteString string)
 {
     if (string.is_empty())
         return vm.empty_string();
@@ -229,12 +229,12 @@ NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, ByteString string)
     return *it->value;
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, DeprecatedFlyString const& string)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, DeprecatedFlyString const& string)
 {
     return create(vm, ByteString { string });
 }
 
-NonnullGCPtr<PrimitiveString> PrimitiveString::create(VM& vm, PrimitiveString& lhs, PrimitiveString& rhs)
+GC::Ref<PrimitiveString> PrimitiveString::create(VM& vm, PrimitiveString& lhs, PrimitiveString& rhs)
 {
     // We're here to concatenate two strings into a new rope string.
     // However, if any of them are empty, no rope is required.
diff --git a/Libraries/LibJS/Runtime/PrimitiveString.h b/Libraries/LibJS/Runtime/PrimitiveString.h
index 678bfec7177..9781bf5e0c9 100644
--- a/Libraries/LibJS/Runtime/PrimitiveString.h
+++ b/Libraries/LibJS/Runtime/PrimitiveString.h
@@ -11,9 +11,9 @@
 #include <AK/Optional.h>
 #include <AK/String.h>
 #include <AK/StringView.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Utf16String.h>
 #include <LibJS/Runtime/Value.h>
@@ -21,17 +21,17 @@
 namespace JS {
 
 class PrimitiveString final : public Cell {
-    JS_CELL(PrimitiveString, Cell);
-    JS_DECLARE_ALLOCATOR(PrimitiveString);
+    GC_CELL(PrimitiveString, Cell);
+    GC_DECLARE_ALLOCATOR(PrimitiveString);
 
 public:
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, Utf16String);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, String);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, FlyString const&);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, ByteString);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, DeprecatedFlyString const&);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, PrimitiveString&, PrimitiveString&);
-    [[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, StringView);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, Utf16String);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, String);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, FlyString const&);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, ByteString);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, DeprecatedFlyString const&);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, PrimitiveString&, PrimitiveString&);
+    [[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, StringView);
 
     virtual ~PrimitiveString();
 
@@ -69,8 +69,8 @@ private:
 
     mutable bool m_is_rope { false };
 
-    mutable GCPtr<PrimitiveString> m_lhs;
-    mutable GCPtr<PrimitiveString> m_rhs;
+    mutable GC::Ptr<PrimitiveString> m_lhs;
+    mutable GC::Ptr<PrimitiveString> m_rhs;
 
     mutable Optional<String> m_utf8_string;
     mutable Optional<ByteString> m_byte_string;
diff --git a/Libraries/LibJS/Runtime/PrivateEnvironment.cpp b/Libraries/LibJS/Runtime/PrivateEnvironment.cpp
index e00a476719e..b0824720515 100644
--- a/Libraries/LibJS/Runtime/PrivateEnvironment.cpp
+++ b/Libraries/LibJS/Runtime/PrivateEnvironment.cpp
@@ -8,7 +8,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PrivateEnvironment);
+GC_DEFINE_ALLOCATOR(PrivateEnvironment);
 
 PrivateEnvironment::PrivateEnvironment(PrivateEnvironment* parent)
     : m_outer_environment(parent)
diff --git a/Libraries/LibJS/Runtime/PrivateEnvironment.h b/Libraries/LibJS/Runtime/PrivateEnvironment.h
index 17c93c35a27..4bc3a7dd616 100644
--- a/Libraries/LibJS/Runtime/PrivateEnvironment.h
+++ b/Libraries/LibJS/Runtime/PrivateEnvironment.h
@@ -9,8 +9,8 @@
 #include <AK/DeprecatedFlyString.h>
 #include <AK/StringView.h>
 #include <AK/Vector.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 
 namespace JS {
 
@@ -29,8 +29,8 @@ struct PrivateName {
 };
 
 class PrivateEnvironment : public Cell {
-    JS_CELL(PrivateEnvironment, Cell);
-    JS_DECLARE_ALLOCATOR(PrivateEnvironment);
+    GC_CELL(PrivateEnvironment, Cell);
+    GC_DECLARE_ALLOCATOR(PrivateEnvironment);
 
 public:
     PrivateName resolve_private_identifier(DeprecatedFlyString const& identifier) const;
@@ -54,8 +54,8 @@ private:
 
     static u64 s_next_id;
 
-    GCPtr<PrivateEnvironment> m_outer_environment; // [[OuterEnv]]
-    Vector<PrivateName> m_private_names;           // [[Names]]
+    GC::Ptr<PrivateEnvironment> m_outer_environment; // [[OuterEnv]]
+    Vector<PrivateName> m_private_names;             // [[Names]]
     u64 m_unique_id;
 };
 
diff --git a/Libraries/LibJS/Runtime/Promise.cpp b/Libraries/LibJS/Runtime/Promise.cpp
index 0d5a860b8d1..1a1fc08836b 100644
--- a/Libraries/LibJS/Runtime/Promise.cpp
+++ b/Libraries/LibJS/Runtime/Promise.cpp
@@ -19,7 +19,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Promise);
+GC_DEFINE_ALLOCATOR(Promise);
 
 // 27.2.4.7.1 PromiseResolve ( C, x ), https://tc39.es/ecma262/#sec-promise-resolve
 ThrowCompletionOr<Object*> promise_resolve(VM& vm, Object& constructor, Value value)
@@ -44,7 +44,7 @@ ThrowCompletionOr<Object*> promise_resolve(VM& vm, Object& constructor, Value va
     return promise_capability->promise().ptr();
 }
 
-NonnullGCPtr<Promise> Promise::create(Realm& realm)
+GC::Ref<Promise> Promise::create(Realm& realm)
 {
     return realm.create<Promise>(realm.intrinsics().promise_prototype());
 }
@@ -290,7 +290,7 @@ void Promise::trigger_reactions() const
 }
 
 // 27.2.5.4.1 PerformPromiseThen ( promise, onFulfilled, onRejected [ , resultCapability ] ), https://tc39.es/ecma262/#sec-performpromisethen
-Value Promise::perform_then(Value on_fulfilled, Value on_rejected, GCPtr<PromiseCapability> result_capability)
+Value Promise::perform_then(Value on_fulfilled, Value on_rejected, GC::Ptr<PromiseCapability> result_capability)
 {
     auto& vm = this->vm();
 
@@ -300,7 +300,7 @@ Value Promise::perform_then(Value on_fulfilled, Value on_rejected, GCPtr<Promise
 
     // 3. If IsCallable(onFulfilled) is false, then
     //     a. Let onFulfilledJobCallback be empty.
-    GCPtr<JobCallback> on_fulfilled_job_callback;
+    GC::Ptr<JobCallback> on_fulfilled_job_callback;
 
     // 4. Else,
     if (on_fulfilled.is_function()) {
@@ -311,7 +311,7 @@ Value Promise::perform_then(Value on_fulfilled, Value on_rejected, GCPtr<Promise
 
     // 5. If IsCallable(onRejected) is false, then
     //     a. Let onRejectedJobCallback be empty.
-    GCPtr<JobCallback> on_rejected_job_callback;
+    GC::Ptr<JobCallback> on_rejected_job_callback;
 
     // 6. Else,
     if (on_rejected.is_function()) {
diff --git a/Libraries/LibJS/Runtime/Promise.h b/Libraries/LibJS/Runtime/Promise.h
index e97d9daaec7..e956c45ed15 100644
--- a/Libraries/LibJS/Runtime/Promise.h
+++ b/Libraries/LibJS/Runtime/Promise.h
@@ -15,7 +15,7 @@ ThrowCompletionOr<Object*> promise_resolve(VM&, Object& constructor, Value);
 
 class Promise : public Object {
     JS_OBJECT(Promise, Object);
-    JS_DECLARE_ALLOCATOR(Promise);
+    GC_DECLARE_ALLOCATOR(Promise);
 
 public:
     enum class State {
@@ -28,7 +28,7 @@ public:
         Handle,
     };
 
-    static NonnullGCPtr<Promise> create(Realm&);
+    static GC::Ref<Promise> create(Realm&);
 
     virtual ~Promise() = default;
 
@@ -36,14 +36,14 @@ public:
     Value result() const { return m_result; }
 
     struct ResolvingFunctions {
-        NonnullGCPtr<FunctionObject> resolve;
-        NonnullGCPtr<FunctionObject> reject;
+        GC::Ref<FunctionObject> resolve;
+        GC::Ref<FunctionObject> reject;
     };
     ResolvingFunctions create_resolving_functions();
 
     void fulfill(Value value);
     void reject(Value reason);
-    Value perform_then(Value on_fulfilled, Value on_rejected, GCPtr<PromiseCapability> result_capability);
+    Value perform_then(Value on_fulfilled, Value on_rejected, GC::Ptr<PromiseCapability> result_capability);
 
     bool is_handled() const { return m_is_handled; }
     void set_is_handled() { m_is_handled = true; }
@@ -59,11 +59,11 @@ private:
     void trigger_reactions() const;
 
     // 27.2.6 Properties of Promise Instances, https://tc39.es/ecma262/#sec-properties-of-promise-instances
-    State m_state { State::Pending };                   // [[PromiseState]]
-    Value m_result;                                     // [[PromiseResult]]
-    Vector<GCPtr<PromiseReaction>> m_fulfill_reactions; // [[PromiseFulfillReactions]]
-    Vector<GCPtr<PromiseReaction>> m_reject_reactions;  // [[PromiseRejectReactions]]
-    bool m_is_handled { false };                        // [[PromiseIsHandled]]
+    State m_state { State::Pending };                     // [[PromiseState]]
+    Value m_result;                                       // [[PromiseResult]]
+    Vector<GC::Ptr<PromiseReaction>> m_fulfill_reactions; // [[PromiseFulfillReactions]]
+    Vector<GC::Ptr<PromiseReaction>> m_reject_reactions;  // [[PromiseRejectReactions]]
+    bool m_is_handled { false };                          // [[PromiseIsHandled]]
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/PromiseCapability.cpp b/Libraries/LibJS/Runtime/PromiseCapability.cpp
index a374ab2705d..e7de078bfde 100644
--- a/Libraries/LibJS/Runtime/PromiseCapability.cpp
+++ b/Libraries/LibJS/Runtime/PromiseCapability.cpp
@@ -11,14 +11,14 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PromiseCapability);
+GC_DEFINE_ALLOCATOR(PromiseCapability);
 
-NonnullGCPtr<PromiseCapability> PromiseCapability::create(VM& vm, NonnullGCPtr<Object> promise, NonnullGCPtr<FunctionObject> resolve, NonnullGCPtr<FunctionObject> reject)
+GC::Ref<PromiseCapability> PromiseCapability::create(VM& vm, GC::Ref<Object> promise, GC::Ref<FunctionObject> resolve, GC::Ref<FunctionObject> reject)
 {
     return vm.heap().allocate<PromiseCapability>(promise, resolve, reject);
 }
 
-PromiseCapability::PromiseCapability(NonnullGCPtr<Object> promise, NonnullGCPtr<FunctionObject> resolve, NonnullGCPtr<FunctionObject> reject)
+PromiseCapability::PromiseCapability(GC::Ref<Object> promise, GC::Ref<FunctionObject> resolve, GC::Ref<FunctionObject> reject)
     : m_promise(promise)
     , m_resolve(resolve)
     , m_reject(reject)
@@ -35,8 +35,8 @@ void PromiseCapability::visit_edges(Cell::Visitor& visitor)
 
 namespace {
 struct ResolvingFunctions final : public Cell {
-    JS_CELL(ResolvingFunctions, Cell);
-    JS_DECLARE_ALLOCATOR(ResolvingFunctions);
+    GC_CELL(ResolvingFunctions, Cell);
+    GC_DECLARE_ALLOCATOR(ResolvingFunctions);
 
     Value resolve { js_undefined() };
     Value reject { js_undefined() };
@@ -48,11 +48,11 @@ struct ResolvingFunctions final : public Cell {
         visitor.visit(reject);
     }
 };
-JS_DEFINE_ALLOCATOR(ResolvingFunctions);
+GC_DEFINE_ALLOCATOR(ResolvingFunctions);
 }
 
 // 27.2.1.5 NewPromiseCapability ( C ), https://tc39.es/ecma262/#sec-newpromisecapability
-ThrowCompletionOr<NonnullGCPtr<PromiseCapability>> new_promise_capability(VM& vm, Value constructor)
+ThrowCompletionOr<GC::Ref<PromiseCapability>> new_promise_capability(VM& vm, Value constructor)
 {
     auto& realm = *vm.current_realm();
 
diff --git a/Libraries/LibJS/Runtime/PromiseCapability.h b/Libraries/LibJS/Runtime/PromiseCapability.h
index 4280b0d0902..8eb5d3cc959 100644
--- a/Libraries/LibJS/Runtime/PromiseCapability.h
+++ b/Libraries/LibJS/Runtime/PromiseCapability.h
@@ -14,28 +14,28 @@ namespace JS {
 
 // 27.2.1.1 PromiseCapability Records, https://tc39.es/ecma262/#sec-promisecapability-records
 class PromiseCapability final : public Cell {
-    JS_CELL(PromiseCapability, Cell);
-    JS_DECLARE_ALLOCATOR(PromiseCapability);
+    GC_CELL(PromiseCapability, Cell);
+    GC_DECLARE_ALLOCATOR(PromiseCapability);
 
 public:
-    static NonnullGCPtr<PromiseCapability> create(VM& vm, NonnullGCPtr<Object> promise, NonnullGCPtr<FunctionObject> resolve, NonnullGCPtr<FunctionObject> reject);
+    static GC::Ref<PromiseCapability> create(VM& vm, GC::Ref<Object> promise, GC::Ref<FunctionObject> resolve, GC::Ref<FunctionObject> reject);
 
     virtual ~PromiseCapability() = default;
 
-    [[nodiscard]] NonnullGCPtr<Object> promise() const { return m_promise; }
+    [[nodiscard]] GC::Ref<Object> promise() const { return m_promise; }
 
-    [[nodiscard]] NonnullGCPtr<FunctionObject> resolve() const { return m_resolve; }
+    [[nodiscard]] GC::Ref<FunctionObject> resolve() const { return m_resolve; }
 
-    [[nodiscard]] NonnullGCPtr<FunctionObject> reject() const { return m_reject; }
+    [[nodiscard]] GC::Ref<FunctionObject> reject() const { return m_reject; }
 
 private:
-    PromiseCapability(NonnullGCPtr<Object>, NonnullGCPtr<FunctionObject>, NonnullGCPtr<FunctionObject>);
+    PromiseCapability(GC::Ref<Object>, GC::Ref<FunctionObject>, GC::Ref<FunctionObject>);
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<Object> m_promise;
-    NonnullGCPtr<FunctionObject> m_resolve;
-    NonnullGCPtr<FunctionObject> m_reject;
+    GC::Ref<Object> m_promise;
+    GC::Ref<FunctionObject> m_resolve;
+    GC::Ref<FunctionObject> m_reject;
 };
 
 // 27.2.1.1.1 IfAbruptRejectPromise ( value, capability ), https://tc39.es/ecma262/#sec-ifabruptrejectpromise
@@ -85,6 +85,6 @@ private:
     })
 
 // 27.2.1.5 NewPromiseCapability ( C ), https://tc39.es/ecma262/#sec-newpromisecapability
-ThrowCompletionOr<NonnullGCPtr<PromiseCapability>> new_promise_capability(VM& vm, Value constructor);
+ThrowCompletionOr<GC::Ref<PromiseCapability>> new_promise_capability(VM& vm, Value constructor);
 
 }
diff --git a/Libraries/LibJS/Runtime/PromiseConstructor.cpp b/Libraries/LibJS/Runtime/PromiseConstructor.cpp
index 996ad495750..f537a938121 100644
--- a/Libraries/LibJS/Runtime/PromiseConstructor.cpp
+++ b/Libraries/LibJS/Runtime/PromiseConstructor.cpp
@@ -19,7 +19,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PromiseConstructor);
+GC_DEFINE_ALLOCATOR(PromiseConstructor);
 
 // 27.2.4.1.1 GetPromiseResolve ( promiseConstructor ), https://tc39.es/ecma262/#sec-getpromiseresolve
 static ThrowCompletionOr<Value> get_promise_resolve(VM& vm, Value constructor)
@@ -256,7 +256,7 @@ ThrowCompletionOr<Value> PromiseConstructor::call()
 }
 
 // 27.2.3.1 Promise ( executor ), https://tc39.es/ecma262/#sec-promise-executor
-ThrowCompletionOr<NonnullGCPtr<Object>> PromiseConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PromiseConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/PromiseConstructor.h b/Libraries/LibJS/Runtime/PromiseConstructor.h
index 8a3142a244f..0bee0122442 100644
--- a/Libraries/LibJS/Runtime/PromiseConstructor.h
+++ b/Libraries/LibJS/Runtime/PromiseConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class PromiseConstructor final : public NativeFunction {
     JS_OBJECT(PromiseConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PromiseConstructor);
+    GC_DECLARE_ALLOCATOR(PromiseConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PromiseConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PromiseConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/PromiseJobs.cpp b/Libraries/LibJS/Runtime/PromiseJobs.cpp
index 72fe7af7ba9..d3c418a8c43 100644
--- a/Libraries/LibJS/Runtime/PromiseJobs.cpp
+++ b/Libraries/LibJS/Runtime/PromiseJobs.cpp
@@ -90,7 +90,7 @@ PromiseJob create_promise_reaction_job(VM& vm, PromiseReaction& reaction, Value
 {
     // 1. Let job be a new Job Abstract Closure with no parameters that captures reaction and argument and performs the following steps when called:
     //    See run_reaction_job for "the following steps".
-    auto job = create_heap_function(vm.heap(), [&vm, &reaction, argument] {
+    auto job = GC::create_function(vm.heap(), [&vm, &reaction, argument] {
         return run_reaction_job(vm, reaction, argument);
     });
 
@@ -144,7 +144,7 @@ static ThrowCompletionOr<Value> run_resolve_thenable_job(VM& vm, Promise& promis
 }
 
 // 27.2.2.2 NewPromiseResolveThenableJob ( promiseToResolve, thenable, then ), https://tc39.es/ecma262/#sec-newpromiseresolvethenablejob
-PromiseJob create_promise_resolve_thenable_job(VM& vm, Promise& promise_to_resolve, Value thenable, JS::NonnullGCPtr<JobCallback> then)
+PromiseJob create_promise_resolve_thenable_job(VM& vm, Promise& promise_to_resolve, Value thenable, GC::Ref<JobCallback> then)
 {
     // 2. Let getThenRealmResult be Completion(GetFunctionRealm(then.[[Callback]])).
     auto get_then_realm_result = get_function_realm(vm, then->callback());
@@ -164,7 +164,7 @@ PromiseJob create_promise_resolve_thenable_job(VM& vm, Promise& promise_to_resol
 
     // 1. Let job be a new Job Abstract Closure with no parameters that captures promiseToResolve, thenable, and then and performs the following steps when called:
     //    See run_resolve_thenable_job() for "the following steps".
-    auto job = create_heap_function(vm.heap(), [&vm, &promise_to_resolve, thenable, then]() mutable {
+    auto job = GC::create_function(vm.heap(), [&vm, &promise_to_resolve, thenable, then]() mutable {
         return run_resolve_thenable_job(vm, promise_to_resolve, thenable, then);
     });
 
diff --git a/Libraries/LibJS/Runtime/PromiseJobs.h b/Libraries/LibJS/Runtime/PromiseJobs.h
index 95689d7a0cc..b44982d852c 100644
--- a/Libraries/LibJS/Runtime/PromiseJobs.h
+++ b/Libraries/LibJS/Runtime/PromiseJobs.h
@@ -15,12 +15,12 @@
 namespace JS {
 
 struct PromiseJob {
-    NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>> job;
-    GCPtr<Realm> realm;
+    GC::Ref<GC::Function<ThrowCompletionOr<Value>()>> job;
+    GC::Ptr<Realm> realm;
 };
 
 // NOTE: These return a PromiseJob to prevent awkward casting at call sites.
 PromiseJob create_promise_reaction_job(VM&, PromiseReaction&, Value argument);
-PromiseJob create_promise_resolve_thenable_job(VM&, Promise&, Value thenable, JS::NonnullGCPtr<JobCallback> then);
+PromiseJob create_promise_resolve_thenable_job(VM&, Promise&, Value thenable, GC::Ref<JobCallback> then);
 
 }
diff --git a/Libraries/LibJS/Runtime/PromisePrototype.cpp b/Libraries/LibJS/Runtime/PromisePrototype.cpp
index 1238f42a2d5..5fc19905bb7 100644
--- a/Libraries/LibJS/Runtime/PromisePrototype.cpp
+++ b/Libraries/LibJS/Runtime/PromisePrototype.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PromisePrototype);
+GC_DEFINE_ALLOCATOR(PromisePrototype);
 
 PromisePrototype::PromisePrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/PromisePrototype.h b/Libraries/LibJS/Runtime/PromisePrototype.h
index 2edef6e2628..e547867524e 100644
--- a/Libraries/LibJS/Runtime/PromisePrototype.h
+++ b/Libraries/LibJS/Runtime/PromisePrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class PromisePrototype final : public PrototypeObject<PromisePrototype, Promise> {
     JS_PROTOTYPE_OBJECT(PromisePrototype, Promise, Promise);
-    JS_DECLARE_ALLOCATOR(PromisePrototype);
+    GC_DECLARE_ALLOCATOR(PromisePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/PromiseReaction.cpp b/Libraries/LibJS/Runtime/PromiseReaction.cpp
index a861db78d1c..d94e2668f8d 100644
--- a/Libraries/LibJS/Runtime/PromiseReaction.cpp
+++ b/Libraries/LibJS/Runtime/PromiseReaction.cpp
@@ -10,14 +10,14 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(PromiseReaction);
+GC_DEFINE_ALLOCATOR(PromiseReaction);
 
-NonnullGCPtr<PromiseReaction> PromiseReaction::create(VM& vm, Type type, GCPtr<PromiseCapability> capability, GCPtr<JobCallback> handler)
+GC::Ref<PromiseReaction> PromiseReaction::create(VM& vm, Type type, GC::Ptr<PromiseCapability> capability, GC::Ptr<JobCallback> handler)
 {
     return vm.heap().allocate<PromiseReaction>(type, capability, move(handler));
 }
 
-PromiseReaction::PromiseReaction(Type type, GCPtr<PromiseCapability> capability, GCPtr<JobCallback> handler)
+PromiseReaction::PromiseReaction(Type type, GC::Ptr<PromiseCapability> capability, GC::Ptr<JobCallback> handler)
     : m_type(type)
     , m_capability(capability)
     , m_handler(move(handler))
diff --git a/Libraries/LibJS/Runtime/PromiseReaction.h b/Libraries/LibJS/Runtime/PromiseReaction.h
index 4398f4a115b..6f51990244a 100644
--- a/Libraries/LibJS/Runtime/PromiseReaction.h
+++ b/Libraries/LibJS/Runtime/PromiseReaction.h
@@ -15,8 +15,8 @@ namespace JS {
 
 // 27.2.1.2 PromiseReaction Records, https://tc39.es/ecma262/#sec-promisereaction-records
 class PromiseReaction final : public Cell {
-    JS_CELL(PromiseReaction, Cell);
-    JS_DECLARE_ALLOCATOR(PromiseReaction);
+    GC_CELL(PromiseReaction, Cell);
+    GC_DECLARE_ALLOCATOR(PromiseReaction);
 
 public:
     enum class Type {
@@ -24,24 +24,24 @@ public:
         Reject,
     };
 
-    static NonnullGCPtr<PromiseReaction> create(VM& vm, Type type, GCPtr<PromiseCapability> capability, JS::GCPtr<JobCallback> handler);
+    static GC::Ref<PromiseReaction> create(VM& vm, Type type, GC::Ptr<PromiseCapability> capability, GC::Ptr<JobCallback> handler);
 
     virtual ~PromiseReaction() = default;
 
     Type type() const { return m_type; }
-    GCPtr<PromiseCapability> capability() const { return m_capability; }
+    GC::Ptr<PromiseCapability> capability() const { return m_capability; }
 
-    JS::GCPtr<JobCallback> handler() { return m_handler; }
-    JS::GCPtr<JobCallback const> handler() const { return m_handler; }
+    GC::Ptr<JobCallback> handler() { return m_handler; }
+    GC::Ptr<JobCallback const> handler() const { return m_handler; }
 
 private:
-    PromiseReaction(Type type, GCPtr<PromiseCapability> capability, JS::GCPtr<JobCallback> handler);
+    PromiseReaction(Type type, GC::Ptr<PromiseCapability> capability, GC::Ptr<JobCallback> handler);
 
     virtual void visit_edges(Visitor&) override;
 
     Type m_type;
-    GCPtr<PromiseCapability> m_capability;
-    JS::GCPtr<JobCallback> m_handler;
+    GC::Ptr<PromiseCapability> m_capability;
+    GC::Ptr<JobCallback> m_handler;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp b/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp
index 02b76fae4e3..8f493af5e56 100644
--- a/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp
+++ b/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.cpp
@@ -13,13 +13,13 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RemainingElements);
-JS_DEFINE_ALLOCATOR(PromiseValueList);
-JS_DEFINE_ALLOCATOR(PromiseResolvingElementFunction);
-JS_DEFINE_ALLOCATOR(PromiseAllResolveElementFunction);
-JS_DEFINE_ALLOCATOR(PromiseAllSettledResolveElementFunction);
-JS_DEFINE_ALLOCATOR(PromiseAllSettledRejectElementFunction);
-JS_DEFINE_ALLOCATOR(PromiseAnyRejectElementFunction);
+GC_DEFINE_ALLOCATOR(RemainingElements);
+GC_DEFINE_ALLOCATOR(PromiseValueList);
+GC_DEFINE_ALLOCATOR(PromiseResolvingElementFunction);
+GC_DEFINE_ALLOCATOR(PromiseAllResolveElementFunction);
+GC_DEFINE_ALLOCATOR(PromiseAllSettledResolveElementFunction);
+GC_DEFINE_ALLOCATOR(PromiseAllSettledRejectElementFunction);
+GC_DEFINE_ALLOCATOR(PromiseAnyRejectElementFunction);
 
 void PromiseValueList::visit_edges(Visitor& visitor)
 {
@@ -27,7 +27,7 @@ void PromiseValueList::visit_edges(Visitor& visitor)
     visitor.visit(m_values);
 }
 
-PromiseResolvingElementFunction::PromiseResolvingElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
+PromiseResolvingElementFunction::PromiseResolvingElementFunction(size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
     : NativeFunction(prototype)
     , m_index(index)
     , m_values(values)
@@ -60,12 +60,12 @@ void PromiseResolvingElementFunction::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_remaining_elements);
 }
 
-NonnullGCPtr<PromiseAllResolveElementFunction> PromiseAllResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements)
+GC::Ref<PromiseAllResolveElementFunction> PromiseAllResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements)
 {
     return realm.create<PromiseAllResolveElementFunction>(index, values, capability, remaining_elements, realm.intrinsics().function_prototype());
 }
 
-PromiseAllResolveElementFunction::PromiseAllResolveElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
+PromiseAllResolveElementFunction::PromiseAllResolveElementFunction(size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
     : PromiseResolvingElementFunction(index, values, capability, remaining_elements, prototype)
 {
 }
@@ -92,12 +92,12 @@ ThrowCompletionOr<Value> PromiseAllResolveElementFunction::resolve_element()
     return js_undefined();
 }
 
-NonnullGCPtr<PromiseAllSettledResolveElementFunction> PromiseAllSettledResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements)
+GC::Ref<PromiseAllSettledResolveElementFunction> PromiseAllSettledResolveElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements)
 {
     return realm.create<PromiseAllSettledResolveElementFunction>(index, values, capability, remaining_elements, realm.intrinsics().function_prototype());
 }
 
-PromiseAllSettledResolveElementFunction::PromiseAllSettledResolveElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
+PromiseAllSettledResolveElementFunction::PromiseAllSettledResolveElementFunction(size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
     : PromiseResolvingElementFunction(index, values, capability, remaining_elements, prototype)
 {
 }
@@ -133,12 +133,12 @@ ThrowCompletionOr<Value> PromiseAllSettledResolveElementFunction::resolve_elemen
     return js_undefined();
 }
 
-NonnullGCPtr<PromiseAllSettledRejectElementFunction> PromiseAllSettledRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements)
+GC::Ref<PromiseAllSettledRejectElementFunction> PromiseAllSettledRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements)
 {
     return realm.create<PromiseAllSettledRejectElementFunction>(index, values, capability, remaining_elements, realm.intrinsics().function_prototype());
 }
 
-PromiseAllSettledRejectElementFunction::PromiseAllSettledRejectElementFunction(size_t index, PromiseValueList& values, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
+PromiseAllSettledRejectElementFunction::PromiseAllSettledRejectElementFunction(size_t index, PromiseValueList& values, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
     : PromiseResolvingElementFunction(index, values, capability, remaining_elements, prototype)
 {
 }
@@ -174,12 +174,12 @@ ThrowCompletionOr<Value> PromiseAllSettledRejectElementFunction::resolve_element
     return js_undefined();
 }
 
-NonnullGCPtr<PromiseAnyRejectElementFunction> PromiseAnyRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& errors, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements)
+GC::Ref<PromiseAnyRejectElementFunction> PromiseAnyRejectElementFunction::create(Realm& realm, size_t index, PromiseValueList& errors, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements)
 {
     return realm.create<PromiseAnyRejectElementFunction>(index, errors, capability, remaining_elements, realm.intrinsics().function_prototype());
 }
 
-PromiseAnyRejectElementFunction::PromiseAnyRejectElementFunction(size_t index, PromiseValueList& errors, NonnullGCPtr<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
+PromiseAnyRejectElementFunction::PromiseAnyRejectElementFunction(size_t index, PromiseValueList& errors, GC::Ref<PromiseCapability const> capability, RemainingElements& remaining_elements, Object& prototype)
     : PromiseResolvingElementFunction(index, errors, capability, remaining_elements, prototype)
 {
 }
diff --git a/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.h b/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.h
index 3b8d4d6f785..a42e1f83ba7 100644
--- a/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.h
+++ b/Libraries/LibJS/Runtime/PromiseResolvingElementFunctions.h
@@ -13,8 +13,8 @@
 namespace JS {
 
 struct RemainingElements final : public Cell {
-    JS_CELL(RemainingElements, Cell);
-    JS_DECLARE_ALLOCATOR(RemainingElements);
+    GC_CELL(RemainingElements, Cell);
+    GC_DECLARE_ALLOCATOR(RemainingElements);
 
     u64 value { 0 };
 
@@ -28,8 +28,8 @@ private:
 };
 
 class PromiseValueList final : public Cell {
-    JS_CELL(PromiseValueList, Cell);
-    JS_DECLARE_ALLOCATOR(PromiseValueList);
+    GC_CELL(PromiseValueList, Cell);
+    GC_DECLARE_ALLOCATOR(PromiseValueList);
 
 public:
     Vector<Value>& values() { return m_values; }
@@ -45,7 +45,7 @@ private:
 
 class PromiseResolvingElementFunction : public NativeFunction {
     JS_OBJECT(PromiseResolvingElementFunction, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PromiseResolvingElementFunction);
+    GC_DECLARE_ALLOCATOR(PromiseResolvingElementFunction);
 
 public:
     virtual void initialize(Realm&) override;
@@ -54,14 +54,14 @@ public:
     virtual ThrowCompletionOr<Value> call() override;
 
 protected:
-    explicit PromiseResolvingElementFunction(size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&, Object& prototype);
+    explicit PromiseResolvingElementFunction(size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&, Object& prototype);
 
     virtual ThrowCompletionOr<Value> resolve_element() = 0;
 
     size_t m_index { 0 };
-    NonnullGCPtr<PromiseValueList> m_values;
-    NonnullGCPtr<PromiseCapability const> m_capability;
-    NonnullGCPtr<RemainingElements> m_remaining_elements;
+    GC::Ref<PromiseValueList> m_values;
+    GC::Ref<PromiseCapability const> m_capability;
+    GC::Ref<RemainingElements> m_remaining_elements;
 
 private:
     virtual void visit_edges(Visitor&) override;
@@ -72,15 +72,15 @@ private:
 // 27.2.4.1.3 Promise.all Resolve Element Functions, https://tc39.es/ecma262/#sec-promise.all-resolve-element-functions
 class PromiseAllResolveElementFunction final : public PromiseResolvingElementFunction {
     JS_OBJECT(PromiseAllResolveElementFunction, PromiseResolvingElementFunction);
-    JS_DECLARE_ALLOCATOR(PromiseAllResolveElementFunction);
+    GC_DECLARE_ALLOCATOR(PromiseAllResolveElementFunction);
 
 public:
-    static NonnullGCPtr<PromiseAllResolveElementFunction> create(Realm&, size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&);
+    static GC::Ref<PromiseAllResolveElementFunction> create(Realm&, size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&);
 
     virtual ~PromiseAllResolveElementFunction() override = default;
 
 private:
-    explicit PromiseAllResolveElementFunction(size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&, Object& prototype);
+    explicit PromiseAllResolveElementFunction(size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&, Object& prototype);
 
     virtual ThrowCompletionOr<Value> resolve_element() override;
 };
@@ -88,15 +88,15 @@ private:
 // 27.2.4.2.2 Promise.allSettled Resolve Element Functions, https://tc39.es/ecma262/#sec-promise.allsettled-resolve-element-functions
 class PromiseAllSettledResolveElementFunction final : public PromiseResolvingElementFunction {
     JS_OBJECT(PromiseAllSettledResolveElementFunction, PromiseResolvingElementFunction);
-    JS_DECLARE_ALLOCATOR(PromiseAllSettledResolveElementFunction);
+    GC_DECLARE_ALLOCATOR(PromiseAllSettledResolveElementFunction);
 
 public:
-    static NonnullGCPtr<PromiseAllSettledResolveElementFunction> create(Realm&, size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&);
+    static GC::Ref<PromiseAllSettledResolveElementFunction> create(Realm&, size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&);
 
     virtual ~PromiseAllSettledResolveElementFunction() override = default;
 
 private:
-    explicit PromiseAllSettledResolveElementFunction(size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&, Object& prototype);
+    explicit PromiseAllSettledResolveElementFunction(size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&, Object& prototype);
 
     virtual ThrowCompletionOr<Value> resolve_element() override;
 };
@@ -104,15 +104,15 @@ private:
 // 27.2.4.2.3 Promise.allSettled Reject Element Functions, https://tc39.es/ecma262/#sec-promise.allsettled-reject-element-functions
 class PromiseAllSettledRejectElementFunction final : public PromiseResolvingElementFunction {
     JS_OBJECT(PromiseAllSettledRejectElementFunction, PromiseResolvingElementFunction);
-    JS_DECLARE_ALLOCATOR(PromiseAllSettledRejectElementFunction);
+    GC_DECLARE_ALLOCATOR(PromiseAllSettledRejectElementFunction);
 
 public:
-    static NonnullGCPtr<PromiseAllSettledRejectElementFunction> create(Realm&, size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&);
+    static GC::Ref<PromiseAllSettledRejectElementFunction> create(Realm&, size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&);
 
     virtual ~PromiseAllSettledRejectElementFunction() override = default;
 
 private:
-    explicit PromiseAllSettledRejectElementFunction(size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&, Object& prototype);
+    explicit PromiseAllSettledRejectElementFunction(size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&, Object& prototype);
 
     virtual ThrowCompletionOr<Value> resolve_element() override;
 };
@@ -120,15 +120,15 @@ private:
 // 27.2.4.3.2 Promise.any Reject Element Functions, https://tc39.es/ecma262/#sec-promise.any-reject-element-functions
 class PromiseAnyRejectElementFunction final : public PromiseResolvingElementFunction {
     JS_OBJECT(PromiseAnyRejectElementFunction, PromiseResolvingElementFunction);
-    JS_DECLARE_ALLOCATOR(PromiseAnyRejectElementFunction);
+    GC_DECLARE_ALLOCATOR(PromiseAnyRejectElementFunction);
 
 public:
-    static NonnullGCPtr<PromiseAnyRejectElementFunction> create(Realm&, size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&);
+    static GC::Ref<PromiseAnyRejectElementFunction> create(Realm&, size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&);
 
     virtual ~PromiseAnyRejectElementFunction() override = default;
 
 private:
-    explicit PromiseAnyRejectElementFunction(size_t, PromiseValueList&, NonnullGCPtr<PromiseCapability const>, RemainingElements&, Object& prototype);
+    explicit PromiseAnyRejectElementFunction(size_t, PromiseValueList&, GC::Ref<PromiseCapability const>, RemainingElements&, Object& prototype);
 
     virtual ThrowCompletionOr<Value> resolve_element() override;
 };
diff --git a/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp b/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp
index af716c176b8..4276ba2b7d2 100644
--- a/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp
+++ b/Libraries/LibJS/Runtime/PromiseResolvingFunction.cpp
@@ -11,10 +11,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(AlreadyResolved);
-JS_DEFINE_ALLOCATOR(PromiseResolvingFunction);
+GC_DEFINE_ALLOCATOR(AlreadyResolved);
+GC_DEFINE_ALLOCATOR(PromiseResolvingFunction);
 
-NonnullGCPtr<PromiseResolvingFunction> PromiseResolvingFunction::create(Realm& realm, Promise& promise, AlreadyResolved& already_resolved, FunctionType function)
+GC::Ref<PromiseResolvingFunction> PromiseResolvingFunction::create(Realm& realm, Promise& promise, AlreadyResolved& already_resolved, FunctionType function)
 {
     return realm.create<PromiseResolvingFunction>(promise, already_resolved, move(function), realm.intrinsics().function_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/PromiseResolvingFunction.h b/Libraries/LibJS/Runtime/PromiseResolvingFunction.h
index 951d18ab8be..e73bf211465 100644
--- a/Libraries/LibJS/Runtime/PromiseResolvingFunction.h
+++ b/Libraries/LibJS/Runtime/PromiseResolvingFunction.h
@@ -12,8 +12,8 @@
 namespace JS {
 
 struct AlreadyResolved final : public Cell {
-    JS_CELL(AlreadyResolved, Cell);
-    JS_DECLARE_ALLOCATOR(AlreadyResolved);
+    GC_CELL(AlreadyResolved, Cell);
+    GC_DECLARE_ALLOCATOR(AlreadyResolved);
 
     bool value { false };
 
@@ -25,12 +25,12 @@ protected:
 
 class PromiseResolvingFunction final : public NativeFunction {
     JS_OBJECT(PromiseResolvingFunction, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PromiseResolvingFunction);
+    GC_DECLARE_ALLOCATOR(PromiseResolvingFunction);
 
 public:
     using FunctionType = Function<Value(VM&, Promise&, AlreadyResolved&)>;
 
-    static NonnullGCPtr<PromiseResolvingFunction> create(Realm&, Promise&, AlreadyResolved&, FunctionType);
+    static GC::Ref<PromiseResolvingFunction> create(Realm&, Promise&, AlreadyResolved&, FunctionType);
 
     virtual void initialize(Realm&) override;
     virtual ~PromiseResolvingFunction() override = default;
@@ -42,8 +42,8 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<Promise> m_promise;
-    NonnullGCPtr<AlreadyResolved> m_already_resolved;
+    GC::Ref<Promise> m_promise;
+    GC::Ref<AlreadyResolved> m_already_resolved;
     FunctionType m_native_function;
 };
 
diff --git a/Libraries/LibJS/Runtime/PropertyDescriptor.h b/Libraries/LibJS/Runtime/PropertyDescriptor.h
index 9eea4de3154..700f8d5218e 100644
--- a/Libraries/LibJS/Runtime/PropertyDescriptor.h
+++ b/Libraries/LibJS/Runtime/PropertyDescriptor.h
@@ -35,8 +35,8 @@ public:
     }
 
     Optional<Value> value {};
-    Optional<GCPtr<FunctionObject>> get {};
-    Optional<GCPtr<FunctionObject>> set {};
+    Optional<GC::Ptr<FunctionObject>> get {};
+    Optional<GC::Ptr<FunctionObject>> set {};
     Optional<bool> writable {};
     Optional<bool> enumerable {};
     Optional<bool> configurable {};
diff --git a/Libraries/LibJS/Runtime/PropertyKey.h b/Libraries/LibJS/Runtime/PropertyKey.h
index eceba387d5a..e5433328337 100644
--- a/Libraries/LibJS/Runtime/PropertyKey.h
+++ b/Libraries/LibJS/Runtime/PropertyKey.h
@@ -8,7 +8,7 @@
 
 #include <AK/DeprecatedFlyString.h>
 #include <AK/FlyString.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/StringOrSymbol.h>
 
@@ -84,7 +84,7 @@ public:
     {
     }
 
-    PropertyKey(NonnullGCPtr<Symbol> symbol)
+    PropertyKey(GC::Ref<Symbol> symbol)
         : m_type(Type::Symbol)
         , m_symbol(symbol)
     {
@@ -188,7 +188,7 @@ private:
     Type m_type { Type::Invalid };
     u32 m_number { 0 };
     DeprecatedFlyString m_string;
-    Handle<Symbol> m_symbol;
+    GC::Root<Symbol> m_symbol;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/PrototypeObject.h b/Libraries/LibJS/Runtime/PrototypeObject.h
index 0d787292737..50c3caca634 100644
--- a/Libraries/LibJS/Runtime/PrototypeObject.h
+++ b/Libraries/LibJS/Runtime/PrototypeObject.h
@@ -29,7 +29,7 @@ class PrototypeObject : public Object {
 public:
     virtual ~PrototypeObject() override = default;
 
-    static ThrowCompletionOr<NonnullGCPtr<Object>> this_object(VM& vm)
+    static ThrowCompletionOr<GC::Ref<Object>> this_object(VM& vm)
     {
         auto this_value = vm.this_value();
         if (!this_value.is_object())
@@ -38,7 +38,7 @@ public:
     }
 
     // Use typed_this_object() when the spec coerces |this| value to an object.
-    static ThrowCompletionOr<NonnullGCPtr<ObjectType>> typed_this_object(VM& vm)
+    static ThrowCompletionOr<GC::Ref<ObjectType>> typed_this_object(VM& vm)
     {
         auto this_object = TRY(vm.this_value().to_object(vm));
         if (!is<ObjectType>(*this_object))
@@ -47,7 +47,7 @@ public:
     }
 
     // Use typed_this_value() when the spec does not coerce |this| value to an object.
-    static ThrowCompletionOr<NonnullGCPtr<ObjectType>> typed_this_value(VM& vm)
+    static ThrowCompletionOr<GC::Ref<ObjectType>> typed_this_value(VM& vm)
     {
         auto this_value = vm.this_value();
         if (!this_value.is_object() || !is<ObjectType>(this_value.as_object()))
diff --git a/Libraries/LibJS/Runtime/ProxyConstructor.cpp b/Libraries/LibJS/Runtime/ProxyConstructor.cpp
index 9e0416ab72a..af74524fda3 100644
--- a/Libraries/LibJS/Runtime/ProxyConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ProxyConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ProxyConstructor);
+GC_DEFINE_ALLOCATOR(ProxyConstructor);
 
 // 10.5.14 ProxyCreate ( target, handler ), https://tc39.es/ecma262/#sec-proxycreate
 static ThrowCompletionOr<ProxyObject*> proxy_create(VM& vm, Value target, Value handler)
@@ -65,7 +65,7 @@ ThrowCompletionOr<Value> ProxyConstructor::call()
 }
 
 // 28.2.1.1 Proxy ( target, handler ), https://tc39.es/ecma262/#sec-proxy-target-handler
-ThrowCompletionOr<NonnullGCPtr<Object>> ProxyConstructor::construct(FunctionObject&)
+ThrowCompletionOr<GC::Ref<Object>> ProxyConstructor::construct(FunctionObject&)
 {
     auto& vm = this->vm();
     auto target = vm.argument(0);
@@ -86,7 +86,7 @@ JS_DEFINE_NATIVE_FUNCTION(ProxyConstructor::revocable)
     auto* proxy = TRY(proxy_create(vm, target, handler));
 
     // 2. Let revokerClosure be a new Abstract Closure with no parameters that captures nothing and performs the following steps when called:
-    auto revoker_closure = [proxy_handle = make_handle(proxy)](auto&) -> ThrowCompletionOr<Value> {
+    auto revoker_closure = [proxy_handle = make_root(proxy)](auto&) -> ThrowCompletionOr<Value> {
         // a. Let F be the active function object.
 
         // b. Let p be F.[[RevocableProxy]].
diff --git a/Libraries/LibJS/Runtime/ProxyConstructor.h b/Libraries/LibJS/Runtime/ProxyConstructor.h
index e46fd7a478f..e8399d82436 100644
--- a/Libraries/LibJS/Runtime/ProxyConstructor.h
+++ b/Libraries/LibJS/Runtime/ProxyConstructor.h
@@ -13,14 +13,14 @@ namespace JS {
 
 class ProxyConstructor final : public NativeFunction {
     JS_OBJECT(ProxyConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ProxyConstructor);
+    GC_DECLARE_ALLOCATOR(ProxyConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ProxyConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ProxyConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/ProxyObject.cpp b/Libraries/LibJS/Runtime/ProxyObject.cpp
index 911be773627..73a148e941f 100644
--- a/Libraries/LibJS/Runtime/ProxyObject.cpp
+++ b/Libraries/LibJS/Runtime/ProxyObject.cpp
@@ -16,7 +16,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ProxyObject);
+GC_DEFINE_ALLOCATOR(ProxyObject);
 
 // NOTE: We can't rely on native stack overflows to catch infinite recursion in Proxy traps,
 //       since the compiler may decide to optimize tail/sibling calls into loops.
@@ -36,7 +36,7 @@ struct RecursionDepthUpdater {
             return vm().throw_completion<InternalError>(ErrorType::CallStackSizeExceeded); \
     } while (0)
 
-NonnullGCPtr<ProxyObject> ProxyObject::create(Realm& realm, Object& target, Object& handler)
+GC::Ref<ProxyObject> ProxyObject::create(Realm& realm, Object& target, Object& handler)
 {
     return realm.create<ProxyObject>(target, handler, realm.intrinsics().object_prototype());
 }
@@ -681,7 +681,7 @@ ThrowCompletionOr<bool> ProxyObject::internal_delete(PropertyKey const& property
 }
 
 // 10.5.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
-ThrowCompletionOr<MarkedVector<Value>> ProxyObject::internal_own_property_keys() const
+ThrowCompletionOr<GC::MarkedVector<Value>> ProxyObject::internal_own_property_keys() const
 {
     LIMIT_PROXY_RECURSION_DEPTH();
 
@@ -732,10 +732,10 @@ ThrowCompletionOr<MarkedVector<Value>> ProxyObject::internal_own_property_keys()
     // 13. Assert: targetKeys contains no duplicate entries.
 
     // 14. Let targetConfigurableKeys be a new empty List.
-    auto target_configurable_keys = MarkedVector<Value> { heap() };
+    auto target_configurable_keys = GC::MarkedVector<Value> { heap() };
 
     // 15. Let targetNonconfigurableKeys be a new empty List.
-    auto target_nonconfigurable_keys = MarkedVector<Value> { heap() };
+    auto target_nonconfigurable_keys = GC::MarkedVector<Value> { heap() };
 
     // 16. For each element key of targetKeys, do
     for (auto& key : target_keys) {
@@ -763,7 +763,7 @@ ThrowCompletionOr<MarkedVector<Value>> ProxyObject::internal_own_property_keys()
     }
 
     // 18. Let uncheckedResultKeys be a List whose elements are the elements of trapResult.
-    auto unchecked_result_keys = MarkedVector<Value> { heap() };
+    auto unchecked_result_keys = GC::MarkedVector<Value> { heap() };
     unchecked_result_keys.extend(trap_result);
 
     // 19. For each element key of targetNonconfigurableKeys, do
@@ -849,7 +849,7 @@ bool ProxyObject::has_constructor() const
 }
 
 // 10.5.13 [[Construct]] ( argumentsList, newTarget ), https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-construct-argumentslist-newtarget
-ThrowCompletionOr<NonnullGCPtr<Object>> ProxyObject::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ProxyObject::internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target)
 {
     LIMIT_PROXY_RECURSION_DEPTH();
 
diff --git a/Libraries/LibJS/Runtime/ProxyObject.h b/Libraries/LibJS/Runtime/ProxyObject.h
index d2f21d910c5..e289ba2b4e0 100644
--- a/Libraries/LibJS/Runtime/ProxyObject.h
+++ b/Libraries/LibJS/Runtime/ProxyObject.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class ProxyObject final : public FunctionObject {
     JS_OBJECT(ProxyObject, FunctionObject);
-    JS_DECLARE_ALLOCATOR(ProxyObject);
+    GC_DECLARE_ALLOCATOR(ProxyObject);
 
 public:
-    static NonnullGCPtr<ProxyObject> create(Realm&, Object& target, Object& handler);
+    static GC::Ref<ProxyObject> create(Realm&, Object& target, Object& handler);
 
     virtual ~ProxyObject() override = default;
 
@@ -42,9 +42,9 @@ public:
     virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata*, PropertyLookupPhase) const override;
     virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata*) override;
     virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const override;
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
     virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;
 
 private:
     ProxyObject(Object& target, Object& handler, Object& prototype);
@@ -54,8 +54,8 @@ private:
     virtual bool is_function() const override { return m_target->is_function(); }
     virtual bool is_proxy_object() const final { return true; }
 
-    NonnullGCPtr<Object> m_target;
-    NonnullGCPtr<Object> m_handler;
+    GC::Ref<Object> m_target;
+    GC::Ref<Object> m_handler;
     bool m_is_revoked { false };
 };
 
diff --git a/Libraries/LibJS/Runtime/Realm.cpp b/Libraries/LibJS/Runtime/Realm.cpp
index 5604e7fbe66..52e32aa2929 100644
--- a/Libraries/LibJS/Runtime/Realm.cpp
+++ b/Libraries/LibJS/Runtime/Realm.cpp
@@ -6,7 +6,7 @@
  */
 
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/DeferGC.h>
+#include <LibGC/DeferGC.h>
 #include <LibJS/Runtime/GlobalEnvironment.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/Realm.h>
@@ -14,12 +14,12 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Realm);
+GC_DEFINE_ALLOCATOR(Realm);
 
 // 9.3.1 InitializeHostDefinedRealm ( ), https://tc39.es/ecma262/#sec-initializehostdefinedrealm
 ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> Realm::initialize_host_defined_realm(VM& vm, Function<Object*(Realm&)> create_global_object, Function<Object*(Realm&)> create_global_this_value)
 {
-    DeferGC defer_gc(vm.heap());
+    GC::DeferGC defer_gc(vm.heap());
 
     // 1. Let realm be a new Realm Record
     auto realm = vm.heap().allocate<Realm>();
diff --git a/Libraries/LibJS/Runtime/Realm.h b/Libraries/LibJS/Runtime/Realm.h
index dcbe5536ebf..5e318c42bd2 100644
--- a/Libraries/LibJS/Runtime/Realm.h
+++ b/Libraries/LibJS/Runtime/Realm.h
@@ -11,10 +11,10 @@
 #include <AK/OwnPtr.h>
 #include <AK/StringView.h>
 #include <AK/Weakable.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Bytecode/Builtins.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/Intrinsics.h>
 #include <LibJS/Runtime/Value.h>
 
@@ -22,8 +22,8 @@ namespace JS {
 
 // 9.3 Realms, https://tc39.es/ecma262/#realm-record
 class Realm final : public Cell {
-    JS_CELL(Realm, Cell);
-    JS_DECLARE_ALLOCATOR(Realm);
+    GC_CELL(Realm, Cell);
+    GC_DECLARE_ALLOCATOR(Realm);
 
 public:
     struct HostDefined {
@@ -33,7 +33,7 @@ public:
     };
 
     template<typename T, typename... Args>
-    NonnullGCPtr<T> create(Args&&... args)
+    GC::Ref<T> create(Args&&... args)
     {
         auto object = heap().allocate<T>(forward<Args>(args)...);
         static_cast<Cell*>(object)->initialize(*this);
@@ -43,10 +43,10 @@ public:
     static ThrowCompletionOr<NonnullOwnPtr<ExecutionContext>> initialize_host_defined_realm(VM&, Function<Object*(Realm&)> create_global_object, Function<Object*(Realm&)> create_global_this_value);
 
     [[nodiscard]] Object& global_object() const { return *m_global_object; }
-    void set_global_object(NonnullGCPtr<Object> global) { m_global_object = global; }
+    void set_global_object(GC::Ref<Object> global) { m_global_object = global; }
 
     [[nodiscard]] GlobalEnvironment& global_environment() const { return *m_global_environment; }
-    void set_global_environment(NonnullGCPtr<GlobalEnvironment> environment) { m_global_environment = environment; }
+    void set_global_environment(GC::Ref<GlobalEnvironment> environment) { m_global_environment = environment; }
 
     [[nodiscard]] Intrinsics const& intrinsics() const { return *m_intrinsics; }
     [[nodiscard]] Intrinsics& intrinsics() { return *m_intrinsics; }
@@ -61,12 +61,12 @@ public:
 
     void set_host_defined(OwnPtr<HostDefined> host_defined) { m_host_defined = move(host_defined); }
 
-    void define_builtin(Bytecode::Builtin builtin, NonnullGCPtr<NativeFunction> value)
+    void define_builtin(Bytecode::Builtin builtin, GC::Ref<NativeFunction> value)
     {
         m_builtins[to_underlying(builtin)] = value;
     }
 
-    NonnullGCPtr<NativeFunction> get_builtin_value(Bytecode::Builtin builtin)
+    GC::Ref<NativeFunction> get_builtin_value(Bytecode::Builtin builtin)
     {
         return *m_builtins[to_underlying(builtin)];
     }
@@ -76,11 +76,11 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    GCPtr<Intrinsics> m_intrinsics;                // [[Intrinsics]]
-    GCPtr<Object> m_global_object;                 // [[GlobalObject]]
-    GCPtr<GlobalEnvironment> m_global_environment; // [[GlobalEnv]]
-    OwnPtr<HostDefined> m_host_defined;            // [[HostDefined]]
-    AK::Array<GCPtr<NativeFunction>, to_underlying(Bytecode::Builtin::__Count)> m_builtins;
+    GC::Ptr<Intrinsics> m_intrinsics;                // [[Intrinsics]]
+    GC::Ptr<Object> m_global_object;                 // [[GlobalObject]]
+    GC::Ptr<GlobalEnvironment> m_global_environment; // [[GlobalEnv]]
+    OwnPtr<HostDefined> m_host_defined;              // [[HostDefined]]
+    AK::Array<GC::Ptr<NativeFunction>, to_underlying(Bytecode::Builtin::__Count)> m_builtins;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/Reference.cpp b/Libraries/LibJS/Runtime/Reference.cpp
index c8ef3677d77..f6b3de56563 100644
--- a/Libraries/LibJS/Runtime/Reference.cpp
+++ b/Libraries/LibJS/Runtime/Reference.cpp
@@ -112,7 +112,7 @@ ThrowCompletionOr<Value> Reference::get_value(VM& vm) const
         }
 
         // OPTIMIZATION: For various primitives we can avoid actually creating a new object for them.
-        GCPtr<Object> base_obj;
+        GC::Ptr<Object> base_obj;
         if (m_base_value.is_string()) {
             auto string_value = TRY(m_base_value.as_string().get(vm, name()));
             if (string_value.has_value())
diff --git a/Libraries/LibJS/Runtime/ReflectObject.cpp b/Libraries/LibJS/Runtime/ReflectObject.cpp
index a4571015dff..29eca5999c7 100644
--- a/Libraries/LibJS/Runtime/ReflectObject.cpp
+++ b/Libraries/LibJS/Runtime/ReflectObject.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ReflectObject);
+GC_DEFINE_ALLOCATOR(ReflectObject);
 
 ReflectObject::ReflectObject(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/ReflectObject.h b/Libraries/LibJS/Runtime/ReflectObject.h
index 5937626d7b5..f99464843e7 100644
--- a/Libraries/LibJS/Runtime/ReflectObject.h
+++ b/Libraries/LibJS/Runtime/ReflectObject.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class ReflectObject final : public Object {
     JS_OBJECT(ReflectObject, Object);
-    JS_DECLARE_ALLOCATOR(ReflectObject);
+    GC_DECLARE_ALLOCATOR(ReflectObject);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/RegExpConstructor.cpp b/Libraries/LibJS/Runtime/RegExpConstructor.cpp
index 363722861f6..a0dad384159 100644
--- a/Libraries/LibJS/Runtime/RegExpConstructor.cpp
+++ b/Libraries/LibJS/Runtime/RegExpConstructor.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RegExpConstructor);
+GC_DEFINE_ALLOCATOR(RegExpConstructor);
 
 RegExpConstructor::RegExpConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.RegExp.as_string(), realm.intrinsics().function_prototype())
@@ -82,7 +82,7 @@ ThrowCompletionOr<Value> RegExpConstructor::call()
 }
 
 // 22.2.4.1 RegExp ( pattern, flags ), https://tc39.es/ecma262/#sec-regexp-pattern-flags
-ThrowCompletionOr<NonnullGCPtr<Object>> RegExpConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> RegExpConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/RegExpConstructor.h b/Libraries/LibJS/Runtime/RegExpConstructor.h
index 06b9c213a3f..6b3598a1344 100644
--- a/Libraries/LibJS/Runtime/RegExpConstructor.h
+++ b/Libraries/LibJS/Runtime/RegExpConstructor.h
@@ -13,14 +13,14 @@ namespace JS {
 
 class RegExpConstructor final : public NativeFunction {
     JS_OBJECT(RegExpConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(RegExpConstructor);
+    GC_DECLARE_ALLOCATOR(RegExpConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~RegExpConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
     RegExpLegacyStaticProperties& legacy_static_properties() { return m_legacy_static_properties; }
 
diff --git a/Libraries/LibJS/Runtime/RegExpObject.cpp b/Libraries/LibJS/Runtime/RegExpObject.cpp
index 7eae7bf397b..972f343c788 100644
--- a/Libraries/LibJS/Runtime/RegExpObject.cpp
+++ b/Libraries/LibJS/Runtime/RegExpObject.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RegExpObject);
+GC_DEFINE_ALLOCATOR(RegExpObject);
 
 Result<regex::RegexOptions<ECMAScriptFlags>, ByteString> regex_flags_from_string(StringView flags)
 {
@@ -146,12 +146,12 @@ ThrowCompletionOr<ByteString> parse_regex_pattern(VM& vm, StringView pattern, bo
     return result.release_value();
 }
 
-NonnullGCPtr<RegExpObject> RegExpObject::create(Realm& realm)
+GC::Ref<RegExpObject> RegExpObject::create(Realm& realm)
 {
     return realm.create<RegExpObject>(realm.intrinsics().regexp_prototype());
 }
 
-NonnullGCPtr<RegExpObject> RegExpObject::create(Realm& realm, Regex<ECMA262> regex, ByteString pattern, ByteString flags)
+GC::Ref<RegExpObject> RegExpObject::create(Realm& realm, Regex<ECMA262> regex, ByteString pattern, ByteString flags)
 {
     return realm.create<RegExpObject>(move(regex), move(pattern), move(flags), realm.intrinsics().regexp_prototype());
 }
@@ -198,7 +198,7 @@ void RegExpObject::initialize(Realm& realm)
 }
 
 // 22.2.3.3 RegExpInitialize ( obj, pattern, flags ), https://tc39.es/ecma262/#sec-regexpinitialize
-ThrowCompletionOr<NonnullGCPtr<RegExpObject>> RegExpObject::regexp_initialize(VM& vm, Value pattern_value, Value flags_value)
+ThrowCompletionOr<GC::Ref<RegExpObject>> RegExpObject::regexp_initialize(VM& vm, Value pattern_value, Value flags_value)
 {
     // 1. If pattern is undefined, let P be the empty String.
     // 2. Else, let P be ? ToString(pattern).
@@ -261,7 +261,7 @@ ThrowCompletionOr<NonnullGCPtr<RegExpObject>> RegExpObject::regexp_initialize(VM
     TRY(set(vm.names.lastIndex, Value(0), Object::ShouldThrowExceptions::Yes));
 
     // 23. Return obj.
-    return NonnullGCPtr { *this };
+    return GC::Ref { *this };
 }
 
 // 22.2.6.13.1 EscapeRegExpPattern ( P, F ), https://tc39.es/ecma262/#sec-escaperegexppattern
@@ -332,7 +332,7 @@ void RegExpObject::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // 22.2.3.1 RegExpCreate ( P, F ), https://tc39.es/ecma262/#sec-regexpcreate
-ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_create(VM& vm, Value pattern, Value flags)
+ThrowCompletionOr<GC::Ref<RegExpObject>> regexp_create(VM& vm, Value pattern, Value flags)
 {
     auto& realm = *vm.current_realm();
 
@@ -345,7 +345,7 @@ ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_create(VM& vm, Value patter
 
 // 22.2.3.2 RegExpAlloc ( newTarget ), https://tc39.es/ecma262/#sec-regexpalloc
 // 22.2.3.2 RegExpAlloc ( newTarget ), https://github.com/tc39/proposal-regexp-legacy-features#regexpalloc--newtarget-
-ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_alloc(VM& vm, FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<RegExpObject>> regexp_alloc(VM& vm, FunctionObject& new_target)
 {
     // 1. Let obj be ? OrdinaryCreateFromConstructor(newTarget, "%RegExp.prototype%", « [[OriginalSource]], [[OriginalFlags]], [[RegExpRecord]], [[RegExpMatcher]] »).
     auto regexp_object = TRY(ordinary_create_from_constructor<RegExpObject>(vm, new_target, &Intrinsics::regexp_prototype));
diff --git a/Libraries/LibJS/Runtime/RegExpObject.h b/Libraries/LibJS/Runtime/RegExpObject.h
index 2cd909d4ef8..947a2b3bddb 100644
--- a/Libraries/LibJS/Runtime/RegExpObject.h
+++ b/Libraries/LibJS/Runtime/RegExpObject.h
@@ -15,8 +15,8 @@
 
 namespace JS {
 
-ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_create(VM&, Value pattern, Value flags);
-ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_alloc(VM&, FunctionObject& new_target);
+ThrowCompletionOr<GC::Ref<RegExpObject>> regexp_create(VM&, Value pattern, Value flags);
+ThrowCompletionOr<GC::Ref<RegExpObject>> regexp_alloc(VM&, FunctionObject& new_target);
 
 Result<regex::RegexOptions<ECMAScriptFlags>, ByteString> regex_flags_from_string(StringView flags);
 struct ParseRegexPatternError {
@@ -27,7 +27,7 @@ ThrowCompletionOr<ByteString> parse_regex_pattern(VM& vm, StringView pattern, bo
 
 class RegExpObject : public Object {
     JS_OBJECT(RegExpObject, Object);
-    JS_DECLARE_ALLOCATOR(RegExpObject);
+    GC_DECLARE_ALLOCATOR(RegExpObject);
 
 public:
     // JS regexps are all 'global' by default as per our definition, but the "global" flag enables "stateful".
@@ -50,10 +50,10 @@ public:
         Sticky = 1 << 7,
     };
 
-    static NonnullGCPtr<RegExpObject> create(Realm&);
-    static NonnullGCPtr<RegExpObject> create(Realm&, Regex<ECMA262> regex, ByteString pattern, ByteString flags);
+    static GC::Ref<RegExpObject> create(Realm&);
+    static GC::Ref<RegExpObject> create(Realm&, Regex<ECMA262> regex, ByteString pattern, ByteString flags);
 
-    ThrowCompletionOr<NonnullGCPtr<RegExpObject>> regexp_initialize(VM&, Value pattern, Value flags);
+    ThrowCompletionOr<GC::Ref<RegExpObject>> regexp_initialize(VM&, Value pattern, Value flags);
     ByteString escape_regexp_pattern() const;
 
     virtual void initialize(Realm&) override;
@@ -81,7 +81,7 @@ private:
     Flags m_flag_bits { 0 };
     bool m_legacy_features_enabled { false }; // [[LegacyFeaturesEnabled]]
     // Note: This is initialized in RegExpAlloc, but will be non-null afterwards
-    GCPtr<Realm> m_realm; // [[Realm]]
+    GC::Ptr<Realm> m_realm; // [[Realm]]
     Optional<Regex<ECMA262>> m_regex;
 };
 
diff --git a/Libraries/LibJS/Runtime/RegExpPrototype.cpp b/Libraries/LibJS/Runtime/RegExpPrototype.cpp
index af7c83cf1b7..60c505f79b3 100644
--- a/Libraries/LibJS/Runtime/RegExpPrototype.cpp
+++ b/Libraries/LibJS/Runtime/RegExpPrototype.cpp
@@ -23,7 +23,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RegExpPrototype);
+GC_DEFINE_ALLOCATOR(RegExpPrototype);
 
 RegExpPrototype::RegExpPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
@@ -289,7 +289,7 @@ static ThrowCompletionOr<Value> regexp_builtin_exec(VM& vm, RegExpObject& regexp
     //     a. Let groups be undefined.
     //     b. Let hasGroups be false.
     bool has_groups = result.n_named_capture_groups != 0;
-    auto groups_object = has_groups ? Object::create(realm, nullptr) : GCPtr<Object> {};
+    auto groups_object = has_groups ? Object::create(realm, nullptr) : GC::Ptr<Object> {};
 
     // 33. For each integer i such that i ≥ 1 and i ≤ n, in ascending order, do
     for (size_t i = 1; i <= result.n_capture_groups; ++i) {
@@ -669,7 +669,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
     }
 
     // 10. Let results be a new empty List.
-    MarkedVector<Object*> results(vm.heap());
+    GC::MarkedVector<Object*> results(vm.heap());
 
     // 11. Let done be false.
     // 12. Repeat, while done is false,
@@ -735,7 +735,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
         position = clamp(position, static_cast<double>(0), static_cast<double>(string.length_in_code_units()));
 
         // g. Let captures be a new empty List.
-        MarkedVector<Value> captures(vm.heap());
+        GC::MarkedVector<Value> captures(vm.heap());
 
         // h. Let n be 1.
         // i. Repeat, while n ≤ nCaptures,
@@ -764,7 +764,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
         // k. If functionalReplace is true, then
         if (replace_value.is_function()) {
             // i. Let replacerArgs be the list-concatenation of « matched », captures, and « 𝔽(position), S ».
-            MarkedVector<Value> replacer_args(vm.heap());
+            GC::MarkedVector<Value> replacer_args(vm.heap());
             replacer_args.append(PrimitiveString::create(vm, move(matched)));
             replacer_args.extend(move(captures));
             replacer_args.append(Value(position));
diff --git a/Libraries/LibJS/Runtime/RegExpPrototype.h b/Libraries/LibJS/Runtime/RegExpPrototype.h
index adeb0de3063..5c57a6703a9 100644
--- a/Libraries/LibJS/Runtime/RegExpPrototype.h
+++ b/Libraries/LibJS/Runtime/RegExpPrototype.h
@@ -17,7 +17,7 @@ size_t advance_string_index(Utf16View const& string, size_t index, bool unicode)
 
 class RegExpPrototype final : public PrototypeObject<RegExpPrototype, RegExpObject> {
     JS_PROTOTYPE_OBJECT(RegExpPrototype, RegExpObject, RegExp);
-    JS_DECLARE_ALLOCATOR(RegExpPrototype);
+    GC_DECLARE_ALLOCATOR(RegExpPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/RegExpStringIterator.cpp b/Libraries/LibJS/Runtime/RegExpStringIterator.cpp
index 5a62dc934ff..3f14e2a6c50 100644
--- a/Libraries/LibJS/Runtime/RegExpStringIterator.cpp
+++ b/Libraries/LibJS/Runtime/RegExpStringIterator.cpp
@@ -9,10 +9,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RegExpStringIterator);
+GC_DEFINE_ALLOCATOR(RegExpStringIterator);
 
 // 22.2.9.1 CreateRegExpStringIterator ( R, S, global, fullUnicode ), https://tc39.es/ecma262/#sec-createregexpstringiterator
-NonnullGCPtr<RegExpStringIterator> RegExpStringIterator::create(Realm& realm, Object& regexp_object, Utf16String string, bool global, bool unicode)
+GC::Ref<RegExpStringIterator> RegExpStringIterator::create(Realm& realm, Object& regexp_object, Utf16String string, bool global, bool unicode)
 {
     return realm.create<RegExpStringIterator>(realm.intrinsics().regexp_string_iterator_prototype(), regexp_object, move(string), global, unicode);
 }
diff --git a/Libraries/LibJS/Runtime/RegExpStringIterator.h b/Libraries/LibJS/Runtime/RegExpStringIterator.h
index dfaae69a2b0..2a0b54c0c8f 100644
--- a/Libraries/LibJS/Runtime/RegExpStringIterator.h
+++ b/Libraries/LibJS/Runtime/RegExpStringIterator.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class RegExpStringIterator final : public Object {
     JS_OBJECT(RegExpStringIterator, Object);
-    JS_DECLARE_ALLOCATOR(RegExpStringIterator);
+    GC_DECLARE_ALLOCATOR(RegExpStringIterator);
 
 public:
-    static NonnullGCPtr<RegExpStringIterator> create(Realm&, Object& regexp_object, Utf16String string, bool global, bool unicode);
+    static GC::Ref<RegExpStringIterator> create(Realm&, Object& regexp_object, Utf16String string, bool global, bool unicode);
 
     virtual ~RegExpStringIterator() override = default;
 
@@ -34,7 +34,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    NonnullGCPtr<Object> m_regexp_object;
+    GC::Ref<Object> m_regexp_object;
     Utf16String m_string;
     bool m_global { false };
     bool m_unicode { false };
diff --git a/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.cpp b/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.cpp
index c3330b89f9e..4fa03378e77 100644
--- a/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(RegExpStringIteratorPrototype);
+GC_DEFINE_ALLOCATOR(RegExpStringIteratorPrototype);
 
 RegExpStringIteratorPrototype::RegExpStringIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.h b/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.h
index 96818aaee89..9355c3e3901 100644
--- a/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/RegExpStringIteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class RegExpStringIteratorPrototype final : public PrototypeObject<RegExpStringIteratorPrototype, RegExpStringIterator> {
     JS_PROTOTYPE_OBJECT(RegExpStringIteratorPrototype, RegExpStringIterator, RegExpStringIterator);
-    JS_DECLARE_ALLOCATOR(RegExpStringIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(RegExpStringIteratorPrototype);
 
 public:
     virtual ~RegExpStringIteratorPrototype() override = default;
diff --git a/Libraries/LibJS/Runtime/Set.cpp b/Libraries/LibJS/Runtime/Set.cpp
index c5f020309a2..59286eafcaa 100644
--- a/Libraries/LibJS/Runtime/Set.cpp
+++ b/Libraries/LibJS/Runtime/Set.cpp
@@ -10,9 +10,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Set);
+GC_DEFINE_ALLOCATOR(Set);
 
-NonnullGCPtr<Set> Set::create(Realm& realm)
+GC::Ref<Set> Set::create(Realm& realm)
 {
     return realm.create<Set>(realm.intrinsics().set_prototype());
 }
@@ -27,7 +27,7 @@ void Set::initialize(Realm& realm)
     m_values = Map::create(realm);
 }
 
-NonnullGCPtr<Set> Set::copy() const
+GC::Ref<Set> Set::copy() const
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
@@ -90,7 +90,7 @@ ThrowCompletionOr<SetRecord> get_set_record(VM& vm, Value value)
 }
 
 // 24.2.1.3 SetDataHas ( setData, value ), https://tc39.es/ecma262/#sec-setdatahas
-bool set_data_has(NonnullGCPtr<Set> set_data, Value value)
+bool set_data_has(GC::Ref<Set> set_data, Value value)
 {
     // NOTE: We do not need to implement SetDataIndex, as we do not implement the use of empty slots in Set. But we do
     //       need to match its behavior of always canonicalizing the provided value.
diff --git a/Libraries/LibJS/Runtime/Set.h b/Libraries/LibJS/Runtime/Set.h
index e7150be17a4..3c369ed7961 100644
--- a/Libraries/LibJS/Runtime/Set.h
+++ b/Libraries/LibJS/Runtime/Set.h
@@ -15,10 +15,10 @@ namespace JS {
 
 class Set : public Object {
     JS_OBJECT(Set, Object);
-    JS_DECLARE_ALLOCATOR(Set);
+    GC_DECLARE_ALLOCATOR(Set);
 
 public:
-    static NonnullGCPtr<Set> create(Realm&);
+    static GC::Ref<Set> create(Realm&);
 
     virtual void initialize(Realm&) override;
     virtual ~Set() override = default;
@@ -37,25 +37,25 @@ public:
     auto begin() { return m_values->begin(); }
     auto end() const { return m_values->end(); }
 
-    NonnullGCPtr<Set> copy() const;
+    GC::Ref<Set> copy() const;
 
 private:
     explicit Set(Object& prototype);
 
     virtual void visit_edges(Visitor& visitor) override;
 
-    GCPtr<Map> m_values;
+    GC::Ptr<Map> m_values;
 };
 
 // 24.2.1.1 Set Records, https://tc39.es/ecma262/#sec-set-records
 struct SetRecord {
-    NonnullGCPtr<Object const> set_object; // [[SetObject]]
-    double size { 0 };                     // [[Size]
-    NonnullGCPtr<FunctionObject> has;      // [[Has]]
-    NonnullGCPtr<FunctionObject> keys;     // [[Keys]]
+    GC::Ref<Object const> set_object; // [[SetObject]]
+    double size { 0 };                // [[Size]
+    GC::Ref<FunctionObject> has;      // [[Has]]
+    GC::Ref<FunctionObject> keys;     // [[Keys]]
 };
 
 ThrowCompletionOr<SetRecord> get_set_record(VM&, Value);
-bool set_data_has(NonnullGCPtr<Set>, Value);
+bool set_data_has(GC::Ref<Set>, Value);
 
 }
diff --git a/Libraries/LibJS/Runtime/SetConstructor.cpp b/Libraries/LibJS/Runtime/SetConstructor.cpp
index 22da3539fd4..bdbed79d0c9 100644
--- a/Libraries/LibJS/Runtime/SetConstructor.cpp
+++ b/Libraries/LibJS/Runtime/SetConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SetConstructor);
+GC_DEFINE_ALLOCATOR(SetConstructor);
 
 SetConstructor::SetConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Set.as_string(), realm.intrinsics().function_prototype())
@@ -43,7 +43,7 @@ ThrowCompletionOr<Value> SetConstructor::call()
 }
 
 // 24.2.1.1 Set ( [ iterable ] ), https://tc39.es/ecma262/#sec-set-iterable
-ThrowCompletionOr<NonnullGCPtr<Object>> SetConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> SetConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto iterable = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/SetConstructor.h b/Libraries/LibJS/Runtime/SetConstructor.h
index a36a8152cf0..2ebbe63879b 100644
--- a/Libraries/LibJS/Runtime/SetConstructor.h
+++ b/Libraries/LibJS/Runtime/SetConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class SetConstructor final : public NativeFunction {
     JS_OBJECT(SetConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(SetConstructor);
+    GC_DECLARE_ALLOCATOR(SetConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~SetConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit SetConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/SetIterator.cpp b/Libraries/LibJS/Runtime/SetIterator.cpp
index d431e8eb712..5d6cd4dedda 100644
--- a/Libraries/LibJS/Runtime/SetIterator.cpp
+++ b/Libraries/LibJS/Runtime/SetIterator.cpp
@@ -9,9 +9,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SetIterator);
+GC_DEFINE_ALLOCATOR(SetIterator);
 
-NonnullGCPtr<SetIterator> SetIterator::create(Realm& realm, Set& set, Object::PropertyKind iteration_kind)
+GC::Ref<SetIterator> SetIterator::create(Realm& realm, Set& set, Object::PropertyKind iteration_kind)
 {
     return realm.create<SetIterator>(set, iteration_kind, realm.intrinsics().set_iterator_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/SetIterator.h b/Libraries/LibJS/Runtime/SetIterator.h
index 2cdb828ce58..4ad95c18da5 100644
--- a/Libraries/LibJS/Runtime/SetIterator.h
+++ b/Libraries/LibJS/Runtime/SetIterator.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class SetIterator final : public Object {
     JS_OBJECT(SetIterator, Object);
-    JS_DECLARE_ALLOCATOR(SetIterator);
+    GC_DECLARE_ALLOCATOR(SetIterator);
 
 public:
-    static NonnullGCPtr<SetIterator> create(Realm&, Set& set, Object::PropertyKind iteration_kind);
+    static GC::Ref<SetIterator> create(Realm&, Set& set, Object::PropertyKind iteration_kind);
 
     virtual ~SetIterator() override = default;
 
@@ -32,7 +32,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    NonnullGCPtr<Set> m_set;
+    GC::Ref<Set> m_set;
     bool m_done { false };
     Object::PropertyKind m_iteration_kind;
     Map::ConstIterator m_iterator;
diff --git a/Libraries/LibJS/Runtime/SetIteratorPrototype.cpp b/Libraries/LibJS/Runtime/SetIteratorPrototype.cpp
index 8c148b8f475..ec4c6a86b39 100644
--- a/Libraries/LibJS/Runtime/SetIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/SetIteratorPrototype.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SetIteratorPrototype);
+GC_DEFINE_ALLOCATOR(SetIteratorPrototype);
 
 SetIteratorPrototype::SetIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/SetIteratorPrototype.h b/Libraries/LibJS/Runtime/SetIteratorPrototype.h
index 6f8a7504cbe..5f480157cdc 100644
--- a/Libraries/LibJS/Runtime/SetIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/SetIteratorPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class SetIteratorPrototype final : public PrototypeObject<SetIteratorPrototype, SetIterator> {
     JS_PROTOTYPE_OBJECT(SetIteratorPrototype, SetIterator, SetIterator);
-    JS_DECLARE_ALLOCATOR(SetIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(SetIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/SetPrototype.cpp b/Libraries/LibJS/Runtime/SetPrototype.cpp
index 86936cb54ee..6d78c618349 100644
--- a/Libraries/LibJS/Runtime/SetPrototype.cpp
+++ b/Libraries/LibJS/Runtime/SetPrototype.cpp
@@ -16,7 +16,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SetPrototype);
+GC_DEFINE_ALLOCATOR(SetPrototype);
 
 SetPrototype::SetPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/SetPrototype.h b/Libraries/LibJS/Runtime/SetPrototype.h
index 49992c07d29..1ef332ca67b 100644
--- a/Libraries/LibJS/Runtime/SetPrototype.h
+++ b/Libraries/LibJS/Runtime/SetPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class SetPrototype final : public PrototypeObject<SetPrototype, Set> {
     JS_PROTOTYPE_OBJECT(SetPrototype, Set, Set);
-    JS_DECLARE_ALLOCATOR(SetPrototype);
+    GC_DECLARE_ALLOCATOR(SetPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/ShadowRealm.cpp b/Libraries/LibJS/Runtime/ShadowRealm.cpp
index ba5f56fb032..bea57bd62e5 100644
--- a/Libraries/LibJS/Runtime/ShadowRealm.cpp
+++ b/Libraries/LibJS/Runtime/ShadowRealm.cpp
@@ -20,7 +20,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ShadowRealm);
+GC_DEFINE_ALLOCATOR(ShadowRealm);
 
 ShadowRealm::ShadowRealm(Object& prototype)
     : Object(ConstructWithPrototypeTag::Tag, prototype)
@@ -208,7 +208,7 @@ ThrowCompletionOr<Value> shadow_realm_import_value(VM& vm, ByteString specifier_
     TRY(vm.push_execution_context(*eval_context, {}));
 
     // 6. Let referrer be the Realm component of evalContext.
-    auto referrer = JS::NonnullGCPtr { *eval_context->realm };
+    auto referrer = GC::Ref { *eval_context->realm };
 
     // 7. Perform HostLoadImportedModule(referrer, specifierString, empty, innerCapability).
     vm.host_load_imported_module(referrer, ModuleRequest { specifier_string }, nullptr, inner_capability);
diff --git a/Libraries/LibJS/Runtime/ShadowRealm.h b/Libraries/LibJS/Runtime/ShadowRealm.h
index 54a5bf3b395..efd2734c457 100644
--- a/Libraries/LibJS/Runtime/ShadowRealm.h
+++ b/Libraries/LibJS/Runtime/ShadowRealm.h
@@ -15,14 +15,14 @@ namespace JS {
 
 class ShadowRealm final : public Object {
     JS_OBJECT(ShadowRealm, Object);
-    JS_DECLARE_ALLOCATOR(ShadowRealm);
+    GC_DECLARE_ALLOCATOR(ShadowRealm);
 
 public:
     virtual ~ShadowRealm() override = default;
 
     [[nodiscard]] Realm const& shadow_realm() const { return *m_shadow_realm; }
     [[nodiscard]] Realm& shadow_realm() { return *m_shadow_realm; }
-    void set_shadow_realm(NonnullGCPtr<Realm> realm) { m_shadow_realm = realm; }
+    void set_shadow_realm(GC::Ref<Realm> realm) { m_shadow_realm = realm; }
 
 private:
     ShadowRealm(Object& prototype);
@@ -30,7 +30,7 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 3.5 Properties of ShadowRealm Instances, https://tc39.es/proposal-shadowrealm/#sec-properties-of-shadowrealm-instances
-    GCPtr<Realm> m_shadow_realm; // [[ShadowRealm]]
+    GC::Ptr<Realm> m_shadow_realm; // [[ShadowRealm]]
 };
 
 ThrowCompletionOr<void> copy_name_and_length(VM&, FunctionObject& function, FunctionObject& target, Optional<StringView> prefix = {}, Optional<unsigned> arg_count = {});
diff --git a/Libraries/LibJS/Runtime/ShadowRealmConstructor.cpp b/Libraries/LibJS/Runtime/ShadowRealmConstructor.cpp
index deeeaa94beb..82f1e9565cf 100644
--- a/Libraries/LibJS/Runtime/ShadowRealmConstructor.cpp
+++ b/Libraries/LibJS/Runtime/ShadowRealmConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ShadowRealmConstructor);
+GC_DEFINE_ALLOCATOR(ShadowRealmConstructor);
 
 // 3.2 The ShadowRealm Constructor, https://tc39.es/proposal-shadowrealm/#sec-shadowrealm-constructor
 ShadowRealmConstructor::ShadowRealmConstructor(Realm& realm)
@@ -41,7 +41,7 @@ ThrowCompletionOr<Value> ShadowRealmConstructor::call()
 
 // 3.2.1 ShadowRealm ( ), https://tc39.es/proposal-shadowrealm/#sec-shadowrealm
 // https://github.com/tc39/proposal-shadowrealm/pull/410
-ThrowCompletionOr<NonnullGCPtr<Object>> ShadowRealmConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ShadowRealmConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/ShadowRealmConstructor.h b/Libraries/LibJS/Runtime/ShadowRealmConstructor.h
index 1a56658cf24..080d38cc0ab 100644
--- a/Libraries/LibJS/Runtime/ShadowRealmConstructor.h
+++ b/Libraries/LibJS/Runtime/ShadowRealmConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class ShadowRealmConstructor final : public NativeFunction {
     JS_OBJECT(ShadowRealmConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ShadowRealmConstructor);
+    GC_DECLARE_ALLOCATOR(ShadowRealmConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ShadowRealmConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ShadowRealmConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/ShadowRealmPrototype.cpp b/Libraries/LibJS/Runtime/ShadowRealmPrototype.cpp
index c239fd67abb..b1623b24f24 100644
--- a/Libraries/LibJS/Runtime/ShadowRealmPrototype.cpp
+++ b/Libraries/LibJS/Runtime/ShadowRealmPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(ShadowRealmPrototype);
+GC_DEFINE_ALLOCATOR(ShadowRealmPrototype);
 
 // 3.4 Properties of the ShadowRealm Prototype Object, https://tc39.es/proposal-shadowrealm/#sec-properties-of-the-shadowrealm-prototype-object
 ShadowRealmPrototype::ShadowRealmPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/ShadowRealmPrototype.h b/Libraries/LibJS/Runtime/ShadowRealmPrototype.h
index 219b942ae67..3c2ffa7ee6a 100644
--- a/Libraries/LibJS/Runtime/ShadowRealmPrototype.h
+++ b/Libraries/LibJS/Runtime/ShadowRealmPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class ShadowRealmPrototype final : public PrototypeObject<ShadowRealmPrototype, ShadowRealm> {
     JS_PROTOTYPE_OBJECT(ShadowRealmPrototype, ShadowRealm, ShadowRealm);
-    JS_DECLARE_ALLOCATOR(ShadowRealmPrototype);
+    GC_DECLARE_ALLOCATOR(ShadowRealmPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Shape.cpp b/Libraries/LibJS/Runtime/Shape.cpp
index 5367e993fd3..326ab3af6b2 100644
--- a/Libraries/LibJS/Runtime/Shape.cpp
+++ b/Libraries/LibJS/Runtime/Shape.cpp
@@ -4,16 +4,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/DeferGC.h>
+#include <LibGC/DeferGC.h>
 #include <LibJS/Runtime/Shape.h>
 #include <LibJS/Runtime/VM.h>
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Shape);
-JS_DEFINE_ALLOCATOR(PrototypeChainValidity);
+GC_DEFINE_ALLOCATOR(Shape);
+GC_DEFINE_ALLOCATOR(PrototypeChainValidity);
 
-static HashTable<JS::GCPtr<Shape>> s_all_prototype_shapes;
+static HashTable<GC::Ptr<Shape>> s_all_prototype_shapes;
 
 Shape::~Shape()
 {
@@ -21,7 +21,7 @@ Shape::~Shape()
         s_all_prototype_shapes.remove(this);
 }
 
-NonnullGCPtr<Shape> Shape::create_cacheable_dictionary_transition()
+GC::Ref<Shape> Shape::create_cacheable_dictionary_transition()
 {
     auto new_shape = heap().allocate<Shape>(m_realm);
     new_shape->m_dictionary = true;
@@ -35,7 +35,7 @@ NonnullGCPtr<Shape> Shape::create_cacheable_dictionary_transition()
     return new_shape;
 }
 
-NonnullGCPtr<Shape> Shape::create_uncacheable_dictionary_transition()
+GC::Ref<Shape> Shape::create_uncacheable_dictionary_transition()
 {
     auto new_shape = heap().allocate<Shape>(m_realm);
     new_shape->m_dictionary = true;
@@ -49,7 +49,7 @@ NonnullGCPtr<Shape> Shape::create_uncacheable_dictionary_transition()
     return new_shape;
 }
 
-GCPtr<Shape> Shape::get_or_prune_cached_forward_transition(TransitionKey const& key)
+GC::Ptr<Shape> Shape::get_or_prune_cached_forward_transition(TransitionKey const& key)
 {
     if (m_is_prototype_shape)
         return nullptr;
@@ -66,7 +66,7 @@ GCPtr<Shape> Shape::get_or_prune_cached_forward_transition(TransitionKey const&
     return it->value.ptr();
 }
 
-GCPtr<Shape> Shape::get_or_prune_cached_delete_transition(StringOrSymbol const& key)
+GC::Ptr<Shape> Shape::get_or_prune_cached_delete_transition(StringOrSymbol const& key)
 {
     if (m_is_prototype_shape)
         return nullptr;
@@ -83,7 +83,7 @@ GCPtr<Shape> Shape::get_or_prune_cached_delete_transition(StringOrSymbol const&
     return it->value.ptr();
 }
 
-GCPtr<Shape> Shape::get_or_prune_cached_prototype_transition(Object* prototype)
+GC::Ptr<Shape> Shape::get_or_prune_cached_prototype_transition(Object* prototype)
 {
     if (m_is_prototype_shape)
         return nullptr;
@@ -100,7 +100,7 @@ GCPtr<Shape> Shape::get_or_prune_cached_prototype_transition(Object* prototype)
     return it->value.ptr();
 }
 
-NonnullGCPtr<Shape> Shape::create_put_transition(StringOrSymbol const& property_key, PropertyAttributes attributes)
+GC::Ref<Shape> Shape::create_put_transition(StringOrSymbol const& property_key, PropertyAttributes attributes)
 {
     TransitionKey key { property_key, attributes };
     if (auto existing_shape = get_or_prune_cached_forward_transition(key))
@@ -115,7 +115,7 @@ NonnullGCPtr<Shape> Shape::create_put_transition(StringOrSymbol const& property_
     return new_shape;
 }
 
-NonnullGCPtr<Shape> Shape::create_configure_transition(StringOrSymbol const& property_key, PropertyAttributes attributes)
+GC::Ref<Shape> Shape::create_configure_transition(StringOrSymbol const& property_key, PropertyAttributes attributes)
 {
     TransitionKey key { property_key, attributes };
     if (auto existing_shape = get_or_prune_cached_forward_transition(key))
@@ -130,7 +130,7 @@ NonnullGCPtr<Shape> Shape::create_configure_transition(StringOrSymbol const& pro
     return new_shape;
 }
 
-NonnullGCPtr<Shape> Shape::create_prototype_transition(Object* new_prototype)
+GC::Ref<Shape> Shape::create_prototype_transition(Object* new_prototype)
 {
     if (new_prototype)
         new_prototype->convert_to_prototype_if_needed();
@@ -140,7 +140,7 @@ NonnullGCPtr<Shape> Shape::create_prototype_transition(Object* new_prototype)
     invalidate_prototype_if_needed_for_new_prototype(new_shape);
     if (!m_is_prototype_shape) {
         if (!m_prototype_transitions)
-            m_prototype_transitions = make<HashMap<GCPtr<Object>, WeakPtr<Shape>>>();
+            m_prototype_transitions = make<HashMap<GC::Ptr<Object>, WeakPtr<Shape>>>();
         m_prototype_transitions->set(new_prototype, new_shape.ptr());
     }
     return new_shape;
@@ -270,7 +270,7 @@ void Shape::ensure_property_table() const
     }
 }
 
-NonnullGCPtr<Shape> Shape::create_delete_transition(StringOrSymbol const& property_key)
+GC::Ref<Shape> Shape::create_delete_transition(StringOrSymbol const& property_key)
 {
     if (auto existing_shape = get_or_prune_cached_delete_transition(property_key))
         return *existing_shape;
@@ -319,7 +319,7 @@ void Shape::remove_property_without_transition(StringOrSymbol const& property_ke
     }
 }
 
-NonnullGCPtr<Shape> Shape::create_for_prototype(NonnullGCPtr<Realm> realm, GCPtr<Object> prototype)
+GC::Ref<Shape> Shape::create_for_prototype(GC::Ref<Realm> realm, GC::Ptr<Object> prototype)
 {
     auto new_shape = realm->heap().allocate<Shape>(realm);
     s_all_prototype_shapes.set(new_shape);
@@ -329,7 +329,7 @@ NonnullGCPtr<Shape> Shape::create_for_prototype(NonnullGCPtr<Realm> realm, GCPtr
     return new_shape;
 }
 
-NonnullGCPtr<Shape> Shape::clone_for_prototype()
+GC::Ref<Shape> Shape::clone_for_prototype()
 {
     VERIFY(!m_is_prototype_shape);
     VERIFY(!m_prototype_chain_validity);
@@ -360,7 +360,7 @@ void Shape::set_prototype_shape()
     m_prototype_chain_validity = heap().allocate<PrototypeChainValidity>();
 }
 
-void Shape::invalidate_prototype_if_needed_for_new_prototype(NonnullGCPtr<Shape> new_prototype_shape)
+void Shape::invalidate_prototype_if_needed_for_new_prototype(GC::Ref<Shape> new_prototype_shape)
 {
     if (!m_is_prototype_shape)
         return;
diff --git a/Libraries/LibJS/Runtime/Shape.h b/Libraries/LibJS/Runtime/Shape.h
index 67dec879435..f87702dab50 100644
--- a/Libraries/LibJS/Runtime/Shape.h
+++ b/Libraries/LibJS/Runtime/Shape.h
@@ -35,8 +35,8 @@ struct TransitionKey {
 };
 
 class PrototypeChainValidity final : public Cell {
-    JS_CELL(PrototypeChainValidity, Cell);
-    JS_DECLARE_ALLOCATOR(PrototypeChainValidity);
+    GC_CELL(PrototypeChainValidity, Cell);
+    GC_DECLARE_ALLOCATOR(PrototypeChainValidity);
 
 public:
     [[nodiscard]] bool is_valid() const { return m_valid; }
@@ -48,8 +48,8 @@ private:
 };
 
 class Shape final : public Cell {
-    JS_CELL(Shape, Cell);
-    JS_DECLARE_ALLOCATOR(Shape);
+    GC_CELL(Shape, Cell);
+    GC_DECLARE_ALLOCATOR(Shape);
 
 public:
     virtual ~Shape() override;
@@ -64,14 +64,14 @@ public:
         UncacheableDictionary,
     };
 
-    [[nodiscard]] NonnullGCPtr<Shape> create_put_transition(StringOrSymbol const&, PropertyAttributes attributes);
-    [[nodiscard]] NonnullGCPtr<Shape> create_configure_transition(StringOrSymbol const&, PropertyAttributes attributes);
-    [[nodiscard]] NonnullGCPtr<Shape> create_prototype_transition(Object* new_prototype);
-    [[nodiscard]] NonnullGCPtr<Shape> create_delete_transition(StringOrSymbol const&);
-    [[nodiscard]] NonnullGCPtr<Shape> create_cacheable_dictionary_transition();
-    [[nodiscard]] NonnullGCPtr<Shape> create_uncacheable_dictionary_transition();
-    [[nodiscard]] NonnullGCPtr<Shape> clone_for_prototype();
-    [[nodiscard]] static NonnullGCPtr<Shape> create_for_prototype(NonnullGCPtr<Realm>, GCPtr<Object> prototype);
+    [[nodiscard]] GC::Ref<Shape> create_put_transition(StringOrSymbol const&, PropertyAttributes attributes);
+    [[nodiscard]] GC::Ref<Shape> create_configure_transition(StringOrSymbol const&, PropertyAttributes attributes);
+    [[nodiscard]] GC::Ref<Shape> create_prototype_transition(Object* new_prototype);
+    [[nodiscard]] GC::Ref<Shape> create_delete_transition(StringOrSymbol const&);
+    [[nodiscard]] GC::Ref<Shape> create_cacheable_dictionary_transition();
+    [[nodiscard]] GC::Ref<Shape> create_uncacheable_dictionary_transition();
+    [[nodiscard]] GC::Ref<Shape> clone_for_prototype();
+    [[nodiscard]] static GC::Ref<Shape> create_for_prototype(GC::Ref<Realm>, GC::Ptr<Object> prototype);
 
     void add_property_without_transition(StringOrSymbol const&, PropertyAttributes);
     void add_property_without_transition(PropertyKey const&, PropertyAttributes);
@@ -87,7 +87,7 @@ public:
     [[nodiscard]] bool is_prototype_shape() const { return m_is_prototype_shape; }
     void set_prototype_shape();
 
-    GCPtr<PrototypeChainValidity> prototype_chain_validity() const { return m_prototype_chain_validity; }
+    GC::Ptr<PrototypeChainValidity> prototype_chain_validity() const { return m_prototype_chain_validity; }
 
     Realm& realm() const { return m_realm; }
 
@@ -111,29 +111,29 @@ private:
     Shape(Shape& previous_shape, StringOrSymbol const& property_key, TransitionType);
     Shape(Shape& previous_shape, Object* new_prototype);
 
-    void invalidate_prototype_if_needed_for_new_prototype(NonnullGCPtr<Shape> new_prototype_shape);
+    void invalidate_prototype_if_needed_for_new_prototype(GC::Ref<Shape> new_prototype_shape);
     void invalidate_all_prototype_chains_leading_to_this();
 
     virtual void visit_edges(Visitor&) override;
 
-    [[nodiscard]] GCPtr<Shape> get_or_prune_cached_forward_transition(TransitionKey const&);
-    [[nodiscard]] GCPtr<Shape> get_or_prune_cached_prototype_transition(Object* prototype);
-    [[nodiscard]] GCPtr<Shape> get_or_prune_cached_delete_transition(StringOrSymbol const&);
+    [[nodiscard]] GC::Ptr<Shape> get_or_prune_cached_forward_transition(TransitionKey const&);
+    [[nodiscard]] GC::Ptr<Shape> get_or_prune_cached_prototype_transition(Object* prototype);
+    [[nodiscard]] GC::Ptr<Shape> get_or_prune_cached_delete_transition(StringOrSymbol const&);
 
     void ensure_property_table() const;
 
-    NonnullGCPtr<Realm> m_realm;
+    GC::Ref<Realm> m_realm;
 
     mutable OwnPtr<OrderedHashMap<StringOrSymbol, PropertyMetadata>> m_property_table;
 
     OwnPtr<HashMap<TransitionKey, WeakPtr<Shape>>> m_forward_transitions;
-    OwnPtr<HashMap<GCPtr<Object>, WeakPtr<Shape>>> m_prototype_transitions;
+    OwnPtr<HashMap<GC::Ptr<Object>, WeakPtr<Shape>>> m_prototype_transitions;
     OwnPtr<HashMap<StringOrSymbol, WeakPtr<Shape>>> m_delete_transitions;
-    GCPtr<Shape> m_previous;
+    GC::Ptr<Shape> m_previous;
     StringOrSymbol m_property_key;
-    GCPtr<Object> m_prototype;
+    GC::Ptr<Object> m_prototype;
 
-    GCPtr<PrototypeChainValidity> m_prototype_chain_validity;
+    GC::Ptr<PrototypeChainValidity> m_prototype_chain_validity;
 
     u32 m_property_count { 0 };
 
diff --git a/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.cpp b/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.cpp
index c4465138a75..fe62231a703 100644
--- a/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.cpp
+++ b/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SharedArrayBufferConstructor);
+GC_DEFINE_ALLOCATOR(SharedArrayBufferConstructor);
 
 SharedArrayBufferConstructor::SharedArrayBufferConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.SharedArrayBuffer.as_string(), realm.intrinsics().function_prototype())
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> SharedArrayBufferConstructor::call()
 }
 
 // 25.2.3.1 SharedArrayBuffer ( length [ , options ] ), https://tc39.es/ecma262/#sec-sharedarraybuffer-length
-ThrowCompletionOr<NonnullGCPtr<Object>> SharedArrayBufferConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> SharedArrayBufferConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.h b/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.h
index 767cb5ee6a1..ef4016ed197 100644
--- a/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.h
+++ b/Libraries/LibJS/Runtime/SharedArrayBufferConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class SharedArrayBufferConstructor final : public NativeFunction {
     JS_OBJECT(SharedArrayBufferConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(SharedArrayBufferConstructor);
+    GC_DECLARE_ALLOCATOR(SharedArrayBufferConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~SharedArrayBufferConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit SharedArrayBufferConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.cpp b/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.cpp
index dbf7aa2992c..472770b379f 100644
--- a/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.cpp
+++ b/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SharedArrayBufferPrototype);
+GC_DEFINE_ALLOCATOR(SharedArrayBufferPrototype);
 
 SharedArrayBufferPrototype::SharedArrayBufferPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.h b/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.h
index cf18484a6b8..dc96ae2218a 100644
--- a/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.h
+++ b/Libraries/LibJS/Runtime/SharedArrayBufferPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class SharedArrayBufferPrototype final : public PrototypeObject<SharedArrayBufferPrototype, ArrayBuffer> {
     JS_PROTOTYPE_OBJECT(SharedArrayBufferPrototype, ArrayBuffer, SharedArrayBuffer);
-    JS_DECLARE_ALLOCATOR(SharedArrayBufferPrototype);
+    GC_DECLARE_ALLOCATOR(SharedArrayBufferPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/StringConstructor.cpp b/Libraries/LibJS/Runtime/StringConstructor.cpp
index abfb5efef35..1cc4a8f9006 100644
--- a/Libraries/LibJS/Runtime/StringConstructor.cpp
+++ b/Libraries/LibJS/Runtime/StringConstructor.cpp
@@ -18,7 +18,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(StringConstructor);
+GC_DEFINE_ALLOCATOR(StringConstructor);
 
 StringConstructor::StringConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.String.as_string(), realm.intrinsics().function_prototype())
@@ -62,7 +62,7 @@ ThrowCompletionOr<Value> StringConstructor::call()
 }
 
 // 22.1.1.1 String ( value ), https://tc39.es/ecma262/#sec-string-constructor-string-value
-ThrowCompletionOr<NonnullGCPtr<Object>> StringConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> StringConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
diff --git a/Libraries/LibJS/Runtime/StringConstructor.h b/Libraries/LibJS/Runtime/StringConstructor.h
index 11b9d2c4cde..785c2d714b6 100644
--- a/Libraries/LibJS/Runtime/StringConstructor.h
+++ b/Libraries/LibJS/Runtime/StringConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class StringConstructor final : public NativeFunction {
     JS_OBJECT(StringConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(StringConstructor);
+    GC_DECLARE_ALLOCATOR(StringConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~StringConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit StringConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/StringIterator.cpp b/Libraries/LibJS/Runtime/StringIterator.cpp
index 3da43869a47..651e2e25d1e 100644
--- a/Libraries/LibJS/Runtime/StringIterator.cpp
+++ b/Libraries/LibJS/Runtime/StringIterator.cpp
@@ -10,9 +10,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(StringIterator);
+GC_DEFINE_ALLOCATOR(StringIterator);
 
-NonnullGCPtr<StringIterator> StringIterator::create(Realm& realm, String string)
+GC::Ref<StringIterator> StringIterator::create(Realm& realm, String string)
 {
     return realm.create<StringIterator>(move(string), realm.intrinsics().string_iterator_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/StringIterator.h b/Libraries/LibJS/Runtime/StringIterator.h
index 1aa833c5030..dbb3c10663b 100644
--- a/Libraries/LibJS/Runtime/StringIterator.h
+++ b/Libraries/LibJS/Runtime/StringIterator.h
@@ -14,10 +14,10 @@ namespace JS {
 
 class StringIterator final : public Object {
     JS_OBJECT(StringIterator, Object);
-    JS_DECLARE_ALLOCATOR(StringIterator);
+    GC_DECLARE_ALLOCATOR(StringIterator);
 
 public:
-    static NonnullGCPtr<StringIterator> create(Realm&, String string);
+    static GC::Ref<StringIterator> create(Realm&, String string);
 
     virtual ~StringIterator() override = default;
 
diff --git a/Libraries/LibJS/Runtime/StringIteratorPrototype.cpp b/Libraries/LibJS/Runtime/StringIteratorPrototype.cpp
index 3691aa80917..56d1378a152 100644
--- a/Libraries/LibJS/Runtime/StringIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/StringIteratorPrototype.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(StringIteratorPrototype);
+GC_DEFINE_ALLOCATOR(StringIteratorPrototype);
 
 StringIteratorPrototype::StringIteratorPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().iterator_prototype())
diff --git a/Libraries/LibJS/Runtime/StringIteratorPrototype.h b/Libraries/LibJS/Runtime/StringIteratorPrototype.h
index 3f865ee96b2..f59c548ba1c 100644
--- a/Libraries/LibJS/Runtime/StringIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/StringIteratorPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class StringIteratorPrototype final : public PrototypeObject<StringIteratorPrototype, StringIterator> {
     JS_PROTOTYPE_OBJECT(StringIteratorPrototype, StringIterator, StringIterator);
-    JS_DECLARE_ALLOCATOR(StringIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(StringIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/StringObject.cpp b/Libraries/LibJS/Runtime/StringObject.cpp
index 0983ac673c5..ca1e32e5265 100644
--- a/Libraries/LibJS/Runtime/StringObject.cpp
+++ b/Libraries/LibJS/Runtime/StringObject.cpp
@@ -14,10 +14,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(StringObject);
+GC_DEFINE_ALLOCATOR(StringObject);
 
 // 10.4.3.4 StringCreate ( value, prototype ), https://tc39.es/ecma262/#sec-stringcreate
-NonnullGCPtr<StringObject> StringObject::create(Realm& realm, PrimitiveString& primitive_string, Object& prototype)
+GC::Ref<StringObject> StringObject::create(Realm& realm, PrimitiveString& primitive_string, Object& prototype)
 {
     // 1. Let S be MakeBasicObject(« [[Prototype]], [[Extensible]], [[StringData]] »).
     // 2. Set S.[[Prototype]] to prototype.
@@ -128,12 +128,12 @@ ThrowCompletionOr<bool> StringObject::internal_define_own_property(PropertyKey c
 }
 
 // 10.4.3.3 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-string-exotic-objects-ownpropertykeys
-ThrowCompletionOr<MarkedVector<Value>> StringObject::internal_own_property_keys() const
+ThrowCompletionOr<GC::MarkedVector<Value>> StringObject::internal_own_property_keys() const
 {
     auto& vm = this->vm();
 
     // 1. Let keys be a new empty List.
-    auto keys = MarkedVector<Value> { heap() };
+    auto keys = GC::MarkedVector<Value> { heap() };
 
     // 2. Let str be O.[[StringData]].
     auto str = m_string->utf16_string_view();
diff --git a/Libraries/LibJS/Runtime/StringObject.h b/Libraries/LibJS/Runtime/StringObject.h
index a0fe580713a..d6ca35b1523 100644
--- a/Libraries/LibJS/Runtime/StringObject.h
+++ b/Libraries/LibJS/Runtime/StringObject.h
@@ -12,10 +12,10 @@ namespace JS {
 
 class StringObject : public Object {
     JS_OBJECT(StringObject, Object);
-    JS_DECLARE_ALLOCATOR(StringObject);
+    GC_DECLARE_ALLOCATOR(StringObject);
 
 public:
-    [[nodiscard]] static NonnullGCPtr<StringObject> create(Realm&, PrimitiveString&, Object& prototype);
+    [[nodiscard]] static GC::Ref<StringObject> create(Realm&, PrimitiveString&, Object& prototype);
 
     virtual void initialize(Realm&) override;
     virtual ~StringObject() override = default;
@@ -29,12 +29,12 @@ protected:
 private:
     virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const override;
     virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr) override;
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const override;
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
 
     virtual bool is_string_object() const final { return true; }
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<PrimitiveString> m_string;
+    GC::Ref<PrimitiveString> m_string;
 };
 
 template<>
diff --git a/Libraries/LibJS/Runtime/StringPrototype.cpp b/Libraries/LibJS/Runtime/StringPrototype.cpp
index 477ec79b1b9..efe8a8b24cf 100644
--- a/Libraries/LibJS/Runtime/StringPrototype.cpp
+++ b/Libraries/LibJS/Runtime/StringPrototype.cpp
@@ -9,7 +9,7 @@
 #include <AK/Function.h>
 #include <AK/StringBuilder.h>
 #include <AK/Utf16View.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/AbstractOperations.h>
 #include <LibJS/Runtime/Array.h>
 #include <LibJS/Runtime/Completion.h>
@@ -34,7 +34,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(StringPrototype);
+GC_DEFINE_ALLOCATOR(StringPrototype);
 
 static ThrowCompletionOr<String> utf8_string_from(VM& vm)
 {
@@ -210,7 +210,7 @@ void StringPrototype::initialize(Realm& realm)
 }
 
 // thisStringValue ( value ), https://tc39.es/ecma262/#thisstringvalue
-static ThrowCompletionOr<NonnullGCPtr<PrimitiveString>> this_string_value(VM& vm, Value value)
+static ThrowCompletionOr<GC::Ref<PrimitiveString>> this_string_value(VM& vm, Value value)
 {
     // 1. If value is a String, return value.
     if (value.is_string())
diff --git a/Libraries/LibJS/Runtime/StringPrototype.h b/Libraries/LibJS/Runtime/StringPrototype.h
index 01cd295ea7d..b8f1375eacc 100644
--- a/Libraries/LibJS/Runtime/StringPrototype.h
+++ b/Libraries/LibJS/Runtime/StringPrototype.h
@@ -25,7 +25,7 @@ ThrowCompletionOr<String> trim_string(VM&, Value string, TrimMode where);
 
 class StringPrototype final : public StringObject {
     JS_OBJECT(StringPrototype, StringObject);
-    JS_DECLARE_ALLOCATOR(StringPrototype);
+    GC_DECLARE_ALLOCATOR(StringPrototype);
 
 public:
     explicit StringPrototype(Realm&);
diff --git a/Libraries/LibJS/Runtime/SuppressedError.cpp b/Libraries/LibJS/Runtime/SuppressedError.cpp
index ace7f592bbf..b168c470df5 100644
--- a/Libraries/LibJS/Runtime/SuppressedError.cpp
+++ b/Libraries/LibJS/Runtime/SuppressedError.cpp
@@ -10,9 +10,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SuppressedError);
+GC_DEFINE_ALLOCATOR(SuppressedError);
 
-NonnullGCPtr<SuppressedError> SuppressedError::create(Realm& realm)
+GC::Ref<SuppressedError> SuppressedError::create(Realm& realm)
 {
     return realm.create<SuppressedError>(realm.intrinsics().suppressed_error_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/SuppressedError.h b/Libraries/LibJS/Runtime/SuppressedError.h
index ca52ba97982..6061d8468b7 100644
--- a/Libraries/LibJS/Runtime/SuppressedError.h
+++ b/Libraries/LibJS/Runtime/SuppressedError.h
@@ -12,10 +12,10 @@ namespace JS {
 
 class SuppressedError : public Error {
     JS_OBJECT(SuppressedError, Error);
-    JS_DECLARE_ALLOCATOR(SuppressedError);
+    GC_DECLARE_ALLOCATOR(SuppressedError);
 
 public:
-    static NonnullGCPtr<SuppressedError> create(Realm&);
+    static GC::Ref<SuppressedError> create(Realm&);
     virtual ~SuppressedError() override = default;
 
 private:
diff --git a/Libraries/LibJS/Runtime/SuppressedErrorConstructor.cpp b/Libraries/LibJS/Runtime/SuppressedErrorConstructor.cpp
index baf180925f1..0010790962a 100644
--- a/Libraries/LibJS/Runtime/SuppressedErrorConstructor.cpp
+++ b/Libraries/LibJS/Runtime/SuppressedErrorConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SuppressedErrorConstructor);
+GC_DEFINE_ALLOCATOR(SuppressedErrorConstructor);
 
 SuppressedErrorConstructor::SuppressedErrorConstructor(Realm& realm)
     : NativeFunction(static_cast<Object&>(realm.intrinsics().error_constructor()))
@@ -40,7 +40,7 @@ ThrowCompletionOr<Value> SuppressedErrorConstructor::call()
 }
 
 // 10.1.4.1.1 SuppressedError ( error, suppressed, message [ , options ] ), https://tc39.es/proposal-explicit-resource-management/#sec-suppressederror
-ThrowCompletionOr<NonnullGCPtr<Object>> SuppressedErrorConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> SuppressedErrorConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto error = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/SuppressedErrorConstructor.h b/Libraries/LibJS/Runtime/SuppressedErrorConstructor.h
index 591a5d3acbb..276efb6f6a6 100644
--- a/Libraries/LibJS/Runtime/SuppressedErrorConstructor.h
+++ b/Libraries/LibJS/Runtime/SuppressedErrorConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class SuppressedErrorConstructor final : public NativeFunction {
     JS_OBJECT(SuppressedErrorConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(SuppressedErrorConstructor);
+    GC_DECLARE_ALLOCATOR(SuppressedErrorConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~SuppressedErrorConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit SuppressedErrorConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/SuppressedErrorPrototype.cpp b/Libraries/LibJS/Runtime/SuppressedErrorPrototype.cpp
index 5de8c162798..65da8d24556 100644
--- a/Libraries/LibJS/Runtime/SuppressedErrorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/SuppressedErrorPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SuppressedErrorPrototype);
+GC_DEFINE_ALLOCATOR(SuppressedErrorPrototype);
 
 SuppressedErrorPrototype::SuppressedErrorPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().error_prototype())
diff --git a/Libraries/LibJS/Runtime/SuppressedErrorPrototype.h b/Libraries/LibJS/Runtime/SuppressedErrorPrototype.h
index 7f949c2e243..6a55ac43262 100644
--- a/Libraries/LibJS/Runtime/SuppressedErrorPrototype.h
+++ b/Libraries/LibJS/Runtime/SuppressedErrorPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class SuppressedErrorPrototype final : public Object {
     JS_OBJECT(SuppressedErrorPrototype, Object);
-    JS_DECLARE_ALLOCATOR(SuppressedErrorPrototype);
+    GC_DECLARE_ALLOCATOR(SuppressedErrorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Symbol.cpp b/Libraries/LibJS/Runtime/Symbol.cpp
index c22f5c2c7b5..b98fa8743d9 100644
--- a/Libraries/LibJS/Runtime/Symbol.cpp
+++ b/Libraries/LibJS/Runtime/Symbol.cpp
@@ -5,13 +5,13 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Symbol.h>
 #include <LibJS/Runtime/VM.h>
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Symbol);
+GC_DEFINE_ALLOCATOR(Symbol);
 
 Symbol::Symbol(Optional<String> description, bool is_global)
     : m_description(move(description))
@@ -19,7 +19,7 @@ Symbol::Symbol(Optional<String> description, bool is_global)
 {
 }
 
-NonnullGCPtr<Symbol> Symbol::create(VM& vm, Optional<String> description, bool is_global)
+GC::Ref<Symbol> Symbol::create(VM& vm, Optional<String> description, bool is_global)
 {
     return vm.heap().allocate<Symbol>(move(description), is_global);
 }
diff --git a/Libraries/LibJS/Runtime/Symbol.h b/Libraries/LibJS/Runtime/Symbol.h
index 440d75169dd..eb7e2d526b3 100644
--- a/Libraries/LibJS/Runtime/Symbol.h
+++ b/Libraries/LibJS/Runtime/Symbol.h
@@ -13,11 +13,11 @@
 namespace JS {
 
 class Symbol final : public Cell {
-    JS_CELL(Symbol, Cell);
-    JS_DECLARE_ALLOCATOR(Symbol);
+    GC_CELL(Symbol, Cell);
+    GC_DECLARE_ALLOCATOR(Symbol);
 
 public:
-    [[nodiscard]] static NonnullGCPtr<Symbol> create(VM&, Optional<String> description, bool is_global);
+    [[nodiscard]] static GC::Ref<Symbol> create(VM&, Optional<String> description, bool is_global);
 
     virtual ~Symbol() = default;
 
diff --git a/Libraries/LibJS/Runtime/SymbolConstructor.cpp b/Libraries/LibJS/Runtime/SymbolConstructor.cpp
index 8b6a3ebf846..0c3ff38a919 100644
--- a/Libraries/LibJS/Runtime/SymbolConstructor.cpp
+++ b/Libraries/LibJS/Runtime/SymbolConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SymbolConstructor);
+GC_DEFINE_ALLOCATOR(SymbolConstructor);
 
 SymbolConstructor::SymbolConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.Symbol.as_string(), realm.intrinsics().function_prototype())
@@ -55,7 +55,7 @@ ThrowCompletionOr<Value> SymbolConstructor::call()
 }
 
 // 20.4.1.1 Symbol ( [ description ] ), https://tc39.es/ecma262/#sec-symbol-description
-ThrowCompletionOr<NonnullGCPtr<Object>> SymbolConstructor::construct(FunctionObject&)
+ThrowCompletionOr<GC::Ref<Object>> SymbolConstructor::construct(FunctionObject&)
 {
     // 1. If NewTarget is not undefined, throw a TypeError exception.
     return vm().throw_completion<TypeError>(ErrorType::NotAConstructor, "Symbol");
diff --git a/Libraries/LibJS/Runtime/SymbolConstructor.h b/Libraries/LibJS/Runtime/SymbolConstructor.h
index c9943c3ea6a..7ef26894e7f 100644
--- a/Libraries/LibJS/Runtime/SymbolConstructor.h
+++ b/Libraries/LibJS/Runtime/SymbolConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class SymbolConstructor final : public NativeFunction {
     JS_OBJECT(SymbolConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(SymbolConstructor);
+    GC_DECLARE_ALLOCATOR(SymbolConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~SymbolConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit SymbolConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/SymbolObject.cpp b/Libraries/LibJS/Runtime/SymbolObject.cpp
index 00bf20cf02f..a78b87764dd 100644
--- a/Libraries/LibJS/Runtime/SymbolObject.cpp
+++ b/Libraries/LibJS/Runtime/SymbolObject.cpp
@@ -10,9 +10,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SymbolObject);
+GC_DEFINE_ALLOCATOR(SymbolObject);
 
-NonnullGCPtr<SymbolObject> SymbolObject::create(Realm& realm, Symbol& primitive_symbol)
+GC::Ref<SymbolObject> SymbolObject::create(Realm& realm, Symbol& primitive_symbol)
 {
     return realm.create<SymbolObject>(primitive_symbol, realm.intrinsics().symbol_prototype());
 }
diff --git a/Libraries/LibJS/Runtime/SymbolObject.h b/Libraries/LibJS/Runtime/SymbolObject.h
index dfe5b4fcce8..78514af39a3 100644
--- a/Libraries/LibJS/Runtime/SymbolObject.h
+++ b/Libraries/LibJS/Runtime/SymbolObject.h
@@ -13,10 +13,10 @@ namespace JS {
 
 class SymbolObject : public Object {
     JS_OBJECT(SymbolObject, Object);
-    JS_DECLARE_ALLOCATOR(SymbolObject);
+    GC_DECLARE_ALLOCATOR(SymbolObject);
 
 public:
-    static NonnullGCPtr<SymbolObject> create(Realm&, Symbol&);
+    static GC::Ref<SymbolObject> create(Realm&, Symbol&);
 
     virtual ~SymbolObject() override = default;
 
@@ -28,7 +28,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    NonnullGCPtr<Symbol> m_symbol;
+    GC::Ref<Symbol> m_symbol;
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/SymbolPrototype.cpp b/Libraries/LibJS/Runtime/SymbolPrototype.cpp
index 9b9042dd1b8..be686eb3d8b 100644
--- a/Libraries/LibJS/Runtime/SymbolPrototype.cpp
+++ b/Libraries/LibJS/Runtime/SymbolPrototype.cpp
@@ -18,7 +18,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SymbolPrototype);
+GC_DEFINE_ALLOCATOR(SymbolPrototype);
 
 SymbolPrototype::SymbolPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
@@ -40,7 +40,7 @@ void SymbolPrototype::initialize(Realm& realm)
 }
 
 // thisSymbolValue ( value ), https://tc39.es/ecma262/#thissymbolvalue
-static ThrowCompletionOr<NonnullGCPtr<Symbol>> this_symbol_value(VM& vm, Value value)
+static ThrowCompletionOr<GC::Ref<Symbol>> this_symbol_value(VM& vm, Value value)
 {
     // 1. If value is a Symbol, return value.
     if (value.is_symbol())
diff --git a/Libraries/LibJS/Runtime/SymbolPrototype.h b/Libraries/LibJS/Runtime/SymbolPrototype.h
index 707a6c76e44..0f097aaf104 100644
--- a/Libraries/LibJS/Runtime/SymbolPrototype.h
+++ b/Libraries/LibJS/Runtime/SymbolPrototype.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class SymbolPrototype final : public Object {
     JS_OBJECT(SymbolPrototype, Object);
-    JS_DECLARE_ALLOCATOR(SymbolPrototype);
+    GC_DECLARE_ALLOCATOR(SymbolPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp b/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp
index 0c722af5af4..5072e266ab0 100644
--- a/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/AbstractOperations.cpp
@@ -40,13 +40,13 @@ static Optional<OptionType> to_option_type(Value value)
 }
 
 // 13.1 IterableToListOfType ( items, elementTypes ), https://tc39.es/proposal-temporal/#sec-iterabletolistoftype
-ThrowCompletionOr<MarkedVector<Value>> iterable_to_list_of_type(VM& vm, Value items, Vector<OptionType> const& element_types)
+ThrowCompletionOr<GC::MarkedVector<Value>> iterable_to_list_of_type(VM& vm, Value items, Vector<OptionType> const& element_types)
 {
     // 1. Let iteratorRecord be ? GetIterator(items, sync).
     auto iterator_record = TRY(get_iterator(vm, items, IteratorHint::Sync));
 
     // 2. Let values be a new empty List.
-    MarkedVector<Value> values(vm.heap());
+    GC::MarkedVector<Value> values(vm.heap());
 
     // 3. Let next be true.
     auto next = true;
@@ -581,7 +581,7 @@ ThrowCompletionOr<RelativeTo> to_relative_temporal_object(VM& vm, Object const&
             auto& zoned_relative_to = static_cast<ZonedDateTime&>(value_object);
 
             // i. Let timeZoneRec be ? CreateTimeZoneMethodsRecord(value.[[TimeZone]], « GET-OFFSET-NANOSECONDS-FOR, GET-POSSIBLE-INSTANTS-FOR »).
-            auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { zoned_relative_to.time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
+            auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { zoned_relative_to.time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
 
             // ii. Return the Record { [[PlainRelativeTo]]: undefined, [[ZonedRelativeTo]]: value, [[TimeZoneRec]]: timeZoneRec }.
             return RelativeTo {
@@ -741,7 +741,7 @@ ThrowCompletionOr<RelativeTo> to_relative_temporal_object(VM& vm, Object const&
     auto const* epoch_nanoseconds = TRY(interpret_iso_date_time_offset(vm, result.year, result.month, result.day, result.hour, result.minute, result.second, result.millisecond, result.microsecond, result.nanosecond, offset_behavior, offset_ns, time_zone, "compatible"sv, "reject"sv, match_behavior));
 
     // 12. Return ! CreateTemporalZonedDateTime(epochNanoseconds, timeZone, calendar).
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
     auto* zoned_relative_to = MUST(create_temporal_zoned_date_time(vm, *epoch_nanoseconds, time_zone.as_object(), *calendar));
     return RelativeTo {
         .plain_relative_to = {},
diff --git a/Libraries/LibJS/Runtime/Temporal/AbstractOperations.h b/Libraries/LibJS/Runtime/Temporal/AbstractOperations.h
index 6e0a432bbe6..3007a33bf87 100644
--- a/Libraries/LibJS/Runtime/Temporal/AbstractOperations.h
+++ b/Libraries/LibJS/Runtime/Temporal/AbstractOperations.h
@@ -124,7 +124,7 @@ struct DifferenceSettings {
     String largest_unit;
     String rounding_mode;
     u64 rounding_increment;
-    NonnullGCPtr<Object> options;
+    GC::Ref<Object> options;
 };
 
 struct TemporalUnitRequired { };
@@ -134,7 +134,7 @@ struct GetOptionRequired { };
 using OptionDefault = Variant<GetOptionRequired, Empty, bool, StringView, double>;
 using TemporalUnitDefault = Variant<TemporalUnitRequired, Optional<StringView>>;
 
-ThrowCompletionOr<MarkedVector<Value>> iterable_to_list_of_type(VM&, Value items, Vector<OptionType> const& element_types);
+ThrowCompletionOr<GC::MarkedVector<Value>> iterable_to_list_of_type(VM&, Value items, Vector<OptionType> const& element_types);
 ThrowCompletionOr<Object*> get_options_object(VM&, Value options);
 ThrowCompletionOr<Value> get_option(VM&, Object const& options, PropertyKey const& property, OptionType type, ReadonlySpan<StringView> values, OptionDefault const&);
 ThrowCompletionOr<String> to_temporal_overflow(VM&, Object const* options);
@@ -151,8 +151,8 @@ ThrowCompletionOr<SecondsStringPrecision> to_seconds_string_precision_record(VM&
 ThrowCompletionOr<Optional<String>> get_temporal_unit(VM&, Object const& normalized_options, PropertyKey const&, UnitGroup, TemporalUnitDefault const& default_, Vector<StringView> const& extra_values = {});
 
 struct RelativeTo {
-    GCPtr<PlainDate> plain_relative_to;         // [[PlainRelativeTo]]
-    GCPtr<ZonedDateTime> zoned_relative_to;     // [[ZonedRelativeTo]]
+    GC::Ptr<PlainDate> plain_relative_to;       // [[PlainRelativeTo]]
+    GC::Ptr<ZonedDateTime> zoned_relative_to;   // [[ZonedRelativeTo]]
     Optional<TimeZoneMethods> time_zone_record; // [[TimeZoneRec]]
 };
 ThrowCompletionOr<RelativeTo> to_relative_temporal_object(VM&, Object const& options);
diff --git a/Libraries/LibJS/Runtime/Temporal/Calendar.cpp b/Libraries/LibJS/Runtime/Temporal/Calendar.cpp
index 40394c6866e..d9e6bc198cd 100644
--- a/Libraries/LibJS/Runtime/Temporal/Calendar.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/Calendar.cpp
@@ -28,7 +28,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(Calendar);
+GC_DEFINE_ALLOCATOR(Calendar);
 
 // 12 Temporal.Calendar Objects, https://tc39.es/proposal-temporal/#sec-temporal-calendar-objects
 Calendar::Calendar(String identifier, Object& prototype)
@@ -69,7 +69,7 @@ ReadonlySpan<StringView> available_calendars()
 }
 
 // 12.2.2 CreateCalendarMethodsRecord ( calendar, methods ), https://tc39.es/proposal-temporal/#sec-temporal-createcalendarmethodsrecord
-ThrowCompletionOr<CalendarMethods> create_calendar_methods_record(VM& vm, Variant<String, NonnullGCPtr<Object>> calendar, ReadonlySpan<CalendarMethod> methods)
+ThrowCompletionOr<CalendarMethods> create_calendar_methods_record(VM& vm, Variant<String, GC::Ref<Object>> calendar, ReadonlySpan<CalendarMethod> methods)
 {
     // 1. Let record be the Calendar Methods Record { [[Receiver]]: calendar, [[DateAdd]]: undefined, [[DateFromFields]]: undefined, [[DateUntil]]: undefined, [[Day]]: undefined, [[Fields]]: undefined, [[MergeFields]]: undefined, [[MonthDayFromFields]]: undefined, [[YearMonthFromFields]]: undefined }.
     CalendarMethods record {
@@ -94,17 +94,17 @@ ThrowCompletionOr<CalendarMethods> create_calendar_methods_record(VM& vm, Varian
     return record;
 }
 
-ThrowCompletionOr<Optional<CalendarMethods>> create_calendar_methods_record_from_relative_to(VM& vm, GCPtr<PlainDate> plain_relative_to, GCPtr<ZonedDateTime> zoned_relative_to, ReadonlySpan<CalendarMethod> methods)
+ThrowCompletionOr<Optional<CalendarMethods>> create_calendar_methods_record_from_relative_to(VM& vm, GC::Ptr<PlainDate> plain_relative_to, GC::Ptr<ZonedDateTime> zoned_relative_to, ReadonlySpan<CalendarMethod> methods)
 {
-    // FIXME: The casts to NonnullGCPtr<Object> should not be here, and can be fixed once PlainDate & ZonedDateTime have the updated type in the [[Calendar]] slot.
+    // FIXME: The casts to GC::Ref<Object> should not be here, and can be fixed once PlainDate & ZonedDateTime have the updated type in the [[Calendar]] slot.
 
     // 1. If zonedRelativeTo is not undefined, return ? CreateCalendarMethodsRecord(zonedRelativeTo.[[Calendar]], methods).
     if (zoned_relative_to)
-        return TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { zoned_relative_to->calendar() }, methods));
+        return TRY(create_calendar_methods_record(vm, GC::Ref<Object> { zoned_relative_to->calendar() }, methods));
 
     // 2. If plainRelativeTo is not undefined, return ? CreateCalendarMethodsRecord(plainRelativeTo.[[Calendar]], methods).
     if (plain_relative_to)
-        return TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { plain_relative_to->calendar() }, methods));
+        return TRY(create_calendar_methods_record(vm, GC::Ref<Object> { plain_relative_to->calendar() }, methods));
 
     // 3. Return undefined.
     return OptionalNone {};
@@ -172,7 +172,7 @@ ThrowCompletionOr<void> calendar_methods_record_lookup(VM& vm, CalendarMethods&
             const auto& calendar_prototype = *realm.intrinsics().temporal_calendar_prototype();                         \
             calendar_record.snake_name = calendar_prototype.get_without_side_effects(vm.names.camelName).as_function(); \
         } else {                                                                                                        \
-            Value calendar { calendar_record.receiver.get<NonnullGCPtr<Object>>() };                                    \
+            Value calendar { calendar_record.receiver.get<GC::Ref<Object>>() };                                         \
             calendar_record.snake_name = TRY(calendar.get_method(vm, vm.names.camelName));                              \
             if (!calendar_record.snake_name)                                                                            \
                 return vm.throw_completion<TypeError>(ErrorType::IsUndefined, #camelName##sv);                          \
@@ -239,11 +239,11 @@ ThrowCompletionOr<Value> calendar_methods_record_call(VM& vm, CalendarMethods co
     // 2. Let receiver be calendarRec.[[Receiver]].
     // 3. If CalendarMethodsRecordIsBuiltin(calendarRec) is true, then
     //     a. Set receiver to ! CreateTemporalCalendar(calendarRec.[[Receiver]]).
-    GCPtr<Object> receiver;
+    GC::Ptr<Object> receiver;
     if (calendar_methods_record_is_builtin(calendar_record))
         receiver = MUST(create_temporal_calendar(vm, calendar_record.receiver.get<String>()));
     else
-        receiver = calendar_record.receiver.get<NonnullGCPtr<Object>>();
+        receiver = calendar_record.receiver.get<GC::Ref<Object>>();
 
     // 4. If methodName is DATE-ADD, then
     //     a. Return ? Call(calendarRec.[[DateAdd]], receiver, arguments).
@@ -392,7 +392,7 @@ ThrowCompletionOr<PlainDate*> calendar_date_add(VM& vm, Object& calendar, Value
 }
 
 // 12.2.7 CalendarDateUntil ( calendar, one, two, options [ , dateUntil ] ), https://tc39.es/proposal-temporal/#sec-temporal-calendardateuntil
-ThrowCompletionOr<NonnullGCPtr<Duration>> calendar_date_until(VM& vm, CalendarMethods const& calendar_record, Value one, Value two, Object const& options)
+ThrowCompletionOr<GC::Ref<Duration>> calendar_date_until(VM& vm, CalendarMethods const& calendar_record, Value one, Value two, Object const& options)
 {
     // 1. Let duration be ? CalendarMethodsRecordCall(calendarRec, DATE-UNTIL, « one, two, options »).
     auto duration = TRY(calendar_methods_record_call(vm, calendar_record, CalendarMethod::DateUntil, Vector<Value> { one, two, &options }));
diff --git a/Libraries/LibJS/Runtime/Temporal/Calendar.h b/Libraries/LibJS/Runtime/Temporal/Calendar.h
index afca5f12592..2052186dc80 100644
--- a/Libraries/LibJS/Runtime/Temporal/Calendar.h
+++ b/Libraries/LibJS/Runtime/Temporal/Calendar.h
@@ -19,7 +19,7 @@ namespace JS::Temporal {
 
 class Calendar final : public Object {
     JS_OBJECT(Calendar, Object);
-    JS_DECLARE_ALLOCATOR(Calendar);
+    GC_DECLARE_ALLOCATOR(Calendar);
 
 public:
     virtual ~Calendar() override = default;
@@ -47,7 +47,7 @@ Calendar* get_iso8601_calendar(VM&);
 ThrowCompletionOr<Vector<String>> calendar_fields(VM&, Object& calendar, Vector<StringView> const& field_names);
 ThrowCompletionOr<Object*> calendar_merge_fields(VM&, Object& calendar, Object& fields, Object& additional_fields);
 ThrowCompletionOr<PlainDate*> calendar_date_add(VM&, Object& calendar, Value date, Duration&, Object* options = nullptr, FunctionObject* date_add = nullptr);
-ThrowCompletionOr<NonnullGCPtr<Duration>> calendar_date_until(VM&, CalendarMethods const&, Value one, Value two, Object const& options);
+ThrowCompletionOr<GC::Ref<Duration>> calendar_date_until(VM&, CalendarMethods const&, Value one, Value two, Object const& options);
 ThrowCompletionOr<double> calendar_year(VM&, Object& calendar, Object& date_like);
 ThrowCompletionOr<double> calendar_month(VM&, Object& calendar, Object& date_like);
 ThrowCompletionOr<String> calendar_month_code(VM&, Object& calendar, Object& date_like);
@@ -87,31 +87,31 @@ u8 to_iso_day_of_week(i32 year, u8 month, u8 day);
 // https://tc39.es/proposal-temporal/#table-temporal-calendar-methods-record-fields
 struct CalendarMethods {
     // The calendar object, or a string indicating a built-in time zone.
-    Variant<String, NonnullGCPtr<Object>> receiver; // [[Reciever]]
+    Variant<String, GC::Ref<Object>> receiver; // [[Reciever]]
 
     // The calendar's dateAdd method. For a built-in calendar this is always %Temporal.Calendar.prototype.dateAdd%.
-    GCPtr<FunctionObject> date_add; // [[DateAdd]]
+    GC::Ptr<FunctionObject> date_add; // [[DateAdd]]
 
     // The calendar's dateFromFields method. For a built-in calendar this is always %Temporal.Calendar.prototype.dateFromFields%.
-    GCPtr<FunctionObject> date_from_fields; // [[DateFromFields]]
+    GC::Ptr<FunctionObject> date_from_fields; // [[DateFromFields]]
 
     // The calendar's dateUntil method. For a built-in calendar this is always %Temporal.Calendar.prototype.dateUntil%.
-    GCPtr<FunctionObject> date_until; // [[DateUntil]]
+    GC::Ptr<FunctionObject> date_until; // [[DateUntil]]
 
     // The calendar's day method. For a built-in calendar this is always %Temporal.Calendar.prototype.day%.
-    GCPtr<FunctionObject> day; // [[Day]]
+    GC::Ptr<FunctionObject> day; // [[Day]]
 
     // The calendar's fields method. For a built-in calendar this is always %Temporal.Calendar.prototype.fields%.
-    GCPtr<FunctionObject> fields; // [[Fields]]
+    GC::Ptr<FunctionObject> fields; // [[Fields]]
 
     // The calendar's mergeFields method. For a built-in calendar this is always %Temporal.Calendar.prototype.mergeFields%.
-    GCPtr<FunctionObject> merge_fields; // [[MergeFields]]
+    GC::Ptr<FunctionObject> merge_fields; // [[MergeFields]]
 
     // The calendar's monthDayFromFields method. For a built-in calendar this is always %Temporal.Calendar.prototype.monthDayFromFields%.
-    GCPtr<FunctionObject> month_day_from_fields; // [[MonthDayFromFields]]
+    GC::Ptr<FunctionObject> month_day_from_fields; // [[MonthDayFromFields]]
 
     // The calendar's yearMonthFromFields method. For a built-in calendar this is always %Temporal.Calendar.prototype.yearMonthFromFields%.
-    GCPtr<FunctionObject> year_month_from_fields; // [[YearMonthFromFields]]
+    GC::Ptr<FunctionObject> year_month_from_fields; // [[YearMonthFromFields]]
 };
 
 #define JS_ENUMERATE_CALENDAR_METHODS                                             \
@@ -132,8 +132,8 @@ enum class CalendarMethod {
 };
 
 ThrowCompletionOr<void> calendar_methods_record_lookup(VM&, CalendarMethods&, CalendarMethod);
-ThrowCompletionOr<CalendarMethods> create_calendar_methods_record(VM&, Variant<String, NonnullGCPtr<Object>> calendar, ReadonlySpan<CalendarMethod>);
-ThrowCompletionOr<Optional<CalendarMethods>> create_calendar_methods_record_from_relative_to(VM&, GCPtr<PlainDate>, GCPtr<ZonedDateTime>, ReadonlySpan<CalendarMethod>);
+ThrowCompletionOr<CalendarMethods> create_calendar_methods_record(VM&, Variant<String, GC::Ref<Object>> calendar, ReadonlySpan<CalendarMethod>);
+ThrowCompletionOr<Optional<CalendarMethods>> create_calendar_methods_record_from_relative_to(VM&, GC::Ptr<PlainDate>, GC::Ptr<ZonedDateTime>, ReadonlySpan<CalendarMethod>);
 bool calendar_methods_record_has_looked_up(CalendarMethods const&, CalendarMethod);
 bool calendar_methods_record_is_builtin(CalendarMethods const&);
 ThrowCompletionOr<Value> calendar_methods_record_call(VM&, CalendarMethods const&, CalendarMethod, ReadonlySpan<Value> arguments);
diff --git a/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.cpp
index 0dfd873477f..9013d450d0e 100644
--- a/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.cpp
@@ -10,7 +10,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(CalendarConstructor);
+GC_DEFINE_ALLOCATOR(CalendarConstructor);
 
 // 12.2 The Temporal.Calendar Constructor, https://tc39.es/proposal-temporal/#sec-temporal-calendar-constructor
 CalendarConstructor::CalendarConstructor(Realm& realm)
@@ -44,7 +44,7 @@ ThrowCompletionOr<Value> CalendarConstructor::call()
 }
 
 // 12.2.1 Temporal.Calendar ( id ), https://tc39.es/proposal-temporal/#sec-temporal.calendar
-ThrowCompletionOr<NonnullGCPtr<Object>> CalendarConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> CalendarConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.h b/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.h
index c37e1f088d5..7222f8d51ea 100644
--- a/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/CalendarConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class CalendarConstructor final : public NativeFunction {
     JS_OBJECT(CalendarConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(CalendarConstructor);
+    GC_DECLARE_ALLOCATOR(CalendarConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~CalendarConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit CalendarConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.cpp
index 9b4e5bf9ea2..deb9343c260 100644
--- a/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.cpp
@@ -19,7 +19,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(CalendarPrototype);
+GC_DEFINE_ALLOCATOR(CalendarPrototype);
 
 [[nodiscard]] static i32 iso_year(Object& temporal_object);
 [[nodiscard]] static u8 iso_month(Object& temporal_object);
@@ -537,7 +537,7 @@ JS_DEFINE_NATIVE_FUNCTION(CalendarPrototype::fields)
     auto iterator_record = TRY(get_iterator(vm, fields, IteratorHint::Sync));
 
     // 5. Let fieldNames be a new empty List.
-    auto field_names = MarkedVector<Value> { vm.heap() };
+    auto field_names = GC::MarkedVector<Value> { vm.heap() };
 
     // 6. Let next be true.
     // 7. Repeat, while next is not false,
diff --git a/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.h b/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.h
index 1390b94eacf..0bfeeb868b2 100644
--- a/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/CalendarPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class CalendarPrototype final : public PrototypeObject<CalendarPrototype, Calendar> {
     JS_PROTOTYPE_OBJECT(CalendarPrototype, Calendar, Temporal.Calendar);
-    JS_DECLARE_ALLOCATOR(CalendarPrototype);
+    GC_DECLARE_ALLOCATOR(CalendarPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/Duration.cpp b/Libraries/LibJS/Runtime/Temporal/Duration.cpp
index 27abb6a88f7..c2e81ee524b 100644
--- a/Libraries/LibJS/Runtime/Temporal/Duration.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/Duration.cpp
@@ -25,7 +25,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(Duration);
+GC_DEFINE_ALLOCATOR(Duration);
 
 // 7 Temporal.Duration Objects, https://tc39.es/proposal-temporal/#sec-temporal-duration-objects
 Duration::Duration(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, Object& prototype)
@@ -127,7 +127,7 @@ ThrowCompletionOr<TimeDurationRecord> create_time_duration_record(VM& vm, double
 }
 
 // 7.5.8 ToTemporalDuration ( item ), https://tc39.es/proposal-temporal/#sec-temporal-totemporalduration
-ThrowCompletionOr<NonnullGCPtr<Duration>> to_temporal_duration(VM& vm, Value item)
+ThrowCompletionOr<GC::Ref<Duration>> to_temporal_duration(VM& vm, Value item)
 {
     // 1. If Type(item) is Object and item has an [[InitializedTemporalDuration]] internal slot, then
     if (item.is_object() && is<Duration>(item.as_object())) {
@@ -433,7 +433,7 @@ ThrowCompletionOr<PartialDurationRecord> to_temporal_partial_duration_record(VM&
 }
 
 // 7.5.14 CreateTemporalDuration ( years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds [ , newTarget ] ), https://tc39.es/proposal-temporal/#sec-temporal-createtemporalduration
-ThrowCompletionOr<NonnullGCPtr<Duration>> create_temporal_duration(VM& vm, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject const* new_target)
+ThrowCompletionOr<GC::Ref<Duration>> create_temporal_duration(VM& vm, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject const* new_target)
 {
     auto& realm = *vm.current_realm();
 
@@ -463,7 +463,7 @@ ThrowCompletionOr<NonnullGCPtr<Duration>> create_temporal_duration(VM& vm, doubl
 }
 
 // 7.5.15 CreateNegatedTemporalDuration ( duration ), https://tc39.es/proposal-temporal/#sec-temporal-createnegatedtemporalduration
-NonnullGCPtr<Duration> create_negated_temporal_duration(VM& vm, Duration const& duration)
+GC::Ref<Duration> create_negated_temporal_duration(VM& vm, Duration const& duration)
 {
     // 1. Return ! CreateTemporalDuration(-duration.[[Years]], -duration.[[Months]], -duration.[[Weeks]], -duration.[[Days]], -duration.[[Hours]], -duration.[[Minutes]], -duration.[[Seconds]], -duration.[[Milliseconds]], -duration.[[Microseconds]], -duration.[[Nanoseconds]]).
     return MUST(create_temporal_duration(vm, -duration.years(), -duration.months(), -duration.weeks(), -duration.days(), -duration.hours(), -duration.minutes(), -duration.seconds(), -duration.milliseconds(), -duration.microseconds(), -duration.nanoseconds()));
@@ -477,7 +477,7 @@ ThrowCompletionOr<double> calculate_offset_shift(VM& vm, Value relative_to_value
         return 0.0;
 
     auto& relative_to = static_cast<ZonedDateTime&>(relative_to_value.as_object());
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { relative_to.time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { relative_to.time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
     // 2. Let instant be ! CreateTemporalInstant(relativeTo.[[Nanoseconds]]).
     auto* instant = MUST(create_temporal_instant(vm, relative_to.nanoseconds()));
@@ -921,7 +921,7 @@ ThrowCompletionOr<DateDurationRecord> unbalance_duration_relative(VM& vm, double
 
             // FIXME: AD-HOC calendar records use as this AO is not up to date with latest spec
             // iv. Let untilResult be ? CalendarDateUntil(calendar, relativeTo, newRelativeTo, untilOptions, dateUntil).
-            auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { *calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+            auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { *calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
             auto until_result = TRY(calendar_date_until(vm, calendar_record, relative_to, new_relative_to, *until_options));
 
             // v. Let oneYearMonths be untilResult.[[Months]].
@@ -1159,7 +1159,7 @@ ThrowCompletionOr<DateDurationRecord> balance_duration_relative(VM& vm, double y
 
         // FIXME: AD-HOC calendar records use as this AO is not up to date with latest spec
         // n. Let untilResult be ? CalendarDateUntil(calendar, relativeTo, newRelativeTo, untilOptions, dateUntil).
-        auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+        auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
         auto until_result = TRY(calendar_date_until(vm, calendar_record, relative_to, new_relative_to, *until_options));
 
         // o. Let oneYearMonths be untilResult.[[Months]].
@@ -1342,7 +1342,7 @@ ThrowCompletionOr<DurationRecord> add_duration(VM& vm, double years1, double mon
 
         // j. Let dateDifference be ? CalendarDateUntil(calendar, relativeTo, end, differenceOptions).
         // FIXME: AD-HOC calendar records use as this AO is not up to date with latest spec
-        auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+        auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
         auto date_difference = TRY(calendar_date_until(vm, calendar_record, &relative_to, end, *difference_options));
 
         // k. Let result be ? BalanceDuration(dateDifference.[[Days]], h1 + h2, min1 + min2, s1 + s2, ms1 + ms2, mus1 + mus2, ns1 + ns2, largestUnit).
@@ -1398,7 +1398,7 @@ ThrowCompletionOr<MoveRelativeDateResult> move_relative_date(VM& vm, Object& cal
     auto days = days_until(relative_to, *new_date);
 
     // 3. Return the Record { [[RelativeTo]]: newDate, [[Days]]: days }.
-    return MoveRelativeDateResult { .relative_to = make_handle(new_date), .days = days };
+    return MoveRelativeDateResult { .relative_to = make_root(new_date), .days = days };
 }
 
 // 7.5.24 MoveRelativeZonedDateTime ( zonedDateTime, years, months, weeks, days ), https://tc39.es/proposal-temporal/#sec-temporal-moverelativezoneddatetime
@@ -2068,7 +2068,7 @@ ThrowCompletionOr<String> temporal_duration_to_string(VM& vm, double years, doub
 }
 
 // 7.5.28 AddDurationToOrSubtractDurationFromDuration ( operation, duration, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-adddurationtoorsubtractdurationfromduration
-ThrowCompletionOr<NonnullGCPtr<Duration>> add_duration_to_or_subtract_duration_from_duration(VM& vm, ArithmeticOperation operation, Duration const& duration, Value other_value, Value options_value)
+ThrowCompletionOr<GC::Ref<Duration>> add_duration_to_or_subtract_duration_from_duration(VM& vm, ArithmeticOperation operation, Duration const& duration, Value other_value, Value options_value)
 {
     // 1. If operation is subtract, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == ArithmeticOperation::Subtract ? -1 : 1;
diff --git a/Libraries/LibJS/Runtime/Temporal/Duration.h b/Libraries/LibJS/Runtime/Temporal/Duration.h
index c2a75e24676..141569a1410 100644
--- a/Libraries/LibJS/Runtime/Temporal/Duration.h
+++ b/Libraries/LibJS/Runtime/Temporal/Duration.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/Optional.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Date.h>
 #include <LibJS/Runtime/Object.h>
@@ -21,7 +21,7 @@ namespace JS::Temporal {
 
 class Duration final : public Object {
     JS_OBJECT(Duration, Object);
-    JS_DECLARE_ALLOCATOR(Duration);
+    GC_DECLARE_ALLOCATOR(Duration);
 
 public:
     virtual ~Duration() override = default;
@@ -102,7 +102,7 @@ struct PartialDurationRecord {
 
 // Used by MoveRelativeDate to temporarily hold values
 struct MoveRelativeDateResult {
-    Handle<PlainDate> relative_to;
+    GC::Root<PlainDate> relative_to;
     double days;
 };
 
@@ -125,14 +125,14 @@ ThrowCompletionOr<DurationRecord> create_duration_record(VM&, double years, doub
 DateDurationRecord create_date_duration_record(double years, double months, double weeks, double days);
 ThrowCompletionOr<DateDurationRecord> create_date_duration_record(VM&, double years, double months, double weeks, double days);
 ThrowCompletionOr<TimeDurationRecord> create_time_duration_record(VM&, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
-ThrowCompletionOr<NonnullGCPtr<Duration>> to_temporal_duration(VM&, Value item);
+ThrowCompletionOr<GC::Ref<Duration>> to_temporal_duration(VM&, Value item);
 ThrowCompletionOr<DurationRecord> to_temporal_duration_record(VM&, Value temporal_duration_like);
 i8 duration_sign(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
 bool is_valid_duration(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
 StringView default_temporal_largest_unit(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds);
 ThrowCompletionOr<PartialDurationRecord> to_temporal_partial_duration_record(VM&, Value temporal_duration_like);
-ThrowCompletionOr<NonnullGCPtr<Duration>> create_temporal_duration(VM&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject const* new_target = nullptr);
-NonnullGCPtr<Duration> create_negated_temporal_duration(VM&, Duration const& duration);
+ThrowCompletionOr<GC::Ref<Duration>> create_temporal_duration(VM&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, FunctionObject const* new_target = nullptr);
+GC::Ref<Duration> create_negated_temporal_duration(VM&, Duration const& duration);
 ThrowCompletionOr<double> calculate_offset_shift(VM&, Value relative_to_value, double years, double months, double weeks, double days);
 Crypto::SignedBigInteger total_duration_nanoseconds(double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, Crypto::SignedBigInteger const& nanoseconds, double offset_shift);
 ThrowCompletionOr<TimeDurationRecord> balance_time_duration(VM& vm, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, Crypto::SignedBigInteger const& nanoseconds, StringView largest_unit);
@@ -153,7 +153,7 @@ ThrowCompletionOr<ZonedDateTime*> move_relative_zoned_date_time(VM&, ZonedDateTi
 ThrowCompletionOr<RoundedDuration> round_duration(VM&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, u32 increment, StringView unit, StringView rounding_mode, Object* relative_to_object = nullptr, Optional<CalendarMethods> const& = {});
 ThrowCompletionOr<DurationRecord> adjust_rounded_duration_days(VM&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, u32 increment, StringView unit, StringView rounding_mode, Object* relative_to_object);
 ThrowCompletionOr<String> temporal_duration_to_string(VM&, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, Variant<StringView, u8> const& precision);
-ThrowCompletionOr<NonnullGCPtr<Duration>> add_duration_to_or_subtract_duration_from_duration(VM&, ArithmeticOperation, Duration const&, Value other_value, Value options_value);
+ThrowCompletionOr<GC::Ref<Duration>> add_duration_to_or_subtract_duration_from_duration(VM&, ArithmeticOperation, Duration const&, Value other_value, Value options_value);
 
 // 7.5.22 DaysUntil ( earlier, later ), https://tc39.es/proposal-temporal/#sec-temporal-daysuntil
 template<typename EarlierObjectType, typename LaterObjectType>
diff --git a/Libraries/LibJS/Runtime/Temporal/DurationConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/DurationConstructor.cpp
index f5d35704113..1271c919e0f 100644
--- a/Libraries/LibJS/Runtime/Temporal/DurationConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/DurationConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(DurationConstructor);
+GC_DEFINE_ALLOCATOR(DurationConstructor);
 
 // 7.1 The Temporal.Duration Constructor, https://tc39.es/proposal-temporal/#sec-temporal-duration-constructor
 DurationConstructor::DurationConstructor(Realm& realm)
@@ -49,7 +49,7 @@ ThrowCompletionOr<Value> DurationConstructor::call()
 }
 
 // 7.1.1 Temporal.Duration ( [ years [ , months [ , weeks [ , days [ , hours [ , minutes [ , seconds [ , milliseconds [ , microseconds [ , nanoseconds ] ] ] ] ] ] ] ] ] ] ), https://tc39.es/proposal-temporal/#sec-temporal.duration
-ThrowCompletionOr<NonnullGCPtr<Object>> DurationConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> DurationConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/DurationConstructor.h b/Libraries/LibJS/Runtime/Temporal/DurationConstructor.h
index 1b012dd90a3..381dc334944 100644
--- a/Libraries/LibJS/Runtime/Temporal/DurationConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/DurationConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class DurationConstructor final : public NativeFunction {
     JS_OBJECT(DurationConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(DurationConstructor);
+    GC_DECLARE_ALLOCATOR(DurationConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~DurationConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit DurationConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/DurationPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/DurationPrototype.cpp
index d64a56501a3..9f0cebd2315 100644
--- a/Libraries/LibJS/Runtime/Temporal/DurationPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/DurationPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(DurationPrototype);
+GC_DEFINE_ALLOCATOR(DurationPrototype);
 
 // 7.3 Properties of the Temporal.Duration Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-duration-prototype-object
 DurationPrototype::DurationPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/DurationPrototype.h b/Libraries/LibJS/Runtime/Temporal/DurationPrototype.h
index 4d4fb7932f6..563f243450f 100644
--- a/Libraries/LibJS/Runtime/Temporal/DurationPrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/DurationPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class DurationPrototype final : public PrototypeObject<DurationPrototype, Duration> {
     JS_PROTOTYPE_OBJECT(DurationPrototype, Duration, Temporal.Duration);
-    JS_DECLARE_ALLOCATOR(DurationPrototype);
+    GC_DECLARE_ALLOCATOR(DurationPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/Instant.cpp b/Libraries/LibJS/Runtime/Temporal/Instant.cpp
index d9ca44f2360..bb87f2e436a 100644
--- a/Libraries/LibJS/Runtime/Temporal/Instant.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/Instant.cpp
@@ -23,7 +23,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(Instant);
+GC_DEFINE_ALLOCATOR(Instant);
 
 // 8 Temporal.Instant Objects, https://tc39.es/proposal-temporal/#sec-temporal-instant-objects
 Instant::Instant(BigInt const& nanoseconds, Object& prototype)
@@ -300,7 +300,7 @@ ThrowCompletionOr<String> temporal_instant_to_string(VM& vm, Instant& instant, V
     }
     // 9. Else,
     else {
-        auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+        auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
         // a. Let offsetNs be ? GetOffsetNanosecondsFor(timeZone, instant).
         auto offset_ns = TRY(get_offset_nanoseconds_for(vm, time_zone_record, instant));
@@ -314,7 +314,7 @@ ThrowCompletionOr<String> temporal_instant_to_string(VM& vm, Instant& instant, V
 }
 
 // 8.5.9 DifferenceTemporalInstant ( operation, instant, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalinstant
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_instant(VM& vm, DifferenceOperation operation, Instant const& instant, Value other_value, Value options)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_instant(VM& vm, DifferenceOperation operation, Instant const& instant, Value other_value, Value options)
 {
     // 1. If operation is since, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
diff --git a/Libraries/LibJS/Runtime/Temporal/Instant.h b/Libraries/LibJS/Runtime/Temporal/Instant.h
index aa9b47922da..ec5c124d3e3 100644
--- a/Libraries/LibJS/Runtime/Temporal/Instant.h
+++ b/Libraries/LibJS/Runtime/Temporal/Instant.h
@@ -18,7 +18,7 @@ namespace JS::Temporal {
 
 class Instant final : public Object {
     JS_OBJECT(Instant, Object);
-    JS_DECLARE_ALLOCATOR(Instant);
+    GC_DECLARE_ALLOCATOR(Instant);
 
 public:
     virtual ~Instant() override = default;
@@ -31,7 +31,7 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 8.4 Properties of Temporal.Instant Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-instant-instances
-    NonnullGCPtr<BigInt const> m_nanoseconds; // [[Nanoseconds]]
+    GC::Ref<BigInt const> m_nanoseconds; // [[Nanoseconds]]
 };
 
 // https://tc39.es/proposal-temporal/#eqn-nsMaxInstant
@@ -52,7 +52,7 @@ ThrowCompletionOr<BigInt*> add_instant(VM&, BigInt const& epoch_nanoseconds, dou
 TimeDurationRecord difference_instant(VM&, BigInt const& nanoseconds1, BigInt const& nanoseconds2, u64 rounding_increment, StringView smallest_unit, StringView largest_unit, StringView rounding_mode);
 BigInt* round_temporal_instant(VM&, BigInt const& nanoseconds, u64 increment, StringView unit, StringView rounding_mode);
 ThrowCompletionOr<String> temporal_instant_to_string(VM&, Instant&, Value time_zone, Variant<StringView, u8> const& precision);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_instant(VM&, DifferenceOperation, Instant const&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_instant(VM&, DifferenceOperation, Instant const&, Value other, Value options);
 ThrowCompletionOr<Instant*> add_duration_to_or_subtract_duration_from_instant(VM&, ArithmeticOperation, Instant const&, Value temporal_duration_like);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/InstantConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/InstantConstructor.cpp
index 36706d3aa98..c425581b14f 100644
--- a/Libraries/LibJS/Runtime/Temporal/InstantConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/InstantConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(InstantConstructor);
+GC_DEFINE_ALLOCATOR(InstantConstructor);
 
 // 8.1 The Temporal.Instant Constructor, https://tc39.es/proposal-temporal/#sec-temporal-instant-constructor
 InstantConstructor::InstantConstructor(Realm& realm)
@@ -52,7 +52,7 @@ ThrowCompletionOr<Value> InstantConstructor::call()
 }
 
 // 8.1.1 Temporal.Instant ( epochNanoseconds ), https://tc39.es/proposal-temporal/#sec-temporal.instant
-ThrowCompletionOr<NonnullGCPtr<Object>> InstantConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> InstantConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/InstantConstructor.h b/Libraries/LibJS/Runtime/Temporal/InstantConstructor.h
index 80014a37138..b2e9626c48e 100644
--- a/Libraries/LibJS/Runtime/Temporal/InstantConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/InstantConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class InstantConstructor final : public NativeFunction {
     JS_OBJECT(InstantConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(InstantConstructor);
+    GC_DECLARE_ALLOCATOR(InstantConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~InstantConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit InstantConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp
index 50a838b03ab..98746709ad5 100644
--- a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.cpp
@@ -18,7 +18,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(InstantPrototype);
+GC_DEFINE_ALLOCATOR(InstantPrototype);
 
 // 8.3 Properties of the Temporal.Instant Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-instant-prototype-object
 InstantPrototype::InstantPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h
index a5bd989648e..66aea209d49 100644
--- a/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/InstantPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class InstantPrototype final : public PrototypeObject<InstantPrototype, Instant> {
     JS_PROTOTYPE_OBJECT(InstantPrototype, Instant, Temporal.Instant);
-    JS_DECLARE_ALLOCATOR(InstantPrototype);
+    GC_DECLARE_ALLOCATOR(InstantPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/Now.cpp b/Libraries/LibJS/Runtime/Temporal/Now.cpp
index 49a55262dd6..1723c5aad7c 100644
--- a/Libraries/LibJS/Runtime/Temporal/Now.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/Now.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(Now);
+GC_DEFINE_ALLOCATOR(Now);
 
 // 2 The Temporal.Now Object, https://tc39.es/proposal-temporal/#sec-temporal-now-object
 Now::Now(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/Now.h b/Libraries/LibJS/Runtime/Temporal/Now.h
index c420d748bcf..8217e49271a 100644
--- a/Libraries/LibJS/Runtime/Temporal/Now.h
+++ b/Libraries/LibJS/Runtime/Temporal/Now.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class Now final : public Object {
     JS_OBJECT(Now, Object);
-    JS_DECLARE_ALLOCATOR(Now);
+    GC_DECLARE_ALLOCATOR(Now);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDate.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDate.cpp
index 51089649abb..d26a7fb3d9a 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDate.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDate.cpp
@@ -23,7 +23,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDate);
+GC_DEFINE_ALLOCATOR(PlainDate);
 
 // 3 Temporal.PlainDate Objects, https://tc39.es/proposal-temporal/#sec-temporal-plaindate-objects
 PlainDate::PlainDate(i32 year, u8 month, u8 day, Object& calendar, Object& prototype)
@@ -382,7 +382,7 @@ bool is_valid_iso_date(i32 year, u8 month, u8 day)
 }
 
 // 3.5.6 DifferenceDate ( calendarRec, one, two, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencedate
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_date(VM& vm, CalendarMethods const& calendar_record, PlainDate const& one, PlainDate const& two, Object const& options)
+ThrowCompletionOr<GC::Ref<Duration>> difference_date(VM& vm, CalendarMethods const& calendar_record, PlainDate const& one, PlainDate const& two, Object const& options)
 {
     // FIXME: 1. Assert: one.[[Calendar]] and two.[[Calendar]] have been determined to be equivalent as with CalendarEquals.
     // FIXME: 2. Assert: options is an ordinary Object.
@@ -529,7 +529,7 @@ i8 compare_iso_date(i32 year1, u8 month1, u8 day1, i32 year2, u8 month2, u8 day2
 }
 
 // 3.5.11 DifferenceTemporalPlainDate ( operation, temporalDate, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaindate
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date(VM& vm, DifferenceOperation operation, PlainDate& temporal_date, Value other_value, Value options)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_date(VM& vm, DifferenceOperation operation, PlainDate& temporal_date, Value other_value, Value options)
 {
     // 1. If operation is SINCE, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
@@ -555,7 +555,7 @@ ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date(VM& vm,
 
     // 7. Let calendarRec be ? CreateCalendarMethodsRecord(temporalDate.[[Calendar]], « DATE-ADD, DATE-UNTIL »).
     // FIXME: The type of calendar in PlainDate does not align with latest spec
-    auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { temporal_date.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+    auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { temporal_date.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
 
     // 8. Perform ! CreateDataPropertyOrThrow(resolvedOptions, "largestUnit", settings.[[LargestUnit]]).
     MUST(resolved_options->create_data_property_or_throw(vm.names.largestUnit, PrimitiveString::create(vm, settings.largest_unit)));
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDate.h b/Libraries/LibJS/Runtime/Temporal/PlainDate.h
index 04eb56c62b3..3fa52469ef5 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDate.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDate.h
@@ -17,7 +17,7 @@ namespace JS::Temporal {
 
 class PlainDate final : public Object {
     JS_OBJECT(PlainDate, Object);
-    JS_DECLARE_ALLOCATOR(PlainDate);
+    GC_DECLARE_ALLOCATOR(PlainDate);
 
 public:
     virtual ~PlainDate() override = default;
@@ -34,10 +34,10 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 3.4 Properties of Temporal.PlainDate Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plaindate-instances
-    i32 m_iso_year { 0 };            // [[ISOYear]]
-    u8 m_iso_month { 1 };            // [[ISOMonth]]
-    u8 m_iso_day { 1 };              // [[ISODay]]
-    NonnullGCPtr<Object> m_calendar; // [[Calendar]]
+    i32 m_iso_year { 0 };       // [[ISOYear]]
+    u8 m_iso_month { 1 };       // [[ISOMonth]]
+    u8 m_iso_day { 1 };         // [[ISODay]]
+    GC::Ref<Object> m_calendar; // [[Calendar]]
 };
 
 // 3.5.1 ISO Date Records, https://tc39.es/proposal-temporal/#sec-temporal-iso-date-records
@@ -58,7 +58,7 @@ ThrowCompletionOr<String> pad_iso_year(VM&, i32 y);
 ThrowCompletionOr<String> temporal_date_to_string(VM&, PlainDate&, StringView show_calendar);
 ThrowCompletionOr<ISODateRecord> add_iso_date(VM&, i32 year, u8 month, u8 day, double years, double months, double weeks, double days, StringView overflow);
 i8 compare_iso_date(i32 year1, u8 month1, u8 day1, i32 year2, u8 month2, u8 day2);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date(VM&, DifferenceOperation, PlainDate&, Value other, Value options);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_date(VM& vm, CalendarMethods const&, PlainDate const& one, PlainDate const& two, Object const& options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_date(VM&, DifferenceOperation, PlainDate&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_date(VM& vm, CalendarMethods const&, PlainDate const& one, PlainDate const& two, Object const& options);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.cpp
index 00f7a715133..b40bf0aae97 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDateConstructor);
+GC_DEFINE_ALLOCATOR(PlainDateConstructor);
 
 // 3.1 The Temporal.PlainDate Constructor, https://tc39.es/proposal-temporal/#sec-temporal-plaindate-constructor
 PlainDateConstructor::PlainDateConstructor(Realm& realm)
@@ -48,7 +48,7 @@ ThrowCompletionOr<Value> PlainDateConstructor::call()
 }
 
 // 3.1.1 Temporal.PlainDate ( isoYear, isoMonth, isoDay [ , calendarLike ] ), https://tc39.es/proposal-temporal/#sec-temporal.plaindate
-ThrowCompletionOr<NonnullGCPtr<Object>> PlainDateConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PlainDateConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.h b/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.h
index bc51a6a6e66..e6a7943d137 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class PlainDateConstructor final : public NativeFunction {
     JS_OBJECT(PlainDateConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PlainDateConstructor);
+    GC_DECLARE_ALLOCATOR(PlainDateConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PlainDateConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PlainDateConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.cpp
index 918289b83c0..759c77c983d 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.cpp
@@ -19,7 +19,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDatePrototype);
+GC_DEFINE_ALLOCATOR(PlainDatePrototype);
 
 // 3.3 Properties of the Temporal.PlainDate Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-plaindate-prototype-object
 PlainDatePrototype::PlainDatePrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.h b/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.h
index 8b988229634..1fd3f199133 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDatePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainDatePrototype final : public PrototypeObject<PlainDatePrototype, PlainDate> {
     JS_PROTOTYPE_OBJECT(PlainDatePrototype, PlainDate, Temporal.PlainDate);
-    JS_DECLARE_ALLOCATOR(PlainDatePrototype);
+    GC_DECLARE_ALLOCATOR(PlainDatePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTime.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDateTime.cpp
index 4edcd31c53b..9cc9427d8b1 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTime.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTime.cpp
@@ -23,7 +23,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDateTime);
+GC_DEFINE_ALLOCATOR(PlainDateTime);
 
 // 5 Temporal.PlainDateTime Objects, https://tc39.es/proposal-temporal/#sec-temporal-plaindatetime-objects
 PlainDateTime::PlainDateTime(i32 iso_year, u8 iso_month, u8 iso_day, u8 iso_hour, u8 iso_minute, u8 iso_second, u16 iso_millisecond, u16 iso_microsecond, u16 iso_nanosecond, Object& calendar, Object& prototype)
@@ -375,7 +375,7 @@ ThrowCompletionOr<DurationRecord> difference_iso_date_time(VM& vm, i32 year1, u8
 
     // 12. Let dateDifference be ? CalendarDateUntil(calendar, date1, date2, untilOptions).
     // FIXME: AD-HOC calendar records use as this AO is not up to date with latest spec
-    auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+    auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
     auto date_difference = TRY(calendar_date_until(vm, calendar_record, date1, date2, *until_options));
 
     // 13. Let balanceResult be ? BalanceDuration(dateDifference.[[Days]], timeDifference.[[Hours]], timeDifference.[[Minutes]], timeDifference.[[Seconds]], timeDifference.[[Milliseconds]], timeDifference.[[Microseconds]], timeDifference.[[Nanoseconds]], largestUnit).
@@ -386,7 +386,7 @@ ThrowCompletionOr<DurationRecord> difference_iso_date_time(VM& vm, i32 year1, u8
 }
 
 // 5.5.11 DifferenceTemporalPlainDateTime ( operation, dateTime, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaindatetime
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date_time(VM& vm, DifferenceOperation operation, PlainDateTime& date_time, Value other_value, Value options_value)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_date_time(VM& vm, DifferenceOperation operation, PlainDateTime& date_time, Value other_value, Value options_value)
 {
     // 1. If operation is since, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
@@ -409,7 +409,7 @@ ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date_time(VM
 
     // 7. Let roundResult be (? RoundDuration(diff.[[Years]], diff.[[Months]], diff.[[Weeks]], diff.[[Days]], diff.[[Hours]], diff.[[Minutes]], diff.[[Seconds]], diff.[[Milliseconds]], diff.[[Microseconds]], diff.[[Nanoseconds]], settings.[[RoundingIncrement]], settings.[[SmallestUnit]], settings.[[RoundingMode]], relativeTo)).[[DurationRecord]].
     // FIXME: AD-HOC calendar records use as this AO is not up to date with latest spec
-    auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { date_time.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
+    auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { date_time.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateUntil } }));
     auto round_result = TRY(round_duration(vm, diff.years, diff.months, diff.weeks, diff.days, diff.hours, diff.minutes, diff.seconds, diff.milliseconds, diff.microseconds, diff.nanoseconds, settings.rounding_increment, settings.smallest_unit, settings.rounding_mode, relative_to, calendar_record)).duration_record;
 
     // 8. Let result be ? BalanceDuration(roundResult.[[Days]], roundResult.[[Hours]], roundResult.[[Minutes]], roundResult.[[Seconds]], roundResult.[[Milliseconds]], roundResult.[[Microseconds]], roundResult.[[Nanoseconds]], settings.[[LargestUnit]]).
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTime.h b/Libraries/LibJS/Runtime/Temporal/PlainDateTime.h
index 2c3fa9a8760..5dd711a93ad 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTime.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTime.h
@@ -17,7 +17,7 @@ namespace JS::Temporal {
 
 class PlainDateTime final : public Object {
     JS_OBJECT(PlainDateTime, Object);
-    JS_DECLARE_ALLOCATOR(PlainDateTime);
+    GC_DECLARE_ALLOCATOR(PlainDateTime);
 
 public:
     virtual ~PlainDateTime() override = default;
@@ -40,16 +40,16 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 5.4 Properties of Temporal.PlainDateTime Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plaindatetime-instances
-    i32 m_iso_year { 0 };            // [[ISOYear]]
-    u8 m_iso_month { 0 };            // [[ISOMonth]]
-    u8 m_iso_day { 0 };              // [[ISODay]]
-    u8 m_iso_hour { 0 };             // [[ISOHour]]
-    u8 m_iso_minute { 0 };           // [[ISOMinute]]
-    u8 m_iso_second { 0 };           // [[ISOSecond]]
-    u16 m_iso_millisecond { 0 };     // [[ISOMillisecond]]
-    u16 m_iso_microsecond { 0 };     // [[ISOMicrosecond]]
-    u16 m_iso_nanosecond { 0 };      // [[ISONanosecond]]
-    NonnullGCPtr<Object> m_calendar; // [[Calendar]]
+    i32 m_iso_year { 0 };        // [[ISOYear]]
+    u8 m_iso_month { 0 };        // [[ISOMonth]]
+    u8 m_iso_day { 0 };          // [[ISODay]]
+    u8 m_iso_hour { 0 };         // [[ISOHour]]
+    u8 m_iso_minute { 0 };       // [[ISOMinute]]
+    u8 m_iso_second { 0 };       // [[ISOSecond]]
+    u16 m_iso_millisecond { 0 }; // [[ISOMillisecond]]
+    u16 m_iso_microsecond { 0 }; // [[ISOMicrosecond]]
+    u16 m_iso_nanosecond { 0 };  // [[ISONanosecond]]
+    GC::Ref<Object> m_calendar;  // [[Calendar]]
 };
 
 // Used by AddDateTime to temporarily hold values
@@ -75,7 +75,7 @@ i8 compare_iso_date_time(i32 year1, u8 month1, u8 day1, u8 hour1, u8 minute1, u8
 ThrowCompletionOr<TemporalPlainDateTime> add_date_time(VM&, i32 year, u8 month, u8 day, u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, Object& calendar, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, Object* options);
 ISODateTime round_iso_date_time(i32 year, u8 month, u8 day, u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, u64 increment, StringView unit, StringView rounding_mode, Optional<double> day_length = {});
 ThrowCompletionOr<DurationRecord> difference_iso_date_time(VM&, i32 year1, u8 month1, u8 day1, u8 hour1, u8 minute1, u8 second1, u16 millisecond1, u16 microsecond1, u16 nanosecond1, i32 year2, u8 month2, u8 day2, u8 hour2, u8 minute2, u8 second2, u16 millisecond2, u16 microsecond2, u16 nanosecond2, Object& calendar, StringView largest_unit, Object const& options);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_date_time(VM&, DifferenceOperation, PlainDateTime&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_date_time(VM&, DifferenceOperation, PlainDateTime&, Value other, Value options);
 ThrowCompletionOr<PlainDateTime*> add_duration_to_or_subtract_duration_from_plain_date_time(VM&, ArithmeticOperation, PlainDateTime&, Value temporal_duration_like, Value options_value);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.cpp
index 405084b2f05..811b22d3327 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDateTimeConstructor);
+GC_DEFINE_ALLOCATOR(PlainDateTimeConstructor);
 
 // 5.1 The Temporal.PlainDateTime Constructor, https://tc39.es/proposal-temporal/#sec-temporal-plaindatetime-constructor
 PlainDateTimeConstructor::PlainDateTimeConstructor(Realm& realm)
@@ -48,7 +48,7 @@ ThrowCompletionOr<Value> PlainDateTimeConstructor::call()
 }
 
 // 5.1.1 Temporal.PlainDateTime ( isoYear, isoMonth, isoDay [ , hour [ , minute [ , second [ , millisecond [ , microsecond [ , nanosecond [ , calendarLike ] ] ] ] ] ] ] ), https://tc39.es/proposal-temporal/#sec-temporal.plaindatetime
-ThrowCompletionOr<NonnullGCPtr<Object>> PlainDateTimeConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PlainDateTimeConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.h b/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.h
index 321ca75a149..71e26a7fad4 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTimeConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class PlainDateTimeConstructor final : public NativeFunction {
     JS_OBJECT(PlainDateTimeConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PlainDateTimeConstructor);
+    GC_DECLARE_ALLOCATOR(PlainDateTimeConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PlainDateTimeConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PlainDateTimeConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.cpp b/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.cpp
index af19d95eec6..0b28b124d7d 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainDateTimePrototype);
+GC_DEFINE_ALLOCATOR(PlainDateTimePrototype);
 
 // 5.3 Properties of the Temporal.PlainDateTime Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-plaindatetime-prototype-object
 PlainDateTimePrototype::PlainDateTimePrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.h b/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.h
index f333433a40c..d9e73b36f66 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainDateTimePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainDateTimePrototype final : public PrototypeObject<PlainDateTimePrototype, PlainDateTime> {
     JS_PROTOTYPE_OBJECT(PlainDateTimePrototype, PlainDateTime, Temporal.PlainDateTime);
-    JS_DECLARE_ALLOCATOR(PlainDateTimePrototype);
+    GC_DECLARE_ALLOCATOR(PlainDateTimePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.cpp b/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.cpp
index 7ac70e7d951..7582d0a60e5 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.cpp
@@ -18,7 +18,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainMonthDay);
+GC_DEFINE_ALLOCATOR(PlainMonthDay);
 
 // 10 Temporal.PlainMonthDay Objects, https://tc39.es/proposal-temporal/#sec-temporal-plainmonthday-objects
 PlainMonthDay::PlainMonthDay(u8 iso_month, u8 iso_day, i32 iso_year, Object& calendar, Object& prototype)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.h b/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.h
index ea2d59f00b8..07dca500417 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDay.h
@@ -12,7 +12,7 @@ namespace JS::Temporal {
 
 class PlainMonthDay final : public Object {
     JS_OBJECT(PlainMonthDay, Object);
-    JS_DECLARE_ALLOCATOR(PlainMonthDay);
+    GC_DECLARE_ALLOCATOR(PlainMonthDay);
 
 public:
     virtual ~PlainMonthDay() override = default;
@@ -29,10 +29,10 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 10.4 Properties of Temporal.PlainMonthDay Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plainmonthday-instances
-    i32 m_iso_year { 0 };            // [[ISOYear]]
-    u8 m_iso_month { 0 };            // [[ISOMonth]]
-    u8 m_iso_day { 0 };              // [[ISODay]]
-    NonnullGCPtr<Object> m_calendar; // [[Calendar]]
+    i32 m_iso_year { 0 };       // [[ISOYear]]
+    u8 m_iso_month { 0 };       // [[ISOMonth]]
+    u8 m_iso_day { 0 };         // [[ISODay]]
+    GC::Ref<Object> m_calendar; // [[Calendar]]
 };
 
 struct ISOMonthDay {
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.cpp
index 2eae0df4cdb..ce6e2afc836 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainMonthDayConstructor);
+GC_DEFINE_ALLOCATOR(PlainMonthDayConstructor);
 
 // 10.1 The Temporal.PlainMonthDay Constructor, https://tc39.es/proposal-temporal/#sec-temporal-plainmonthday-constructor
 PlainMonthDayConstructor::PlainMonthDayConstructor(Realm& realm)
@@ -46,7 +46,7 @@ ThrowCompletionOr<Value> PlainMonthDayConstructor::call()
 }
 
 // 10.1.1 Temporal.PlainMonthDay ( isoMonth, isoDay [ , calendarLike [ , referenceISOYear ] ] ), https://tc39.es/proposal-temporal/#sec-temporal.plainmonthday
-ThrowCompletionOr<NonnullGCPtr<Object>> PlainMonthDayConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PlainMonthDayConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.h b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.h
index 3a8a3098ea2..71b85743143 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class PlainMonthDayConstructor final : public NativeFunction {
     JS_OBJECT(PlainMonthDayConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PlainMonthDayConstructor);
+    GC_DECLARE_ALLOCATOR(PlainMonthDayConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PlainMonthDayConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PlainMonthDayConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.cpp
index 591d11d6dcf..4e16531580e 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainMonthDayPrototype);
+GC_DEFINE_ALLOCATOR(PlainMonthDayPrototype);
 
 // 10.3 Properties of the Temporal.PlainMonthDay Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-plainmonthday-prototype-object
 PlainMonthDayPrototype::PlainMonthDayPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.h b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.h
index f3a00aa2338..63c46ec2e5f 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainMonthDayPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainMonthDayPrototype final : public PrototypeObject<PlainMonthDayPrototype, PlainMonthDay> {
     JS_PROTOTYPE_OBJECT(PlainMonthDayPrototype, PlainMonthDay, Temporal.PlainMonthDay);
-    JS_DECLARE_ALLOCATOR(PlainMonthDayPrototype);
+    GC_DECLARE_ALLOCATOR(PlainMonthDayPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTime.cpp b/Libraries/LibJS/Runtime/Temporal/PlainTime.cpp
index 66f863b77c6..99e87c963d6 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTime.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTime.cpp
@@ -22,7 +22,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainTime);
+GC_DEFINE_ALLOCATOR(PlainTime);
 
 // 4 Temporal.PlainTime Objects, https://tc39.es/proposal-temporal/#sec-temporal-plaintime-objects
 PlainTime::PlainTime(u8 iso_hour, u8 iso_minute, u8 iso_second, u16 iso_millisecond, u16 iso_microsecond, u16 iso_nanosecond, Calendar& calendar, Object& prototype)
@@ -644,7 +644,7 @@ DaysAndTime round_time(u8 hour, u8 minute, u8 second, u16 millisecond, u16 micro
 }
 
 // 4.5.13 DifferenceTemporalPlainTime ( operation, temporalTime, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplaintime
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_time(VM& vm, DifferenceOperation operation, PlainTime const& temporal_time, Value other_value, Value options_value)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_time(VM& vm, DifferenceOperation operation, PlainTime const& temporal_time, Value other_value, Value options_value)
 {
     // 1. If operation is since, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTime.h b/Libraries/LibJS/Runtime/Temporal/PlainTime.h
index 363a02c652a..e7b9bd37c13 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTime.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTime.h
@@ -17,7 +17,7 @@ namespace JS::Temporal {
 
 class PlainTime final : public Object {
     JS_OBJECT(PlainTime, Object);
-    JS_DECLARE_ALLOCATOR(PlainTime);
+    GC_DECLARE_ALLOCATOR(PlainTime);
 
 public:
     virtual ~PlainTime() override = default;
@@ -37,13 +37,13 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 4.4 Properties of Temporal.PlainTime Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plaintime-instances
-    u8 m_iso_hour { 0 };               // [[ISOHour]]
-    u8 m_iso_minute { 0 };             // [[ISOMinute]]
-    u8 m_iso_second { 0 };             // [[ISOSecond]]
-    u16 m_iso_millisecond { 0 };       // [[ISOMillisecond]]
-    u16 m_iso_microsecond { 0 };       // [[ISOMicrosecond]]
-    u16 m_iso_nanosecond { 0 };        // [[ISONanosecond]]
-    NonnullGCPtr<Calendar> m_calendar; // [[Calendar]] (always the built-in ISO 8601 calendar)
+    u8 m_iso_hour { 0 };          // [[ISOHour]]
+    u8 m_iso_minute { 0 };        // [[ISOMinute]]
+    u8 m_iso_second { 0 };        // [[ISOSecond]]
+    u16 m_iso_millisecond { 0 };  // [[ISOMillisecond]]
+    u16 m_iso_microsecond { 0 };  // [[ISOMicrosecond]]
+    u16 m_iso_nanosecond { 0 };   // [[ISONanosecond]]
+    GC::Ref<Calendar> m_calendar; // [[Calendar]] (always the built-in ISO 8601 calendar)
 };
 
 struct DaysAndTime {
@@ -90,7 +90,7 @@ ThrowCompletionOr<String> temporal_time_to_string(VM&, u8 hour, u8 minute, u8 se
 i8 compare_temporal_time(u8 hour1, u8 minute1, u8 second1, u16 millisecond1, u16 microsecond1, u16 nanosecond1, u8 hour2, u8 minute2, u8 second2, u16 millisecond2, u16 microsecond2, u16 nanosecond2);
 DaysAndTime add_time(u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds);
 DaysAndTime round_time(u8 hour, u8 minute, u8 second, u16 millisecond, u16 microsecond, u16 nanosecond, u64 increment, StringView unit, StringView rounding_mode, Optional<double> day_length_ns = {});
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_time(VM&, DifferenceOperation, PlainTime const&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_time(VM&, DifferenceOperation, PlainTime const&, Value other, Value options);
 ThrowCompletionOr<PlainTime*> add_duration_to_or_subtract_duration_from_plain_time(VM&, ArithmeticOperation, PlainTime const&, Value temporal_duration_like);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.cpp
index 0b4237246b6..c505c895128 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.cpp
@@ -12,7 +12,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainTimeConstructor);
+GC_DEFINE_ALLOCATOR(PlainTimeConstructor);
 
 // 4.1 The Temporal.PlainTime Constructor, https://tc39.es/proposal-temporal/#sec-temporal-plaintime-constructor
 PlainTimeConstructor::PlainTimeConstructor(Realm& realm)
@@ -46,7 +46,7 @@ ThrowCompletionOr<Value> PlainTimeConstructor::call()
 }
 
 // 4.1.1 Temporal.PlainTime ( [ hour [ , minute [ , second [ , millisecond [ , microsecond [ , nanosecond ] ] ] ] ] ] ), https://tc39.es/proposal-temporal/#sec-temporal.plaintime
-ThrowCompletionOr<NonnullGCPtr<Object>> PlainTimeConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PlainTimeConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.h b/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.h
index 05788273c02..dc754dbe780 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTimeConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class PlainTimeConstructor final : public NativeFunction {
     JS_OBJECT(PlainTimeConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PlainTimeConstructor);
+    GC_DECLARE_ALLOCATOR(PlainTimeConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PlainTimeConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PlainTimeConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.cpp b/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.cpp
index 708024129b6..3e9afbb38f4 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.cpp
@@ -19,7 +19,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainTimePrototype);
+GC_DEFINE_ALLOCATOR(PlainTimePrototype);
 
 // 4.3 Properties of the Temporal.PlainTime Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-plaintime-prototype-object
 PlainTimePrototype::PlainTimePrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.h b/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.h
index b20bdb50991..67b7c21378b 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainTimePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainTimePrototype final : public PrototypeObject<PlainTimePrototype, PlainTime> {
     JS_PROTOTYPE_OBJECT(PlainTimePrototype, PlainTime, Temporal.PlainTime);
-    JS_DECLARE_ALLOCATOR(PlainTimePrototype);
+    GC_DECLARE_ALLOCATOR(PlainTimePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.cpp b/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.cpp
index 6a1f7faed00..88b5a0deafc 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.cpp
@@ -17,7 +17,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainYearMonth);
+GC_DEFINE_ALLOCATOR(PlainYearMonth);
 
 // 9 Temporal.PlainYearMonth Objects, https://tc39.es/proposal-temporal/#sec-temporal-plainyearmonth-objects
 PlainYearMonth::PlainYearMonth(i32 iso_year, u8 iso_month, u8 iso_day, Object& calendar, Object& prototype)
@@ -232,7 +232,7 @@ ThrowCompletionOr<String> temporal_year_month_to_string(VM& vm, PlainYearMonth&
 }
 
 // 9.5.7 DifferenceTemporalPlainYearMonth ( operation, yearMonth, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalplainyearmonth
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_year_month(VM& vm, DifferenceOperation operation, PlainYearMonth& year_month, Value other_value, Value options_value)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_year_month(VM& vm, DifferenceOperation operation, PlainYearMonth& year_month, Value other_value, Value options_value)
 {
     // 1. If operation is since, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
@@ -264,7 +264,7 @@ ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_year_month(V
 
     // 9. Let calendarRec be ? CreateCalendarMethodsRecord(calendar, « dateAdd, dateFromFields, dateUntil, fields »).
     // FIXME: The type of calendar in PlainYearMonth does not align with latest spec
-    auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateFromFields, CalendarMethod::DateUntil, CalendarMethod::Fields } }));
+    auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { calendar }, { { CalendarMethod::DateAdd, CalendarMethod::DateFromFields, CalendarMethod::DateUntil, CalendarMethod::Fields } }));
 
     // 10. Let fieldNames be ? CalendarFields(calendarRec, « "monthCode", "year" »).
     // FIXME: Pass through calendar record
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.h b/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.h
index ae43477a8ba..10c070c52d3 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonth.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainYearMonth final : public Object {
     JS_OBJECT(PlainYearMonth, Object);
-    JS_DECLARE_ALLOCATOR(PlainYearMonth);
+    GC_DECLARE_ALLOCATOR(PlainYearMonth);
 
 public:
     virtual ~PlainYearMonth() override = default;
@@ -30,10 +30,10 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 9.4 Properties of Temporal.PlainYearMonth Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-plainyearmonth-instances
-    i32 m_iso_year { 0 };            // [[ISOYear]]
-    u8 m_iso_month { 0 };            // [[ISOMonth]]
-    u8 m_iso_day { 0 };              // [[ISODay]]
-    NonnullGCPtr<Object> m_calendar; // [[Calendar]]
+    i32 m_iso_year { 0 };       // [[ISOYear]]
+    u8 m_iso_month { 0 };       // [[ISOMonth]]
+    u8 m_iso_day { 0 };         // [[ISODay]]
+    GC::Ref<Object> m_calendar; // [[Calendar]]
 };
 
 struct ISOYearMonth {
@@ -48,7 +48,7 @@ bool iso_year_month_within_limits(i32 year, u8 month);
 ISOYearMonth balance_iso_year_month(double year, double month);
 ThrowCompletionOr<PlainYearMonth*> create_temporal_year_month(VM&, i32 iso_year, u8 iso_month, Object& calendar, u8 reference_iso_day, FunctionObject const* new_target = nullptr);
 ThrowCompletionOr<String> temporal_year_month_to_string(VM&, PlainYearMonth&, StringView show_calendar);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_plain_year_month(VM&, DifferenceOperation, PlainYearMonth&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_plain_year_month(VM&, DifferenceOperation, PlainYearMonth&, Value other, Value options);
 ThrowCompletionOr<PlainYearMonth*> add_duration_to_or_subtract_duration_from_plain_year_month(VM&, ArithmeticOperation, PlainYearMonth&, Value temporal_duration_like, Value options_value);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.cpp
index 1889b4e7374..59fff92c92c 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainYearMonthConstructor);
+GC_DEFINE_ALLOCATOR(PlainYearMonthConstructor);
 
 // 9.1 The Temporal.PlainYearMonth Constructor, https://tc39.es/proposal-temporal/#sec-temporal-plainyearmonth-constructor
 PlainYearMonthConstructor::PlainYearMonthConstructor(Realm& realm)
@@ -48,7 +48,7 @@ ThrowCompletionOr<Value> PlainYearMonthConstructor::call()
 }
 
 // 9.1.1 Temporal.PlainYearMonth ( isoYear, isoMonth [ , calendarLike [ , referenceISODay ] ] ), https://tc39.es/proposal-temporal/#sec-temporal.plainyearmonth
-ThrowCompletionOr<NonnullGCPtr<Object>> PlainYearMonthConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> PlainYearMonthConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.h b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.h
index 95966b24dd8..7dafaeda508 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class PlainYearMonthConstructor final : public NativeFunction {
     JS_OBJECT(PlainYearMonthConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(PlainYearMonthConstructor);
+    GC_DECLARE_ALLOCATOR(PlainYearMonthConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~PlainYearMonthConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit PlainYearMonthConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.cpp b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.cpp
index ef5041567ee..daf93e10a66 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.cpp
@@ -16,7 +16,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(PlainYearMonthPrototype);
+GC_DEFINE_ALLOCATOR(PlainYearMonthPrototype);
 
 // 9.3 Properties of the Temporal.PlainYearMonth Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-plainyearmonth-prototype-object
 PlainYearMonthPrototype::PlainYearMonthPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.h b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.h
index ab2464d9f68..feeb49a94ee 100644
--- a/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/PlainYearMonthPrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class PlainYearMonthPrototype final : public PrototypeObject<PlainYearMonthPrototype, PlainYearMonth> {
     JS_PROTOTYPE_OBJECT(PlainYearMonthPrototype, PlainYearMonth, Temporal.PlainYearMonth);
-    JS_DECLARE_ALLOCATOR(PlainYearMonthPrototype);
+    GC_DECLARE_ALLOCATOR(PlainYearMonthPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/Temporal.cpp b/Libraries/LibJS/Runtime/Temporal/Temporal.cpp
index df0dabfe940..c898c629c16 100644
--- a/Libraries/LibJS/Runtime/Temporal/Temporal.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/Temporal.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(Temporal);
+GC_DEFINE_ALLOCATOR(Temporal);
 
 // 1 The Temporal Object, https://tc39.es/proposal-temporal/#sec-temporal-objects
 Temporal::Temporal(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/Temporal/Temporal.h b/Libraries/LibJS/Runtime/Temporal/Temporal.h
index ed083f37883..1265381ec88 100644
--- a/Libraries/LibJS/Runtime/Temporal/Temporal.h
+++ b/Libraries/LibJS/Runtime/Temporal/Temporal.h
@@ -12,7 +12,7 @@ namespace JS::Temporal {
 
 class Temporal final : public Object {
     JS_OBJECT(Temporal, Object);
-    JS_DECLARE_ALLOCATOR(Temporal);
+    GC_DECLARE_ALLOCATOR(Temporal);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZone.cpp b/Libraries/LibJS/Runtime/Temporal/TimeZone.cpp
index 0f722a58ac2..96f9fbfadb7 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZone.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZone.cpp
@@ -24,7 +24,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(TimeZone);
+GC_DEFINE_ALLOCATOR(TimeZone);
 
 // 11 Temporal.TimeZone Objects, https://tc39.es/proposal-temporal/#sec-temporal-timezone-objects
 TimeZone::TimeZone(Object& prototype)
@@ -378,7 +378,7 @@ ThrowCompletionOr<double> get_offset_nanoseconds_for(VM& vm, TimeZoneMethods con
 // 11.6.9 BuiltinTimeZoneGetOffsetStringFor ( timeZone, instant ), https://tc39.es/proposal-temporal/#sec-temporal-builtintimezonegetoffsetstringfor
 ThrowCompletionOr<String> builtin_time_zone_get_offset_string_for(VM& vm, Value time_zone, Instant& instant)
 {
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
     // 1. Let offsetNanoseconds be ? GetOffsetNanosecondsFor(timeZone, instant).
     auto offset_nanoseconds = TRY(get_offset_nanoseconds_for(vm, time_zone_record, instant));
@@ -390,7 +390,7 @@ ThrowCompletionOr<String> builtin_time_zone_get_offset_string_for(VM& vm, Value
 // 11.6.10 BuiltinTimeZoneGetPlainDateTimeFor ( timeZone, instant, calendar ), https://tc39.es/proposal-temporal/#sec-temporal-builtintimezonegetplaindatetimefor
 ThrowCompletionOr<PlainDateTime*> builtin_time_zone_get_plain_date_time_for(VM& vm, Value time_zone, Instant& instant, Object& calendar)
 {
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
     // 1. Assert: instant has an [[InitializedTemporalInstant]] internal slot.
 
@@ -408,12 +408,12 @@ ThrowCompletionOr<PlainDateTime*> builtin_time_zone_get_plain_date_time_for(VM&
 }
 
 // 11.6.11 BuiltinTimeZoneGetInstantFor ( timeZone, dateTime, disambiguation ), https://tc39.es/proposal-temporal/#sec-temporal-builtintimezonegetinstantfor
-ThrowCompletionOr<NonnullGCPtr<Instant>> builtin_time_zone_get_instant_for(VM& vm, Value time_zone, PlainDateTime& date_time, StringView disambiguation)
+ThrowCompletionOr<GC::Ref<Instant>> builtin_time_zone_get_instant_for(VM& vm, Value time_zone, PlainDateTime& date_time, StringView disambiguation)
 {
     // 1. Assert: dateTime has an [[InitializedTemporalDateTime]] internal slot.
 
     // 2. Let possibleInstants be ? GetPossibleInstantsFor(timeZone, dateTime).
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetOffsetNanosecondsFor, TimeZoneMethod::GetPossibleInstantsFor } }));
     auto possible_instants = TRY(get_possible_instants_for(vm, time_zone_record, date_time));
 
     // 3. Return ? DisambiguatePossibleInstants(possibleInstants, timeZone, dateTime, disambiguation).
@@ -421,7 +421,7 @@ ThrowCompletionOr<NonnullGCPtr<Instant>> builtin_time_zone_get_instant_for(VM& v
 }
 
 // 11.6.12 DisambiguatePossibleInstants ( possibleInstants, timeZone, dateTime, disambiguation ), https://tc39.es/proposal-temporal/#sec-temporal-disambiguatepossibleinstants
-ThrowCompletionOr<NonnullGCPtr<Instant>> disambiguate_possible_instants(VM& vm, MarkedVector<NonnullGCPtr<Instant>> const& possible_instants, TimeZoneMethods const& time_zone_record, PlainDateTime& date_time, StringView disambiguation)
+ThrowCompletionOr<GC::Ref<Instant>> disambiguate_possible_instants(VM& vm, GC::MarkedVector<GC::Ref<Instant>> const& possible_instants, TimeZoneMethods const& time_zone_record, PlainDateTime& date_time, StringView disambiguation)
 {
     // 1. Assert: TimeZoneMethodsRecordHasLookedUp(timeZoneRec, GET-POSSIBLE-INSTANTS-FOR) is true.
     VERIFY(time_zone_methods_record_has_looked_up(time_zone_record, TimeZoneMethod::GetPossibleInstantsFor));
@@ -544,14 +544,14 @@ ThrowCompletionOr<NonnullGCPtr<Instant>> disambiguate_possible_instants(VM& vm,
 }
 
 // 11.5.24 GetPossibleInstantsFor ( timeZoneRec, dateTime ), https://tc39.es/proposal-temporal/#sec-temporal-getpossibleinstantsfor
-ThrowCompletionOr<MarkedVector<NonnullGCPtr<Instant>>> get_possible_instants_for(VM& vm, TimeZoneMethods const& time_zone_record, PlainDateTime const& date_time)
+ThrowCompletionOr<GC::MarkedVector<GC::Ref<Instant>>> get_possible_instants_for(VM& vm, TimeZoneMethods const& time_zone_record, PlainDateTime const& date_time)
 {
     // 1. Let possibleInstants be ? TimeZoneMethodsRecordCall(timeZoneRec, GET-POSSIBLE-INSTANTS-FOR, « dateTime »).
     auto possible_instants = TRY(time_zone_methods_record_call(vm, time_zone_record, TimeZoneMethod::GetPossibleInstantsFor, { { &date_time } }));
 
     // 2. If TimeZoneMethodsRecordIsBuiltin(timeZoneRec), return ! CreateListFromArrayLike(possibleInstants, « Object »).
     if (time_zone_methods_record_is_builtin(time_zone_record)) {
-        auto list = MarkedVector<NonnullGCPtr<Instant>> { vm.heap() };
+        auto list = GC::MarkedVector<GC::Ref<Instant>> { vm.heap() };
 
         (void)MUST(create_list_from_array_like(vm, possible_instants, [&list](auto value) -> ThrowCompletionOr<void> {
             list.append(verify_cast<Instant>(value.as_object()));
@@ -565,7 +565,7 @@ ThrowCompletionOr<MarkedVector<NonnullGCPtr<Instant>>> get_possible_instants_for
     auto iterator = TRY(get_iterator(vm, possible_instants, IteratorHint::Sync));
 
     // 4. Let list be a new empty List.
-    auto list = MarkedVector<NonnullGCPtr<Instant>> { vm.heap() };
+    auto list = GC::MarkedVector<GC::Ref<Instant>> { vm.heap() };
 
     // 5. Repeat,
     while (true) {
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZone.h b/Libraries/LibJS/Runtime/Temporal/TimeZone.h
index 1fda94550fc..3d781f70f4d 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZone.h
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZone.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/Optional.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/Object.h>
 #include <LibJS/Runtime/Temporal/AbstractOperations.h>
 
@@ -15,7 +15,7 @@ namespace JS::Temporal {
 
 class TimeZone final : public Object {
     JS_OBJECT(TimeZone, Object);
-    JS_DECLARE_ALLOCATOR(TimeZone);
+    GC_DECLARE_ALLOCATOR(TimeZone);
 
 public:
     // Needs to store values in the range -8.64 * 10^13 to 8.64 * 10^13
@@ -49,9 +49,9 @@ ThrowCompletionOr<Object*> to_temporal_time_zone(VM&, Value temporal_time_zone_l
 ThrowCompletionOr<double> get_offset_nanoseconds_for(VM& vm, TimeZoneMethods const& time_zone_record, Instant const& instant);
 ThrowCompletionOr<String> builtin_time_zone_get_offset_string_for(VM&, Value time_zone, Instant&);
 ThrowCompletionOr<PlainDateTime*> builtin_time_zone_get_plain_date_time_for(VM&, Value time_zone, Instant&, Object& calendar);
-ThrowCompletionOr<NonnullGCPtr<Instant>> builtin_time_zone_get_instant_for(VM&, Value time_zone, PlainDateTime&, StringView disambiguation);
-ThrowCompletionOr<NonnullGCPtr<Instant>> disambiguate_possible_instants(VM&, MarkedVector<NonnullGCPtr<Instant>> const& possible_instants, TimeZoneMethods const&, PlainDateTime&, StringView disambiguation);
-ThrowCompletionOr<MarkedVector<NonnullGCPtr<Instant>>> get_possible_instants_for(VM&, TimeZoneMethods const&, PlainDateTime const&);
+ThrowCompletionOr<GC::Ref<Instant>> builtin_time_zone_get_instant_for(VM&, Value time_zone, PlainDateTime&, StringView disambiguation);
+ThrowCompletionOr<GC::Ref<Instant>> disambiguate_possible_instants(VM&, GC::MarkedVector<GC::Ref<Instant>> const& possible_instants, TimeZoneMethods const&, PlainDateTime&, StringView disambiguation);
+ThrowCompletionOr<GC::MarkedVector<GC::Ref<Instant>>> get_possible_instants_for(VM&, TimeZoneMethods const&, PlainDateTime const&);
 ThrowCompletionOr<bool> time_zone_equals(VM&, Object& one, Object& two);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.cpp
index 352ee7fd230..df12a9a7681 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(TimeZoneConstructor);
+GC_DEFINE_ALLOCATOR(TimeZoneConstructor);
 
 // 11.2 The Temporal.TimeZone Constructor, https://tc39.es/proposal-temporal/#sec-temporal-timezone-constructor
 TimeZoneConstructor::TimeZoneConstructor(Realm& realm)
@@ -45,7 +45,7 @@ ThrowCompletionOr<Value> TimeZoneConstructor::call()
 }
 
 // 11.2.1 Temporal.TimeZone ( identifier ), https://tc39.es/proposal-temporal/#sec-temporal.timezone
-ThrowCompletionOr<NonnullGCPtr<Object>> TimeZoneConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> TimeZoneConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.h b/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.h
index 163ce8dae70..05305368062 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZoneConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class TimeZoneConstructor final : public NativeFunction {
     JS_OBJECT(TimeZoneConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(TimeZoneConstructor);
+    GC_DECLARE_ALLOCATOR(TimeZoneConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~TimeZoneConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit TimeZoneConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.cpp b/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.cpp
index 0fbc568fab2..85e60c15c2e 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.cpp
@@ -11,7 +11,7 @@
 namespace JS::Temporal {
 
 // 11.5.2 CreateTimeZoneMethodsRecord ( timeZone, methods ), https://tc39.es/proposal-temporal/#sec-temporal-createtimezonemethodsrecord
-ThrowCompletionOr<TimeZoneMethods> create_time_zone_methods_record(VM& vm, Variant<String, NonnullGCPtr<Object>> time_zone, ReadonlySpan<TimeZoneMethod> methods)
+ThrowCompletionOr<TimeZoneMethods> create_time_zone_methods_record(VM& vm, Variant<String, GC::Ref<Object>> time_zone, ReadonlySpan<TimeZoneMethod> methods)
 {
     // 1. Let record be the Time Zone Methods Record { [[Receiver]]: timeZone, [[GetOffsetNanosecondsFor]]: undefined, [[GetPossibleInstantsFor]]: undefined  }.
     TimeZoneMethods record {
@@ -56,7 +56,7 @@ ThrowCompletionOr<void> time_zone_methods_record_lookup(VM& vm, TimeZoneMethods&
             const auto& time_zone_prototype = *realm.intrinsics().temporal_time_zone_prototype();                         \
             time_zone_record.snake_name = time_zone_prototype.get_without_side_effects(vm.names.camelName).as_function(); \
         } else {                                                                                                          \
-            Value time_zone { time_zone_record.receiver.get<NonnullGCPtr<Object>>() };                                    \
+            Value time_zone { time_zone_record.receiver.get<GC::Ref<Object>>() };                                         \
             time_zone_record.snake_name = TRY(time_zone.get_method(vm, vm.names.camelName));                              \
             if (!time_zone_record.snake_name)                                                                             \
                 return vm.throw_completion<TypeError>(ErrorType::IsUndefined, #camelName##sv);                            \
@@ -110,11 +110,11 @@ ThrowCompletionOr<Value> time_zone_methods_record_call(VM& vm, TimeZoneMethods c
     // 2. Let receiver be timeZoneRec.[[Receiver]].
     // 3. If TimeZoneMethodsRecordIsBuiltin(timeZoneRec) is true, then
     //     a. Set receiver to ! CreateTemporalTimeZone(timeZoneRec.[[Receiver]]).
-    GCPtr<Object> receiver;
+    GC::Ptr<Object> receiver;
     if (time_zone_methods_record_is_builtin(time_zone_record))
         receiver = MUST(create_temporal_time_zone(vm, time_zone_record.receiver.get<String>()));
     else
-        receiver = time_zone_record.receiver.get<NonnullGCPtr<Object>>();
+        receiver = time_zone_record.receiver.get<GC::Ref<Object>>();
 
     // 4. If methodName is GET-OFFSET-NANOSECONDS-FOR, then
     //     a. Return ? Call(timeZoneRec.[[GetOffsetNanosecondsFor]], receiver, arguments).
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.h b/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.h
index 7eb309d84cc..b0c00487086 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.h
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZoneMethods.h
@@ -7,21 +7,21 @@
 #pragma once
 
 #include <AK/String.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 
 namespace JS::Temporal {
 
 // 11.5.1 Time Zone Methods Records, https://tc39.es/proposal-temporal/#sec-temporal-time-zone-methods-records
 struct TimeZoneMethods {
     // The time zone object, or a string indicating a built-in time zone.
-    Variant<String, NonnullGCPtr<Object>> receiver; // [[Reciever]]
+    Variant<String, GC::Ref<Object>> receiver; // [[Reciever]]
 
     // The time zone's getOffsetNanosecondsFor method. For a built-in time zone this is always %Temporal.TimeZone.prototype.getOffsetNanosecondsFor%.
-    GCPtr<FunctionObject> get_offset_nanoseconds_for; // [[GetOffsetNanosecondsFor]]
+    GC::Ptr<FunctionObject> get_offset_nanoseconds_for; // [[GetOffsetNanosecondsFor]]
 
     // The time zone's getPossibleInstantsFor method. For a built-in time zone this is always %Temporal.TimeZone.prototype.getPossibleInstantsFor%.
-    GCPtr<FunctionObject> get_possible_instants_for; // [[GetPossibleInstantsFor]]
+    GC::Ptr<FunctionObject> get_possible_instants_for; // [[GetPossibleInstantsFor]]
 };
 
 #define JS_ENUMERATE_TIME_ZONE_METHODS                                                           \
@@ -36,7 +36,7 @@ enum class TimeZoneMethod {
 };
 
 ThrowCompletionOr<void> time_zone_methods_record_lookup(VM&, TimeZoneMethods&, TimeZoneMethod);
-ThrowCompletionOr<TimeZoneMethods> create_time_zone_methods_record(VM&, Variant<String, NonnullGCPtr<Object>> time_zone, ReadonlySpan<TimeZoneMethod>);
+ThrowCompletionOr<TimeZoneMethods> create_time_zone_methods_record(VM&, Variant<String, GC::Ref<Object>> time_zone, ReadonlySpan<TimeZoneMethod>);
 bool time_zone_methods_record_has_looked_up(TimeZoneMethods const&, TimeZoneMethod);
 bool time_zone_methods_record_is_builtin(TimeZoneMethods const&);
 ThrowCompletionOr<Value> time_zone_methods_record_call(VM&, TimeZoneMethods const&, TimeZoneMethod, ReadonlySpan<Value> arguments);
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.cpp b/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.cpp
index a0705d0c532..680527eedff 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.cpp
@@ -17,7 +17,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(TimeZonePrototype);
+GC_DEFINE_ALLOCATOR(TimeZonePrototype);
 
 // 11.4 Properties of the Temporal.TimeZone Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-timezone-prototype-object
 TimeZonePrototype::TimeZonePrototype(Realm& realm)
@@ -158,7 +158,7 @@ JS_DEFINE_NATIVE_FUNCTION(TimeZonePrototype::get_possible_instants_for)
     }
 
     // 6. Let possibleInstants be a new empty List.
-    auto possible_instants = MarkedVector<Value> { vm.heap() };
+    auto possible_instants = GC::MarkedVector<Value> { vm.heap() };
 
     // 7. For each value epochNanoseconds in possibleEpochNanoseconds, do
     for (auto& epoch_nanoseconds : possible_epoch_nanoseconds) {
diff --git a/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.h b/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.h
index 8a9c79cac33..e994a8b986b 100644
--- a/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/TimeZonePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class TimeZonePrototype final : public PrototypeObject<TimeZonePrototype, TimeZone> {
     JS_PROTOTYPE_OBJECT(TimeZonePrototype, TimeZone, Temporal.TimeZone);
-    JS_DECLARE_ALLOCATOR(TimeZonePrototype);
+    GC_DECLARE_ALLOCATOR(TimeZonePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.cpp b/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.cpp
index 49a545f29c9..533cb520035 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(ZonedDateTime);
+GC_DEFINE_ALLOCATOR(ZonedDateTime);
 
 // 6 Temporal.ZonedDateTime Objects, https://tc39.es/proposal-temporal/#sec-temporal-zoneddatetime-objects
 ZonedDateTime::ZonedDateTime(BigInt const& nanoseconds, Object& time_zone, Object& calendar, Object& prototype)
@@ -81,7 +81,7 @@ ThrowCompletionOr<BigInt const*> interpret_iso_date_time_offset(VM& vm, i32 year
     VERIFY(offset_option.is_one_of("prefer"sv, "reject"sv));
 
     // 7. Let possibleInstants be ? GetPossibleInstantsFor(timeZone, dateTime).
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetPossibleInstantsFor, TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone.as_object() }, { { TimeZoneMethod::GetPossibleInstantsFor, TimeZoneMethod::GetOffsetNanosecondsFor } }));
     auto possible_instants = TRY(get_possible_instants_for(vm, time_zone_record, *date_time));
 
     // 8. For each element candidate of possibleInstants, do
@@ -329,7 +329,7 @@ ThrowCompletionOr<String> temporal_zoned_date_time_to_string(VM& vm, ZonedDateTi
     }
     // 11. Else,
     else {
-        auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+        auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
         // a. Let offsetNs be ? GetOffsetNanosecondsFor(timeZone, instant).
         auto offset_ns = TRY(get_offset_nanoseconds_for(vm, time_zone_record, *instant));
@@ -574,7 +574,7 @@ ThrowCompletionOr<NanosecondsToDaysResult> nanoseconds_to_days(VM& vm, Crypto::S
 }
 
 // 6.5.8 DifferenceTemporalZonedDateTime ( operation, zonedDateTime, other, options ), https://tc39.es/proposal-temporal/#sec-temporal-differencetemporalzoneddatetime
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_zoned_date_time(VM& vm, DifferenceOperation operation, ZonedDateTime& zoned_date_time, Value other_value, Value options_value)
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_zoned_date_time(VM& vm, DifferenceOperation operation, ZonedDateTime& zoned_date_time, Value other_value, Value options_value)
 {
     // 1. If operation is since, let sign be -1. Otherwise, let sign be 1.
     i8 sign = operation == DifferenceOperation::Since ? -1 : 1;
@@ -612,7 +612,7 @@ ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_zoned_date_time(VM
     // 8. Let difference be ? DifferenceZonedDateTime(zonedDateTime.[[Nanoseconds]], other.[[Nanoseconds]], zonedDateTime.[[TimeZone]], zonedDateTime.[[Calendar]], settings.[[LargestUnit]], untilOptions).
     auto difference = TRY(difference_zoned_date_time(vm, zoned_date_time.nanoseconds(), other->nanoseconds(), zoned_date_time.time_zone(), zoned_date_time.calendar(), settings.largest_unit, *until_options));
 
-    auto calendar_record = TRY(create_calendar_methods_record(vm, NonnullGCPtr<Object> { zoned_date_time.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateFromFields, CalendarMethod::DateUntil, CalendarMethod::Fields } }));
+    auto calendar_record = TRY(create_calendar_methods_record(vm, GC::Ref<Object> { zoned_date_time.calendar() }, { { CalendarMethod::DateAdd, CalendarMethod::DateFromFields, CalendarMethod::DateUntil, CalendarMethod::Fields } }));
 
     // 9. Let roundResult be (? RoundDuration(difference.[[Years]], difference.[[Months]], difference.[[Weeks]], difference.[[Days]], difference.[[Hours]], difference.[[Minutes]], difference.[[Seconds]], difference.[[Milliseconds]], difference.[[Microseconds]], difference.[[Nanoseconds]], settings.[[RoundingIncrement]], settings.[[SmallestUnit]], settings.[[RoundingMode]], zonedDateTime)).[[DurationRecord]].
     auto round_result = TRY(round_duration(vm, difference.years, difference.months, difference.weeks, difference.days, difference.hours, difference.minutes, difference.seconds, difference.milliseconds, difference.microseconds, difference.nanoseconds, settings.rounding_increment, settings.smallest_unit, settings.rounding_mode, &zoned_date_time, calendar_record)).duration_record;
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.h b/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.h
index 965951b6ac7..c3fc6a93298 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.h
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTime.h
@@ -14,7 +14,7 @@ namespace JS::Temporal {
 
 class ZonedDateTime final : public Object {
     JS_OBJECT(ZonedDateTime, Object);
-    JS_DECLARE_ALLOCATOR(ZonedDateTime);
+    GC_DECLARE_ALLOCATOR(ZonedDateTime);
 
 public:
     virtual ~ZonedDateTime() override = default;
@@ -31,9 +31,9 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // 6.4 Properties of Temporal.ZonedDateTime Instances, https://tc39.es/proposal-temporal/#sec-properties-of-temporal-zoneddatetime-instances
-    NonnullGCPtr<BigInt const> m_nanoseconds; // [[Nanoseconds]]
-    NonnullGCPtr<Object> m_time_zone;         // [[TimeZone]]
-    NonnullGCPtr<Object> m_calendar;          // [[Calendar]]
+    GC::Ref<BigInt const> m_nanoseconds; // [[Nanoseconds]]
+    GC::Ref<Object> m_time_zone;         // [[TimeZone]]
+    GC::Ref<Object> m_calendar;          // [[Calendar]]
 };
 
 struct NanosecondsToDaysResult {
@@ -60,7 +60,7 @@ ThrowCompletionOr<String> temporal_zoned_date_time_to_string(VM&, ZonedDateTime&
 ThrowCompletionOr<BigInt*> add_zoned_date_time(VM&, BigInt const& epoch_nanoseconds, Value time_zone, Object& calendar, double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds, Object* options = nullptr);
 ThrowCompletionOr<DurationRecord> difference_zoned_date_time(VM&, BigInt const& nanoseconds1, BigInt const& nanoseconds2, Object& time_zone, Object& calendar, StringView largest_unit, Object const& options);
 ThrowCompletionOr<NanosecondsToDaysResult> nanoseconds_to_days(VM&, Crypto::SignedBigInteger nanoseconds, Value relative_to);
-ThrowCompletionOr<NonnullGCPtr<Duration>> difference_temporal_zoned_date_time(VM&, DifferenceOperation, ZonedDateTime&, Value other, Value options);
+ThrowCompletionOr<GC::Ref<Duration>> difference_temporal_zoned_date_time(VM&, DifferenceOperation, ZonedDateTime&, Value other, Value options);
 ThrowCompletionOr<ZonedDateTime*> add_duration_to_or_subtract_duration_from_zoned_date_time(VM&, ArithmeticOperation, ZonedDateTime&, Value temporal_duration_like, Value options_value);
 
 }
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.cpp b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.cpp
index 18ece4731b7..dd7b4f14d9e 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.cpp
@@ -15,7 +15,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(ZonedDateTimeConstructor);
+GC_DEFINE_ALLOCATOR(ZonedDateTimeConstructor);
 
 // 6.1 The Temporal.ZonedDateTime Constructor, https://tc39.es/proposal-temporal/#sec-temporal-zoneddatetime-constructor
 ZonedDateTimeConstructor::ZonedDateTimeConstructor(Realm& realm)
@@ -50,7 +50,7 @@ ThrowCompletionOr<Value> ZonedDateTimeConstructor::call()
 }
 
 // 6.1.1 Temporal.ZonedDateTime ( epochNanoseconds, timeZoneLike [ , calendarLike ] ), https://tc39.es/proposal-temporal/#sec-temporal.zoneddatetime
-ThrowCompletionOr<NonnullGCPtr<Object>> ZonedDateTimeConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> ZonedDateTimeConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.h b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.h
index 423cb616585..2ee8c13a051 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.h
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimeConstructor.h
@@ -12,14 +12,14 @@ namespace JS::Temporal {
 
 class ZonedDateTimeConstructor final : public NativeFunction {
     JS_OBJECT(ZonedDateTimeConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(ZonedDateTimeConstructor);
+    GC_DECLARE_ALLOCATOR(ZonedDateTimeConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~ZonedDateTimeConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 private:
     explicit ZonedDateTimeConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.cpp b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.cpp
index 7fdf9da35a3..d78d4ed1ada 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.cpp
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.cpp
@@ -20,7 +20,7 @@
 
 namespace JS::Temporal {
 
-JS_DEFINE_ALLOCATOR(ZonedDateTimePrototype);
+GC_DEFINE_ALLOCATOR(ZonedDateTimePrototype);
 
 // 6.3 Properties of the Temporal.ZonedDateTime Prototype Object, https://tc39.es/proposal-temporal/#sec-properties-of-the-temporal-zoneddatetime-prototype-object
 ZonedDateTimePrototype::ZonedDateTimePrototype(Realm& realm)
@@ -676,7 +676,7 @@ JS_DEFINE_NATIVE_FUNCTION(ZonedDateTimePrototype::offset_nanoseconds_getter)
 
     // 3. Let timeZone be zonedDateTime.[[TimeZone]].
     // 3. Let timeZoneRec be ? CreateTimeZoneMethodsRecord(zonedDateTime.[[TimeZone]], « GET-OFFSET-NANOSECONDS-FOR »).
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { zoned_date_time->time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { zoned_date_time->time_zone() }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
     // 4. Let instant be ! CreateTemporalInstant(zonedDateTime.[[Nanoseconds]]).
     auto* instant = MUST(create_temporal_instant(vm, zoned_date_time->nanoseconds()));
@@ -1045,7 +1045,7 @@ JS_DEFINE_NATIVE_FUNCTION(ZonedDateTimePrototype::round)
     // 12. Let timeZone be zonedDateTime.[[TimeZone]].
     auto& time_zone = zoned_date_time->time_zone();
 
-    auto time_zone_record = TRY(create_time_zone_methods_record(vm, NonnullGCPtr<Object> { time_zone }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
+    auto time_zone_record = TRY(create_time_zone_methods_record(vm, GC::Ref<Object> { time_zone }, { { TimeZoneMethod::GetOffsetNanosecondsFor } }));
 
     // 13. Let instant be ! CreateTemporalInstant(zonedDateTime.[[Nanoseconds]]).
     auto* instant = MUST(create_temporal_instant(vm, zoned_date_time->nanoseconds()));
diff --git a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.h b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.h
index 8708b98a932..ff585374352 100644
--- a/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.h
+++ b/Libraries/LibJS/Runtime/Temporal/ZonedDateTimePrototype.h
@@ -13,7 +13,7 @@ namespace JS::Temporal {
 
 class ZonedDateTimePrototype final : public PrototypeObject<ZonedDateTimePrototype, ZonedDateTime> {
     JS_PROTOTYPE_OBJECT(ZonedDateTimePrototype, ZonedDateTime, Temporal.ZonedDateTime);
-    JS_DECLARE_ALLOCATOR(ZonedDateTimePrototype);
+    GC_DECLARE_ALLOCATOR(ZonedDateTimePrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/TypedArray.cpp b/Libraries/LibJS/Runtime/TypedArray.cpp
index 254492178ad..637d06d0a67 100644
--- a/Libraries/LibJS/Runtime/TypedArray.cpp
+++ b/Libraries/LibJS/Runtime/TypedArray.cpp
@@ -288,7 +288,7 @@ static ThrowCompletionOr<void> initialize_typed_array_from_array_like(VM& vm, Ty
 
 // 23.2.5.1.4 InitializeTypedArrayFromList, https://tc39.es/ecma262/#sec-initializetypedarrayfromlist
 template<typename T>
-static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArray<T>& typed_array, MarkedVector<Value> const& list)
+static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArray<T>& typed_array, GC::MarkedVector<Value> const& list)
 {
     // 1. Let len be the number of elements in values.
     auto length = list.size();
@@ -315,7 +315,7 @@ static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArr
 }
 
 // 23.2.4.2 TypedArrayCreate ( constructor, argumentList ), https://tc39.es/ecma262/#typedarray-create
-ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& constructor, MarkedVector<Value> arguments)
+ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& constructor, GC::MarkedVector<Value> arguments)
 {
     Optional<double> first_argument;
     if (arguments.size() == 1 && arguments[0].is_number())
@@ -346,7 +346,7 @@ ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& co
 }
 
 // 23.2.4.3 TypedArrayCreateSameType ( exemplar, argumentList ), https://tc39.es/ecma262/#sec-typedarray-create-same-type
-ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM& vm, TypedArrayBase const& exemplar, MarkedVector<Value> arguments)
+ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM& vm, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments)
 {
     auto& realm = *vm.current_realm();
 
@@ -446,23 +446,23 @@ void TypedArrayBase::visit_edges(Visitor& visitor)
 }
 
 #define JS_DEFINE_TYPED_ARRAY(ClassName, snake_name, PrototypeName, ConstructorName, Type)                                  \
-    JS_DEFINE_ALLOCATOR(ClassName);                                                                                         \
-    JS_DEFINE_ALLOCATOR(PrototypeName);                                                                                     \
-    JS_DEFINE_ALLOCATOR(ConstructorName);                                                                                   \
-    ThrowCompletionOr<NonnullGCPtr<ClassName>> ClassName::create(Realm& realm, u32 length, FunctionObject& new_target)      \
+    GC_DEFINE_ALLOCATOR(ClassName);                                                                                         \
+    GC_DEFINE_ALLOCATOR(PrototypeName);                                                                                     \
+    GC_DEFINE_ALLOCATOR(ConstructorName);                                                                                   \
+    ThrowCompletionOr<GC::Ref<ClassName>> ClassName::create(Realm& realm, u32 length, FunctionObject& new_target)           \
     {                                                                                                                       \
         auto* prototype = TRY(get_prototype_from_constructor(realm.vm(), new_target, &Intrinsics::snake_name##_prototype)); \
         auto array_buffer = TRY(ArrayBuffer::create(realm, length * sizeof(UnderlyingBufferDataType)));                     \
         return realm.create<ClassName>(*prototype, length, *array_buffer);                                                  \
     }                                                                                                                       \
                                                                                                                             \
-    ThrowCompletionOr<NonnullGCPtr<ClassName>> ClassName::create(Realm& realm, u32 length)                                  \
+    ThrowCompletionOr<GC::Ref<ClassName>> ClassName::create(Realm& realm, u32 length)                                       \
     {                                                                                                                       \
         auto array_buffer = TRY(ArrayBuffer::create(realm, length * sizeof(UnderlyingBufferDataType)));                     \
         return create(realm, length, *array_buffer);                                                                        \
     }                                                                                                                       \
                                                                                                                             \
-    NonnullGCPtr<ClassName> ClassName::create(Realm& realm, u32 length, ArrayBuffer& array_buffer)                          \
+    GC::Ref<ClassName> ClassName::create(Realm& realm, u32 length, ArrayBuffer& array_buffer)                               \
     {                                                                                                                       \
         return realm.create<ClassName>(realm.intrinsics().snake_name##_prototype(), length, array_buffer);                  \
     }                                                                                                                       \
@@ -540,7 +540,7 @@ void TypedArrayBase::visit_edges(Visitor& visitor)
     }                                                                                                                       \
                                                                                                                             \
     /* 23.2.5.1 TypedArray ( ...args ), https://tc39.es/ecma262/#sec-typedarray */                                          \
-    ThrowCompletionOr<NonnullGCPtr<Object>> ConstructorName::construct(FunctionObject& new_target)                          \
+    ThrowCompletionOr<GC::Ref<Object>> ConstructorName::construct(FunctionObject& new_target)                               \
     {                                                                                                                       \
         auto& vm = this->vm();                                                                                              \
         auto& realm = *vm.current_realm();                                                                                  \
diff --git a/Libraries/LibJS/Runtime/TypedArray.h b/Libraries/LibJS/Runtime/TypedArray.h
index 7f211e12ce0..fdf6fb905d8 100644
--- a/Libraries/LibJS/Runtime/TypedArray.h
+++ b/Libraries/LibJS/Runtime/TypedArray.h
@@ -35,7 +35,7 @@ public:
 #undef __JS_ENUMERATE
     };
 
-    using IntrinsicConstructor = NonnullGCPtr<TypedArrayConstructor> (Intrinsics::*)();
+    using IntrinsicConstructor = GC::Ref<TypedArrayConstructor> (Intrinsics::*)();
 
     ByteLength const& array_length() const { return m_array_length; }
     ByteLength const& byte_length() const { return m_byte_length; }
@@ -81,7 +81,7 @@ protected:
     u32 m_byte_offset { 0 };
     ContentType m_content_type { ContentType::Number };
     Kind m_kind {};
-    GCPtr<ArrayBuffer> m_viewed_array_buffer;
+    GC::Ptr<ArrayBuffer> m_viewed_array_buffer;
     IntrinsicConstructor m_intrinsic_constructor { nullptr };
 
 private:
@@ -90,8 +90,8 @@ private:
 
 // 10.4.5.8 TypedArray With Buffer Witness Records, https://tc39.es/ecma262/#sec-typedarray-with-buffer-witness-records
 struct TypedArrayWithBufferWitness {
-    NonnullGCPtr<TypedArrayBase const> object; // [[Object]]
-    ByteLength cached_buffer_byte_length;      // [[CachedBufferByteLength]]
+    GC::Ref<TypedArrayBase const> object; // [[Object]]
+    ByteLength cached_buffer_byte_length; // [[CachedBufferByteLength]]
 };
 
 TypedArrayWithBufferWitness make_typed_array_with_buffer_witness_record(TypedArrayBase const&, ArrayBuffer::Order);
@@ -397,7 +397,7 @@ public:
     }
 
     // 10.4.5.7 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-integer-indexed-exotic-objects-ownpropertykeys
-    virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const override
+    virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override
     {
         auto& vm = this->vm();
 
@@ -405,7 +405,7 @@ public:
         auto typed_array_record = make_typed_array_with_buffer_witness_record(*this, ArrayBuffer::Order::SeqCst);
 
         // 2. Let keys be a new empty List.
-        auto keys = MarkedVector<Value> { heap() };
+        auto keys = GC::MarkedVector<Value> { heap() };
 
         // 3. If IsTypedArrayOutOfBounds(taRecord) is false, then
         if (!is_typed_array_out_of_bounds(typed_array_record)) {
@@ -495,54 +495,54 @@ protected:
 };
 
 ThrowCompletionOr<TypedArrayBase*> typed_array_from(VM&, Value);
-ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM&, FunctionObject& constructor, MarkedVector<Value> arguments);
-ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM&, TypedArrayBase const& exemplar, MarkedVector<Value> arguments);
+ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM&, FunctionObject& constructor, GC::MarkedVector<Value> arguments);
+ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM&, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments);
 ThrowCompletionOr<TypedArrayWithBufferWitness> validate_typed_array(VM&, Object const&, ArrayBuffer::Order);
 ThrowCompletionOr<double> compare_typed_array_elements(VM&, Value x, Value y, FunctionObject* comparefn);
 
-#define JS_DECLARE_TYPED_ARRAY(ClassName, snake_name, PrototypeName, ConstructorName, Type)                       \
-    class ClassName : public TypedArray<Type> {                                                                   \
-        JS_OBJECT(ClassName, TypedArray);                                                                         \
-        JS_DECLARE_ALLOCATOR(ClassName);                                                                          \
-                                                                                                                  \
-    public:                                                                                                       \
-        virtual ~ClassName();                                                                                     \
-        static ThrowCompletionOr<NonnullGCPtr<ClassName>> create(Realm&, u32 length, FunctionObject& new_target); \
-        static ThrowCompletionOr<NonnullGCPtr<ClassName>> create(Realm&, u32 length);                             \
-        static NonnullGCPtr<ClassName> create(Realm&, u32 length, ArrayBuffer& buffer);                           \
-        virtual DeprecatedFlyString const& element_name() const override;                                         \
-                                                                                                                  \
-    protected:                                                                                                    \
-        ClassName(Object& prototype, u32 length, ArrayBuffer& array_buffer);                                      \
-    };                                                                                                            \
-    class PrototypeName final : public Object {                                                                   \
-        JS_OBJECT(PrototypeName, Object);                                                                         \
-        JS_DECLARE_ALLOCATOR(PrototypeName);                                                                      \
-                                                                                                                  \
-    public:                                                                                                       \
-        virtual void initialize(Realm&) override;                                                                 \
-        virtual ~PrototypeName() override;                                                                        \
-                                                                                                                  \
-    private:                                                                                                      \
-        PrototypeName(Object& prototype);                                                                         \
-    };                                                                                                            \
-    class ConstructorName final : public NativeFunction {                                                         \
-        JS_OBJECT(ConstructorName, NativeFunction);                                                               \
-        JS_DECLARE_ALLOCATOR(ConstructorName);                                                                    \
-                                                                                                                  \
-    public:                                                                                                       \
-        virtual void initialize(Realm&) override;                                                                 \
-        virtual ~ConstructorName() override;                                                                      \
-                                                                                                                  \
-        virtual ThrowCompletionOr<Value> call() override;                                                         \
-        virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;           \
-                                                                                                                  \
-    private:                                                                                                      \
-        explicit ConstructorName(Realm&, Object& prototype);                                                      \
-        virtual bool has_constructor() const override                                                             \
-        {                                                                                                         \
-            return true;                                                                                          \
-        }                                                                                                         \
+#define JS_DECLARE_TYPED_ARRAY(ClassName, snake_name, PrototypeName, ConstructorName, Type)                  \
+    class ClassName : public TypedArray<Type> {                                                              \
+        JS_OBJECT(ClassName, TypedArray);                                                                    \
+        GC_DECLARE_ALLOCATOR(ClassName);                                                                     \
+                                                                                                             \
+    public:                                                                                                  \
+        virtual ~ClassName();                                                                                \
+        static ThrowCompletionOr<GC::Ref<ClassName>> create(Realm&, u32 length, FunctionObject& new_target); \
+        static ThrowCompletionOr<GC::Ref<ClassName>> create(Realm&, u32 length);                             \
+        static GC::Ref<ClassName> create(Realm&, u32 length, ArrayBuffer& buffer);                           \
+        virtual DeprecatedFlyString const& element_name() const override;                                    \
+                                                                                                             \
+    protected:                                                                                               \
+        ClassName(Object& prototype, u32 length, ArrayBuffer& array_buffer);                                 \
+    };                                                                                                       \
+    class PrototypeName final : public Object {                                                              \
+        JS_OBJECT(PrototypeName, Object);                                                                    \
+        GC_DECLARE_ALLOCATOR(PrototypeName);                                                                 \
+                                                                                                             \
+    public:                                                                                                  \
+        virtual void initialize(Realm&) override;                                                            \
+        virtual ~PrototypeName() override;                                                                   \
+                                                                                                             \
+    private:                                                                                                 \
+        PrototypeName(Object& prototype);                                                                    \
+    };                                                                                                       \
+    class ConstructorName final : public NativeFunction {                                                    \
+        JS_OBJECT(ConstructorName, NativeFunction);                                                          \
+        GC_DECLARE_ALLOCATOR(ConstructorName);                                                               \
+                                                                                                             \
+    public:                                                                                                  \
+        virtual void initialize(Realm&) override;                                                            \
+        virtual ~ConstructorName() override;                                                                 \
+                                                                                                             \
+        virtual ThrowCompletionOr<Value> call() override;                                                    \
+        virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;           \
+                                                                                                             \
+    private:                                                                                                 \
+        explicit ConstructorName(Realm&, Object& prototype);                                                 \
+        virtual bool has_constructor() const override                                                        \
+        {                                                                                                    \
+            return true;                                                                                     \
+        }                                                                                                    \
     };
 
 #define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, Type) \
diff --git a/Libraries/LibJS/Runtime/TypedArrayConstructor.cpp b/Libraries/LibJS/Runtime/TypedArrayConstructor.cpp
index 8ebe1ed3a52..7509772cf70 100644
--- a/Libraries/LibJS/Runtime/TypedArrayConstructor.cpp
+++ b/Libraries/LibJS/Runtime/TypedArrayConstructor.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(TypedArrayConstructor);
+GC_DEFINE_ALLOCATOR(TypedArrayConstructor);
 
 TypedArrayConstructor::TypedArrayConstructor(DeprecatedFlyString const& name, Object& prototype)
     : NativeFunction(name, prototype)
@@ -47,7 +47,7 @@ ThrowCompletionOr<Value> TypedArrayConstructor::call()
 }
 
 // 23.2.1.1 %TypedArray% ( ), https://tc39.es/ecma262/#sec-%typedarray%
-ThrowCompletionOr<NonnullGCPtr<Object>> TypedArrayConstructor::construct(FunctionObject&)
+ThrowCompletionOr<GC::Ref<Object>> TypedArrayConstructor::construct(FunctionObject&)
 {
     // 1. Throw a TypeError exception.
     return vm().throw_completion<TypeError>(ErrorType::ClassIsAbstract, "TypedArray");
@@ -68,7 +68,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::from)
         return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, constructor.to_string_without_side_effects());
 
     // 3. If mapfn is undefined, let mapping be false.
-    GCPtr<FunctionObject> map_fn;
+    GC::Ptr<FunctionObject> map_fn;
 
     // 4. Else,
     if (!map_fn_value.is_undefined()) {
@@ -92,7 +92,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::from)
         auto length = values.size();
 
         // c. Let targetObj be ? TypedArrayCreate(C, « 𝔽(len) »).
-        MarkedVector<Value> arguments(vm.heap());
+        GC::MarkedVector<Value> arguments(vm.heap());
         arguments.empend(length);
         auto* target_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));
 
@@ -139,7 +139,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::from)
     auto length = TRY(length_of_array_like(vm, array_like));
 
     // 10. Let targetObj be ? TypedArrayCreate(C, « 𝔽(len) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(length);
     auto* target_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));
 
@@ -188,7 +188,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::of)
         return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, constructor.to_string_without_side_effects());
 
     // 4. Let newObj be ? TypedArrayCreate(C, « 𝔽(len) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.append(Value(length));
     auto* new_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));
 
diff --git a/Libraries/LibJS/Runtime/TypedArrayConstructor.h b/Libraries/LibJS/Runtime/TypedArrayConstructor.h
index 686ebdef488..5fce614cb15 100644
--- a/Libraries/LibJS/Runtime/TypedArrayConstructor.h
+++ b/Libraries/LibJS/Runtime/TypedArrayConstructor.h
@@ -12,7 +12,7 @@ namespace JS {
 
 class TypedArrayConstructor : public NativeFunction {
     JS_OBJECT(TypedArrayConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(TypedArrayConstructor);
+    GC_DECLARE_ALLOCATOR(TypedArrayConstructor);
 
 public:
     explicit TypedArrayConstructor(Realm&);
@@ -20,7 +20,7 @@ public:
     virtual ~TypedArrayConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject& new_target) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject& new_target) override;
 
 protected:
     TypedArrayConstructor(DeprecatedFlyString const& name, Object& prototype);
diff --git a/Libraries/LibJS/Runtime/TypedArrayPrototype.cpp b/Libraries/LibJS/Runtime/TypedArrayPrototype.cpp
index 7ace8e57669..a0f6af2ca94 100644
--- a/Libraries/LibJS/Runtime/TypedArrayPrototype.cpp
+++ b/Libraries/LibJS/Runtime/TypedArrayPrototype.cpp
@@ -17,7 +17,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(TypedArrayPrototype);
+GC_DEFINE_ALLOCATOR(TypedArrayPrototype);
 
 TypedArrayPrototype::TypedArrayPrototype(Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
@@ -81,7 +81,7 @@ static ThrowCompletionOr<TypedArrayBase*> typed_array_from_this(VM& vm)
     return typed_array_from(vm, this_value);
 }
 
-static ThrowCompletionOr<NonnullGCPtr<FunctionObject>> callback_from_args(VM& vm, StringView prototype_name)
+static ThrowCompletionOr<GC::Ref<FunctionObject>> callback_from_args(VM& vm, StringView prototype_name)
 {
     if (vm.argument_count() < 1)
         return vm.throw_completion<TypeError>(ErrorType::TypedArrayPrototypeOneArg, prototype_name);
@@ -92,7 +92,7 @@ static ThrowCompletionOr<NonnullGCPtr<FunctionObject>> callback_from_args(VM& vm
 }
 
 // 23.2.4.1 TypedArraySpeciesCreate ( exemplar, argumentList ), https://tc39.es/ecma262/#typedarray-species-create
-static ThrowCompletionOr<TypedArrayBase*> typed_array_species_create(VM& vm, TypedArrayBase const& exemplar, MarkedVector<Value> arguments)
+static ThrowCompletionOr<TypedArrayBase*> typed_array_species_create(VM& vm, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments)
 {
     auto& realm = *vm.current_realm();
 
@@ -634,7 +634,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::filter)
     auto callback_function = TRY(callback_from_args(vm, "filter"sv));
 
     // 5. Let kept be a new empty List.
-    MarkedVector<Value> kept { vm.heap() };
+    GC::MarkedVector<Value> kept { vm.heap() };
 
     // 6. Let captured be 0.
     size_t captured = 0;
@@ -664,7 +664,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::filter)
     }
 
     // 9. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(captured) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(captured);
     auto* filter_array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
 
@@ -1186,7 +1186,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::map)
     auto callback_function = TRY(callback_from_args(vm, "map"sv));
 
     // 5. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(len) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(length);
     auto* array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
 
@@ -1660,7 +1660,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::slice)
     auto count = max(final - k, 0);
 
     // 13. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(count) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(count);
     auto* array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
 
@@ -1905,7 +1905,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::subarray)
         return typed_array;
     }
 
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
 
     // 15. If O.[[ArrayLength]] is auto and end is undefined, then
     if (typed_array->array_length().is_auto() && end.is_undefined()) {
@@ -2013,7 +2013,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::to_reversed)
     auto length = typed_array_length(typed_array_record);
 
     // 4. Let A be ? TypedArrayCreateSameType(O, « 𝔽(length) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(length);
     auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));
 
@@ -2058,7 +2058,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::to_sorted)
     auto length = typed_array_length(typed_array_record);
 
     // 5. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(length);
     auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));
 
@@ -2138,7 +2138,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::with)
         return vm.throw_completion<RangeError>(ErrorType::TypedArrayInvalidIntegerIndex, actual_index);
 
     // 10. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
-    MarkedVector<Value> arguments(vm.heap());
+    GC::MarkedVector<Value> arguments(vm.heap());
     arguments.empend(length);
     auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));
 
diff --git a/Libraries/LibJS/Runtime/TypedArrayPrototype.h b/Libraries/LibJS/Runtime/TypedArrayPrototype.h
index 684c8e246bb..eeb777d8159 100644
--- a/Libraries/LibJS/Runtime/TypedArrayPrototype.h
+++ b/Libraries/LibJS/Runtime/TypedArrayPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class TypedArrayPrototype final : public Object {
     JS_OBJECT(TypedArrayPrototype, Object);
-    JS_DECLARE_ALLOCATOR(TypedArrayPrototype);
+    GC_DECLARE_ALLOCATOR(TypedArrayPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/Uint8Array.cpp b/Libraries/LibJS/Runtime/Uint8Array.cpp
index d28744c02c4..c2f85387654 100644
--- a/Libraries/LibJS/Runtime/Uint8Array.cpp
+++ b/Libraries/LibJS/Runtime/Uint8Array.cpp
@@ -369,7 +369,7 @@ JS_DEFINE_NATIVE_FUNCTION(Uint8ArrayPrototypeHelpers::set_from_hex)
 }
 
 // 7 ValidateUint8Array ( ta ), https://tc39.es/proposal-arraybuffer-base64/spec/#sec-validateuint8array
-ThrowCompletionOr<NonnullGCPtr<TypedArrayBase>> validate_uint8_array(VM& vm)
+ThrowCompletionOr<GC::Ref<TypedArrayBase>> validate_uint8_array(VM& vm)
 {
     auto this_object = TRY(vm.this_value().to_object(vm));
 
diff --git a/Libraries/LibJS/Runtime/Uint8Array.h b/Libraries/LibJS/Runtime/Uint8Array.h
index f5e8929ea8f..c78255b5ff3 100644
--- a/Libraries/LibJS/Runtime/Uint8Array.h
+++ b/Libraries/LibJS/Runtime/Uint8Array.h
@@ -9,8 +9,8 @@
 #include <AK/ByteBuffer.h>
 #include <AK/Optional.h>
 #include <AK/StringView.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Value.h>
 
@@ -53,7 +53,7 @@ struct DecodeResult {
     Optional<Completion> error; // [[Error]]
 };
 
-ThrowCompletionOr<NonnullGCPtr<TypedArrayBase>> validate_uint8_array(VM&);
+ThrowCompletionOr<GC::Ref<TypedArrayBase>> validate_uint8_array(VM&);
 ThrowCompletionOr<ByteBuffer> get_uint8_array_bytes(VM&, TypedArrayBase const&);
 void set_uint8_array_bytes(TypedArrayBase&, ReadonlyBytes);
 DecodeResult from_base64(VM&, StringView string, Alphabet alphabet, LastChunkHandling last_chunk_handling, Optional<size_t> max_length = {});
diff --git a/Libraries/LibJS/Runtime/VM.cpp b/Libraries/LibJS/Runtime/VM.cpp
index ff432517807..ada54461755 100644
--- a/Libraries/LibJS/Runtime/VM.cpp
+++ b/Libraries/LibJS/Runtime/VM.cpp
@@ -62,7 +62,7 @@ static constexpr auto make_single_ascii_character_strings(IndexSequence<code_poi
 static constexpr auto single_ascii_character_strings = make_single_ascii_character_strings(MakeIndexSequence<128>());
 
 VM::VM(OwnPtr<CustomData> custom_data, ErrorMessages error_messages)
-    : m_heap(this, [this](HashMap<CellImpl*, JS::HeapRoot>& roots) {
+    : m_heap(this, [this](HashMap<GC::Cell*, GC::HeapRoot>& roots) {
         gather_roots(roots);
     })
     , m_error_messages(move(error_messages))
@@ -99,7 +99,7 @@ VM::VM(OwnPtr<CustomData> custom_data, ErrorMessages error_messages)
         enqueue_finalization_registry_cleanup_job(finalization_registry);
     };
 
-    host_enqueue_promise_job = [this](NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>> job, Realm* realm) {
+    host_enqueue_promise_job = [this](GC::Ref<GC::Function<ThrowCompletionOr<Value>()>> job, Realm* realm) {
         enqueue_promise_job(job, realm);
     };
 
@@ -107,7 +107,7 @@ VM::VM(OwnPtr<CustomData> custom_data, ErrorMessages error_messages)
         return make_job_callback(function_object);
     };
 
-    host_load_imported_module = [this](ImportedModuleReferrer referrer, ModuleRequest const& module_request, GCPtr<GraphLoadingState::HostDefined> load_state, ImportedModulePayload payload) -> void {
+    host_load_imported_module = [this](ImportedModuleReferrer referrer, ModuleRequest const& module_request, GC::Ptr<GraphLoadingState::HostDefined> load_state, ImportedModulePayload payload) -> void {
         return load_imported_module(referrer, module_request, load_state, move(payload));
     };
 
@@ -204,7 +204,7 @@ Bytecode::Interpreter& VM::bytecode_interpreter()
 }
 
 struct ExecutionContextRootsCollector : public Cell::Visitor {
-    virtual void visit_impl(CellImpl& cell) override
+    virtual void visit_impl(GC::Cell& cell) override
     {
         roots.set(&cell);
     }
@@ -214,41 +214,41 @@ struct ExecutionContextRootsCollector : public Cell::Visitor {
         VERIFY_NOT_REACHED();
     }
 
-    HashTable<GCPtr<CellImpl>> roots;
+    HashTable<GC::Ptr<GC::Cell>> roots;
 };
 
-void VM::gather_roots(HashMap<CellImpl*, HeapRoot>& roots)
+void VM::gather_roots(HashMap<GC::Cell*, GC::HeapRoot>& roots)
 {
-    roots.set(m_empty_string, HeapRoot { .type = HeapRoot::Type::VM });
+    roots.set(m_empty_string, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
     for (auto string : m_single_ascii_character_strings)
-        roots.set(string, HeapRoot { .type = HeapRoot::Type::VM });
+        roots.set(string, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
 
-    roots.set(typeof_strings.number, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.undefined, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.object, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.string, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.symbol, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.boolean, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.bigint, HeapRoot { .type = HeapRoot::Type::VM });
-    roots.set(typeof_strings.function, HeapRoot { .type = HeapRoot::Type::VM });
+    roots.set(typeof_strings.number, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.undefined, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.object, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.string, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.symbol, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.boolean, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.bigint, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
+    roots.set(typeof_strings.function, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
 
 #define __JS_ENUMERATE(SymbolName, snake_name) \
-    roots.set(m_well_known_symbols.snake_name, HeapRoot { .type = HeapRoot::Type::VM });
+    roots.set(m_well_known_symbols.snake_name, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
     JS_ENUMERATE_WELL_KNOWN_SYMBOLS
 #undef __JS_ENUMERATE
 
     for (auto& symbol : m_global_symbol_registry)
-        roots.set(symbol.value, HeapRoot { .type = HeapRoot::Type::VM });
+        roots.set(symbol.value, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
 
     for (auto finalization_registry : m_finalization_registry_cleanup_jobs)
-        roots.set(finalization_registry, HeapRoot { .type = HeapRoot::Type::VM });
+        roots.set(finalization_registry, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
 
     auto gather_roots_from_execution_context_stack = [&roots](Vector<ExecutionContext*> const& stack) {
         for (auto const& execution_context : stack) {
             ExecutionContextRootsCollector visitor;
             execution_context->visit_edges(visitor);
             for (auto cell : visitor.roots)
-                roots.set(cell, HeapRoot { .type = HeapRoot::Type::VM });
+                roots.set(cell, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
         }
     };
     gather_roots_from_execution_context_stack(m_execution_context_stack);
@@ -256,7 +256,7 @@ void VM::gather_roots(HashMap<CellImpl*, HeapRoot>& roots)
         gather_roots_from_execution_context_stack(saved_stack);
 
     for (auto& job : m_promise_jobs)
-        roots.set(job, HeapRoot { .type = HeapRoot::Type::VM });
+        roots.set(job, GC::HeapRoot { .type = GC::HeapRoot::Type::VM });
 }
 
 // 9.1.2.1 GetIdentifierReference ( env, name, strict ), https://tc39.es/ecma262/#sec-getidentifierreference
@@ -347,7 +347,7 @@ Object* VM::get_import_meta()
     auto script_or_module = get_active_script_or_module();
 
     // 2. Assert: module is a Source Text Module Record.
-    auto& module = verify_cast<SourceTextModule>(*script_or_module.get<NonnullGCPtr<Module>>());
+    auto& module = verify_cast<SourceTextModule>(*script_or_module.get<GC::Ref<Module>>());
 
     // 3. Let importMeta be module.[[ImportMeta]].
     auto* import_meta = module.import_meta();
@@ -415,7 +415,7 @@ void VM::run_queued_promise_jobs()
 }
 
 // 9.5.4 HostEnqueuePromiseJob ( job, realm ), https://tc39.es/ecma262/#sec-hostenqueuepromisejob
-void VM::enqueue_promise_job(NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>> job, Realm*)
+void VM::enqueue_promise_job(GC::Ref<GC::Function<ThrowCompletionOr<Value>()>> job, Realm*)
 {
     // An implementation of HostEnqueuePromiseJob must conform to the requirements in 9.5 as well as the following:
     // - FIXME: If realm is not null, each time job is invoked the implementation must perform implementation-defined steps such that execution is prepared to evaluate ECMAScript code at the time of job's invocation.
@@ -587,7 +587,7 @@ static ByteString resolve_module_filename(StringView filename, StringView module
 }
 
 // 16.2.1.8 HostLoadImportedModule ( referrer, specifier, hostDefined, payload ), https://tc39.es/ecma262/#sec-HostLoadImportedModule
-void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest const& module_request, GCPtr<GraphLoadingState::HostDefined>, ImportedModulePayload payload)
+void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest const& module_request, GC::Ptr<GraphLoadingState::HostDefined>, ImportedModulePayload payload)
 {
     // An implementation of HostLoadImportedModule must conform to the following requirements:
     //
@@ -605,7 +605,7 @@ void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest con
     // mapping process. A typical normalization process would include actions such as expansion of relative and abbreviated path specifiers.
 
     // Here we check, against the spec, if payload is a promise capability, meaning that this was called for a dynamic import
-    if (payload.has<NonnullGCPtr<PromiseCapability>>() && !m_dynamic_imports_allowed) {
+    if (payload.has<GC::Ref<PromiseCapability>>() && !m_dynamic_imports_allowed) {
         // If you are here because you want to enable dynamic module importing make sure it won't be a security problem
         // by checking the default implementation of HostImportModuleDynamically and creating your own hook or calling
         // vm.allow_dynamic_imports().
@@ -624,7 +624,7 @@ void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest con
     dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] module at {} has type {}", module_request.module_specifier, module_type);
 
     StringView const base_filename = referrer.visit(
-        [&](NonnullGCPtr<Realm> const&) {
+        [&](GC::Ref<Realm> const&) {
             // Generally within ECMA262 we always get a referencing_script_or_module. However, ShadowRealm gives an explicit null.
             // To get around this is we attempt to get the active script_or_module otherwise we might start loading "random" files from the working directory.
             return get_active_script_or_module().visit(
@@ -695,7 +695,7 @@ void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest con
 
     StringView const content_view { file_content_or_error.value().bytes() };
 
-    auto module = [&]() -> ThrowCompletionOr<NonnullGCPtr<Module>> {
+    auto module = [&]() -> ThrowCompletionOr<GC::Ref<Module>> {
         // If assertions has an entry entry such that entry.[[Key]] is "type", let type be entry.[[Value]]. The following requirements apply:
         // If type is "json", then this algorithm must either invoke ParseJSONModule and return the resulting Completion Record, or throw an exception.
         if (module_type == "json"sv) {
@@ -717,7 +717,7 @@ void VM::load_imported_module(ImportedModuleReferrer referrer, ModuleRequest con
             referrer,
             module->filename(),
             ByteString {}, // Null type
-            make_handle<Module>(*module),
+            make_root<Module>(*module),
             true);
 
         return module;
diff --git a/Libraries/LibJS/Runtime/VM.h b/Libraries/LibJS/Runtime/VM.h
index d1941f667e1..8d7fe05b86a 100644
--- a/Libraries/LibJS/Runtime/VM.h
+++ b/Libraries/LibJS/Runtime/VM.h
@@ -15,9 +15,10 @@
 #include <AK/RefCounted.h>
 #include <AK/StackInfo.h>
 #include <AK/Variant.h>
+#include <LibGC/Function.h>
+#include <LibGC/Heap.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/CyclicModule.h>
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibJS/ModuleLoading.h>
 #include <LibJS/Runtime/CommonPropertyNames.h>
 #include <LibJS/Runtime/Completion.h>
@@ -47,40 +48,40 @@ public:
     struct CustomData {
         virtual ~CustomData() = default;
 
-        virtual void spin_event_loop_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition) = 0;
+        virtual void spin_event_loop_until(GC::Root<GC::Function<bool()>> goal_condition) = 0;
     };
 
     static ErrorOr<NonnullRefPtr<VM>> create(OwnPtr<CustomData> = {});
     ~VM();
 
-    Heap& heap() { return m_heap; }
-    Heap const& heap() const { return m_heap; }
+    GC::Heap& heap() { return m_heap; }
+    GC::Heap const& heap() const { return m_heap; }
 
     Bytecode::Interpreter& bytecode_interpreter();
 
     void dump_backtrace() const;
 
-    void gather_roots(HashMap<CellImpl*, HeapRoot>&);
+    void gather_roots(HashMap<GC::Cell*, GC::HeapRoot>&);
 
-#define __JS_ENUMERATE(SymbolName, snake_name)                  \
-    NonnullGCPtr<Symbol> well_known_symbol_##snake_name() const \
-    {                                                           \
-        return *m_well_known_symbols.snake_name;                \
+#define __JS_ENUMERATE(SymbolName, snake_name)             \
+    GC::Ref<Symbol> well_known_symbol_##snake_name() const \
+    {                                                      \
+        return *m_well_known_symbols.snake_name;           \
     }
     JS_ENUMERATE_WELL_KNOWN_SYMBOLS
 #undef __JS_ENUMERATE
 
-    HashMap<String, GCPtr<PrimitiveString>>& string_cache()
+    HashMap<String, GC::Ptr<PrimitiveString>>& string_cache()
     {
         return m_string_cache;
     }
 
-    HashMap<ByteString, GCPtr<PrimitiveString>>& byte_string_cache()
+    HashMap<ByteString, GC::Ptr<PrimitiveString>>& byte_string_cache()
     {
         return m_byte_string_cache;
     }
 
-    HashMap<Utf16String, GCPtr<PrimitiveString>>& utf16_string_cache()
+    HashMap<Utf16String, GC::Ptr<PrimitiveString>>& utf16_string_cache()
     {
         return m_utf16_string_cache;
     }
@@ -189,8 +190,8 @@ public:
 
     StackInfo const& stack_info() const { return m_stack_info; }
 
-    HashMap<String, NonnullGCPtr<Symbol>> const& global_symbol_registry() const { return m_global_symbol_registry; }
-    HashMap<String, NonnullGCPtr<Symbol>>& global_symbol_registry() { return m_global_symbol_registry; }
+    HashMap<String, GC::Ref<Symbol>> const& global_symbol_registry() const { return m_global_symbol_registry; }
+    HashMap<String, GC::Ref<Symbol>>& global_symbol_registry() { return m_global_symbol_registry; }
 
     u32 execution_generation() const { return m_execution_generation; }
     void finish_execution_generation() { ++m_execution_generation; }
@@ -228,18 +229,18 @@ public:
 
     CommonPropertyNames names;
     struct {
-        GCPtr<PrimitiveString> number;
-        GCPtr<PrimitiveString> undefined;
-        GCPtr<PrimitiveString> object;
-        GCPtr<PrimitiveString> string;
-        GCPtr<PrimitiveString> symbol;
-        GCPtr<PrimitiveString> boolean;
-        GCPtr<PrimitiveString> bigint;
-        GCPtr<PrimitiveString> function;
+        GC::Ptr<PrimitiveString> number;
+        GC::Ptr<PrimitiveString> undefined;
+        GC::Ptr<PrimitiveString> object;
+        GC::Ptr<PrimitiveString> string;
+        GC::Ptr<PrimitiveString> symbol;
+        GC::Ptr<PrimitiveString> boolean;
+        GC::Ptr<PrimitiveString> bigint;
+        GC::Ptr<PrimitiveString> function;
     } typeof_strings;
 
     void run_queued_promise_jobs();
-    void enqueue_promise_job(NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>> job, Realm*);
+    void enqueue_promise_job(GC::Ref<GC::Function<ThrowCompletionOr<Value>()>> job, Realm*);
 
     void run_queued_finalization_registry_cleanup_jobs();
     void enqueue_finalization_registry_cleanup_job(FinalizationRegistry&);
@@ -267,7 +268,7 @@ public:
     //       Our implementation of this proposal is outdated however, as such we try to adapt the proposal and living standard
     //       to match our implementation for now.
     // 16.2.1.8 HostLoadImportedModule ( referrer, moduleRequest, hostDefined, payload ), https://tc39.es/proposal-import-attributes/#sec-HostLoadImportedModule
-    Function<void(ImportedModuleReferrer, ModuleRequest const&, GCPtr<GraphLoadingState::HostDefined>, ImportedModulePayload)> host_load_imported_module;
+    Function<void(ImportedModuleReferrer, ModuleRequest const&, GC::Ptr<GraphLoadingState::HostDefined>, ImportedModulePayload)> host_load_imported_module;
 
     Function<HashMap<PropertyKey, Value>(SourceTextModule&)> host_get_import_meta_properties;
     Function<void(Object*, SourceTextModule const&)> host_finalize_import_meta;
@@ -279,8 +280,8 @@ public:
     Function<void(Promise&, Promise::RejectionOperation)> host_promise_rejection_tracker;
     Function<ThrowCompletionOr<Value>(JobCallback&, Value, ReadonlySpan<Value>)> host_call_job_callback;
     Function<void(FinalizationRegistry&)> host_enqueue_finalization_registry_cleanup_job;
-    Function<void(NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>>, Realm*)> host_enqueue_promise_job;
-    Function<JS::NonnullGCPtr<JobCallback>(FunctionObject&)> host_make_job_callback;
+    Function<void(GC::Ref<GC::Function<ThrowCompletionOr<Value>()>>, Realm*)> host_enqueue_promise_job;
+    Function<GC::Ref<JobCallback>(FunctionObject&)> host_make_job_callback;
     Function<ThrowCompletionOr<void>(Realm&, ReadonlySpan<String>, StringView, EvalMode)> host_ensure_can_compile_strings;
     Function<ThrowCompletionOr<void>(Object&)> host_ensure_can_add_private_element;
     Function<ThrowCompletionOr<HandledByHost>(ArrayBuffer&, size_t)> host_resize_array_buffer;
@@ -294,23 +295,23 @@ private:
 
     struct WellKnownSymbols {
 #define __JS_ENUMERATE(SymbolName, snake_name) \
-    GCPtr<Symbol> snake_name;
+    GC::Ptr<Symbol> snake_name;
         JS_ENUMERATE_WELL_KNOWN_SYMBOLS
 #undef __JS_ENUMERATE
     };
 
     VM(OwnPtr<CustomData>, ErrorMessages);
 
-    void load_imported_module(ImportedModuleReferrer, ModuleRequest const&, GCPtr<GraphLoadingState::HostDefined>, ImportedModulePayload);
+    void load_imported_module(ImportedModuleReferrer, ModuleRequest const&, GC::Ptr<GraphLoadingState::HostDefined>, ImportedModulePayload);
     ThrowCompletionOr<void> link_and_eval_module(CyclicModule&);
 
     void set_well_known_symbols(WellKnownSymbols well_known_symbols) { m_well_known_symbols = move(well_known_symbols); }
 
-    HashMap<String, GCPtr<PrimitiveString>> m_string_cache;
-    HashMap<ByteString, GCPtr<PrimitiveString>> m_byte_string_cache;
-    HashMap<Utf16String, GCPtr<PrimitiveString>> m_utf16_string_cache;
+    HashMap<String, GC::Ptr<PrimitiveString>> m_string_cache;
+    HashMap<ByteString, GC::Ptr<PrimitiveString>> m_byte_string_cache;
+    HashMap<Utf16String, GC::Ptr<PrimitiveString>> m_utf16_string_cache;
 
-    Heap m_heap;
+    GC::Heap m_heap;
 
     Vector<ExecutionContext*> m_execution_context_stack;
 
@@ -319,21 +320,21 @@ private:
     StackInfo m_stack_info;
 
     // GlobalSymbolRegistry, https://tc39.es/ecma262/#table-globalsymbolregistry-record-fields
-    HashMap<String, NonnullGCPtr<Symbol>> m_global_symbol_registry;
+    HashMap<String, GC::Ref<Symbol>> m_global_symbol_registry;
 
-    Vector<NonnullGCPtr<HeapFunction<ThrowCompletionOr<Value>()>>> m_promise_jobs;
+    Vector<GC::Ref<GC::Function<ThrowCompletionOr<Value>()>>> m_promise_jobs;
 
-    Vector<GCPtr<FinalizationRegistry>> m_finalization_registry_cleanup_jobs;
+    Vector<GC::Ptr<FinalizationRegistry>> m_finalization_registry_cleanup_jobs;
 
-    GCPtr<PrimitiveString> m_empty_string;
-    GCPtr<PrimitiveString> m_single_ascii_character_strings[128] {};
+    GC::Ptr<PrimitiveString> m_empty_string;
+    GC::Ptr<PrimitiveString> m_single_ascii_character_strings[128] {};
     ErrorMessages m_error_messages;
 
     struct StoredModule {
         ImportedModuleReferrer referrer;
         ByteString filename;
         ByteString type;
-        Handle<Module> module;
+        GC::Root<Module> module;
         bool has_once_started_linking { false };
     };
 
diff --git a/Libraries/LibJS/Runtime/Value.cpp b/Libraries/LibJS/Runtime/Value.cpp
index 139245df505..cd7d1bc8b20 100644
--- a/Libraries/LibJS/Runtime/Value.cpp
+++ b/Libraries/LibJS/Runtime/Value.cpp
@@ -49,7 +49,7 @@ static inline bool same_type_for_equality(Value const& lhs, Value const& rhs)
     // If the top two bytes are identical then either:
     // both are NaN boxed Values with the same type
     // or they are doubles which happen to have the same top bytes.
-    if ((lhs.encoded() & TAG_EXTRACTION) == (rhs.encoded() & TAG_EXTRACTION))
+    if ((lhs.encoded() & GC::TAG_EXTRACTION) == (rhs.encoded() & GC::TAG_EXTRACTION))
         return true;
 
     if (lhs.is_number() && rhs.is_number())
@@ -322,7 +322,7 @@ ThrowCompletionOr<bool> Value::is_regexp(VM& vm) const
 }
 
 // 13.5.3 The typeof Operator, https://tc39.es/ecma262/#sec-typeof-operator
-NonnullGCPtr<PrimitiveString> Value::typeof_(VM& vm) const
+GC::Ref<PrimitiveString> Value::typeof_(VM& vm) const
 {
     // 9. If val is a Number, return "number".
     if (is_number())
@@ -394,7 +394,7 @@ String Value::to_string_without_side_effects() const
     }
 }
 
-ThrowCompletionOr<NonnullGCPtr<PrimitiveString>> Value::to_primitive_string(VM& vm)
+ThrowCompletionOr<GC::Ref<PrimitiveString>> Value::to_primitive_string(VM& vm)
 {
     if (is_string())
         return as_string();
@@ -556,7 +556,7 @@ ThrowCompletionOr<Value> Value::to_primitive_slow_case(VM& vm, PreferredType pre
 }
 
 // 7.1.18 ToObject ( argument ), https://tc39.es/ecma262/#sec-toobject
-ThrowCompletionOr<NonnullGCPtr<Object>> Value::to_object(VM& vm) const
+ThrowCompletionOr<GC::Ref<Object>> Value::to_object(VM& vm) const
 {
     auto& realm = *vm.current_realm();
     VERIFY(!is_empty());
@@ -744,7 +744,7 @@ ThrowCompletionOr<Value> Value::to_number_slow_case(VM& vm) const
 static Optional<BigInt*> string_to_bigint(VM& vm, StringView string);
 
 // 7.1.13 ToBigInt ( argument ), https://tc39.es/ecma262/#sec-tobigint
-ThrowCompletionOr<NonnullGCPtr<BigInt>> Value::to_bigint(VM& vm) const
+ThrowCompletionOr<GC::Ref<BigInt>> Value::to_bigint(VM& vm) const
 {
     // 1. Let prim be ? ToPrimitive(argument, number).
     auto primitive = TRY(to_primitive(vm, PreferredType::Number));
@@ -1227,7 +1227,7 @@ ThrowCompletionOr<Value> Value::get(VM& vm, PropertyKey const& property_key) con
 }
 
 // 7.3.11 GetMethod ( V, P ), https://tc39.es/ecma262/#sec-getmethod
-ThrowCompletionOr<GCPtr<FunctionObject>> Value::get_method(VM& vm, PropertyKey const& property_key) const
+ThrowCompletionOr<GC::Ptr<FunctionObject>> Value::get_method(VM& vm, PropertyKey const& property_key) const
 {
     // 1. Let func be ? GetV(V, P).
     auto function = TRY(get(vm, property_key));
@@ -2493,7 +2493,7 @@ ThrowCompletionOr<TriState> is_less_than(VM& vm, Value lhs, Value rhs, bool left
 }
 
 // 7.3.21 Invoke ( V, P [ , argumentsList ] ), https://tc39.es/ecma262/#sec-invoke
-ThrowCompletionOr<Value> Value::invoke_internal(VM& vm, PropertyKey const& property_key, Optional<MarkedVector<Value>> arguments)
+ThrowCompletionOr<Value> Value::invoke_internal(VM& vm, PropertyKey const& property_key, Optional<GC::MarkedVector<Value>> arguments)
 {
     // 1. If argumentsList is not present, set argumentsList to a new empty List.
 
diff --git a/Libraries/LibJS/Runtime/Value.h b/Libraries/LibJS/Runtime/Value.h
index 9a37dc3d69b..11cc0cb8908 100644
--- a/Libraries/LibJS/Runtime/Value.h
+++ b/Libraries/LibJS/Runtime/Value.h
@@ -18,11 +18,11 @@
 #include <AK/SourceLocation.h>
 #include <AK/String.h>
 #include <AK/Types.h>
+#include <LibGC/NanBoxedValue.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/NanBoxedValue.h>
 #include <math.h>
 
 namespace JS {
@@ -33,26 +33,26 @@ static constexpr double MAX_ARRAY_LIKE_INDEX = 9007199254740991.0;
 static constexpr u64 NEGATIVE_ZERO_BITS = ((u64)1 << 63);
 
 // This leaves us 3 bits to tag the type of pointer:
-static constexpr u64 OBJECT_TAG = 0b001 | IS_CELL_BIT;
-static constexpr u64 STRING_TAG = 0b010 | IS_CELL_BIT;
-static constexpr u64 SYMBOL_TAG = 0b011 | IS_CELL_BIT;
-static constexpr u64 ACCESSOR_TAG = 0b100 | IS_CELL_BIT;
-static constexpr u64 BIGINT_TAG = 0b101 | IS_CELL_BIT;
+static constexpr u64 OBJECT_TAG = 0b001 | GC::IS_CELL_BIT;
+static constexpr u64 STRING_TAG = 0b010 | GC::IS_CELL_BIT;
+static constexpr u64 SYMBOL_TAG = 0b011 | GC::IS_CELL_BIT;
+static constexpr u64 ACCESSOR_TAG = 0b100 | GC::IS_CELL_BIT;
+static constexpr u64 BIGINT_TAG = 0b101 | GC::IS_CELL_BIT;
 
 // We can then by extracting the top 13 bits quickly check if a Value is
 // pointer backed.
-static_assert((OBJECT_TAG & IS_CELL_PATTERN) == IS_CELL_PATTERN);
-static_assert((STRING_TAG & IS_CELL_PATTERN) == IS_CELL_PATTERN);
-static_assert((CANON_NAN_BITS & IS_CELL_PATTERN) != IS_CELL_PATTERN);
-static_assert((NEGATIVE_INFINITY_BITS & IS_CELL_PATTERN) != IS_CELL_PATTERN);
+static_assert((OBJECT_TAG & GC::IS_CELL_PATTERN) == GC::IS_CELL_PATTERN);
+static_assert((STRING_TAG & GC::IS_CELL_PATTERN) == GC::IS_CELL_PATTERN);
+static_assert((GC::CANON_NAN_BITS & GC::IS_CELL_PATTERN) != GC::IS_CELL_PATTERN);
+static_assert((GC::NEGATIVE_INFINITY_BITS & GC::IS_CELL_PATTERN) != GC::IS_CELL_PATTERN);
 
 // Then for the non pointer backed types we don't set the sign bit and use the
 // three lower bits for tagging as well.
-static constexpr u64 UNDEFINED_TAG = 0b110 | BASE_TAG;
-static constexpr u64 NULL_TAG = 0b111 | BASE_TAG;
-static constexpr u64 BOOLEAN_TAG = 0b001 | BASE_TAG;
-static constexpr u64 INT32_TAG = 0b010 | BASE_TAG;
-static constexpr u64 EMPTY_TAG = 0b011 | BASE_TAG;
+static constexpr u64 UNDEFINED_TAG = 0b110 | GC::BASE_TAG;
+static constexpr u64 NULL_TAG = 0b111 | GC::BASE_TAG;
+static constexpr u64 BOOLEAN_TAG = 0b001 | GC::BASE_TAG;
+static constexpr u64 INT32_TAG = 0b010 | GC::BASE_TAG;
+static constexpr u64 EMPTY_TAG = 0b011 | GC::BASE_TAG;
 // Notice how only undefined and null have the top bit set, this mean we can
 // quickly check for nullish values by checking if the top and bottom bits are set
 // but the middle one isn't.
@@ -67,8 +67,8 @@ static_assert((EMPTY_TAG & IS_NULLISH_EXTRACT_PATTERN) != IS_NULLISH_PATTERN);
 // values are not valid anywhere else we can use this "value" to our advantage
 // in Optional<Value> to represent the empty optional.
 
-static constexpr u64 SHIFTED_BOOLEAN_TAG = BOOLEAN_TAG << TAG_SHIFT;
-static constexpr u64 SHIFTED_INT32_TAG = INT32_TAG << TAG_SHIFT;
+static constexpr u64 SHIFTED_BOOLEAN_TAG = BOOLEAN_TAG << GC::TAG_SHIFT;
+static constexpr u64 SHIFTED_INT32_TAG = INT32_TAG << GC::TAG_SHIFT;
 
 // Summary:
 // To pack all the different value in to doubles we use the following schema:
@@ -85,7 +85,7 @@ static constexpr u64 SHIFTED_INT32_TAG = INT32_TAG << TAG_SHIFT;
 // options from 8 tags to 15 but since we currently only use 5 for both sign bits
 // this is not needed.
 
-class Value : public NanBoxedValue {
+class Value : public GC::NanBoxedValue {
 public:
     enum class PreferredType {
         Default,
@@ -114,18 +114,18 @@ public:
 
     bool is_infinity() const
     {
-        static_assert(NEGATIVE_INFINITY_BITS == (0x1ULL << 63 | POSITIVE_INFINITY_BITS));
-        return (0x1ULL << 63 | m_value.encoded) == NEGATIVE_INFINITY_BITS;
+        static_assert(GC::NEGATIVE_INFINITY_BITS == (0x1ULL << 63 | GC::POSITIVE_INFINITY_BITS));
+        return (0x1ULL << 63 | m_value.encoded) == GC::NEGATIVE_INFINITY_BITS;
     }
 
     bool is_positive_infinity() const
     {
-        return m_value.encoded == POSITIVE_INFINITY_BITS;
+        return m_value.encoded == GC::POSITIVE_INFINITY_BITS;
     }
 
     bool is_negative_infinity() const
     {
-        return m_value.encoded == NEGATIVE_INFINITY_BITS;
+        return m_value.encoded == GC::NEGATIVE_INFINITY_BITS;
     }
 
     bool is_positive_zero() const
@@ -155,13 +155,13 @@ public:
     }
 
     Value()
-        : Value(EMPTY_TAG << TAG_SHIFT, (u64)0)
+        : Value(EMPTY_TAG << GC::TAG_SHIFT, (u64)0)
     {
     }
 
     template<typename T>
     requires(IsSameIgnoringCV<T, bool>) explicit Value(T value)
-        : Value(BOOLEAN_TAG << TAG_SHIFT, (u64)value)
+        : Value(BOOLEAN_TAG << GC::TAG_SHIFT, (u64)value)
     {
     }
 
@@ -173,7 +173,7 @@ public:
             m_value.encoded = SHIFTED_INT32_TAG | (static_cast<i32>(value) & 0xFFFFFFFFul);
         } else {
             if (isnan(value)) [[unlikely]]
-                m_value.encoded = CANON_NAN_BITS;
+                m_value.encoded = GC::CANON_NAN_BITS;
             else
                 m_value.as_double = value;
         }
@@ -215,44 +215,44 @@ public:
     }
 
     Value(Object const* object)
-        : Value(OBJECT_TAG << TAG_SHIFT, reinterpret_cast<void const*>(object))
+        : Value(OBJECT_TAG << GC::TAG_SHIFT, reinterpret_cast<void const*>(object))
     {
     }
 
     Value(PrimitiveString const* string)
-        : Value(STRING_TAG << TAG_SHIFT, reinterpret_cast<void const*>(string))
+        : Value(STRING_TAG << GC::TAG_SHIFT, reinterpret_cast<void const*>(string))
     {
     }
 
     Value(Symbol const* symbol)
-        : Value(SYMBOL_TAG << TAG_SHIFT, reinterpret_cast<void const*>(symbol))
+        : Value(SYMBOL_TAG << GC::TAG_SHIFT, reinterpret_cast<void const*>(symbol))
     {
     }
 
     Value(Accessor const* accessor)
-        : Value(ACCESSOR_TAG << TAG_SHIFT, reinterpret_cast<void const*>(accessor))
+        : Value(ACCESSOR_TAG << GC::TAG_SHIFT, reinterpret_cast<void const*>(accessor))
     {
     }
 
     Value(BigInt const* bigint)
-        : Value(BIGINT_TAG << TAG_SHIFT, reinterpret_cast<void const*>(bigint))
+        : Value(BIGINT_TAG << GC::TAG_SHIFT, reinterpret_cast<void const*>(bigint))
     {
     }
 
     template<typename T>
-    Value(GCPtr<T> ptr)
+    Value(GC::Ptr<T> ptr)
         : Value(ptr.ptr())
     {
     }
 
     template<typename T>
-    Value(NonnullGCPtr<T> ptr)
+    Value(GC::Ref<T> ptr)
         : Value(ptr.ptr())
     {
     }
 
     template<typename T>
-    Value(Handle<T> const& ptr)
+    Value(GC::Root<T> const& ptr)
         : Value(ptr.ptr())
     {
     }
@@ -347,12 +347,12 @@ public:
     ThrowCompletionOr<ByteString> to_byte_string(VM&) const;
     ThrowCompletionOr<Utf16String> to_utf16_string(VM&) const;
     ThrowCompletionOr<String> to_well_formed_string(VM&) const;
-    ThrowCompletionOr<NonnullGCPtr<PrimitiveString>> to_primitive_string(VM&);
+    ThrowCompletionOr<GC::Ref<PrimitiveString>> to_primitive_string(VM&);
     ThrowCompletionOr<Value> to_primitive(VM&, PreferredType preferred_type = PreferredType::Default) const;
-    ThrowCompletionOr<NonnullGCPtr<Object>> to_object(VM&) const;
+    ThrowCompletionOr<GC::Ref<Object>> to_object(VM&) const;
     ThrowCompletionOr<Value> to_numeric(VM&) const;
     ThrowCompletionOr<Value> to_number(VM&) const;
-    ThrowCompletionOr<NonnullGCPtr<BigInt>> to_bigint(VM&) const;
+    ThrowCompletionOr<GC::Ref<BigInt>> to_bigint(VM&) const;
     ThrowCompletionOr<i64> to_bigint_int64(VM&) const;
     ThrowCompletionOr<u64> to_bigint_uint64(VM&) const;
     ThrowCompletionOr<double> to_double(VM&) const;
@@ -370,7 +370,7 @@ public:
     bool to_boolean() const;
 
     ThrowCompletionOr<Value> get(VM&, PropertyKey const&) const;
-    ThrowCompletionOr<GCPtr<FunctionObject>> get_method(VM&, PropertyKey const&) const;
+    ThrowCompletionOr<GC::Ptr<FunctionObject>> get_method(VM&, PropertyKey const&) const;
 
     [[nodiscard]] String to_string_without_side_effects() const;
 
@@ -381,7 +381,7 @@ public:
         return *this;
     }
 
-    [[nodiscard]] NonnullGCPtr<PrimitiveString> typeof_(VM&) const;
+    [[nodiscard]] GC::Ref<PrimitiveString> typeof_(VM&) const;
 
     bool operator==(Value const&) const;
 
@@ -390,7 +390,7 @@ public:
 
     // A double is any Value which does not have the full exponent and top mantissa bit set or has
     // exactly only those bits set.
-    bool is_double() const { return (m_value.encoded & CANON_NAN_BITS) != CANON_NAN_BITS || (m_value.encoded == CANON_NAN_BITS); }
+    bool is_double() const { return (m_value.encoded & GC::CANON_NAN_BITS) != GC::CANON_NAN_BITS || (m_value.encoded == GC::CANON_NAN_BITS); }
     bool is_int32() const { return m_value.tag == INT32_TAG; }
 
     i32 as_i32() const
@@ -449,7 +449,7 @@ private:
         }
     }
 
-    [[nodiscard]] ThrowCompletionOr<Value> invoke_internal(VM&, PropertyKey const&, Optional<MarkedVector<Value>> arguments);
+    [[nodiscard]] ThrowCompletionOr<Value> invoke_internal(VM&, PropertyKey const&, Optional<GC::MarkedVector<Value>> arguments);
 
     ThrowCompletionOr<i32> to_i32_slow_case(VM&) const;
 
@@ -465,12 +465,12 @@ private:
 
 inline Value js_undefined()
 {
-    return Value(UNDEFINED_TAG << TAG_SHIFT, (u64)0);
+    return Value(UNDEFINED_TAG << GC::TAG_SHIFT, (u64)0);
 }
 
 inline Value js_null()
 {
-    return Value(NULL_TAG << TAG_SHIFT, (u64)0);
+    return Value(NULL_TAG << GC::TAG_SHIFT, (u64)0);
 }
 
 inline Value js_nan()
@@ -646,18 +646,18 @@ private:
 
 }
 
-namespace JS {
+namespace GC {
 
 template<>
-class Handle<Value> {
+class Root<JS::Value> {
 public:
-    Handle() = default;
+    Root() = default;
 
-    static Handle create(Value value, SourceLocation location)
+    static Root create(JS::Value value, SourceLocation location)
     {
         if (value.is_cell())
-            return Handle(value, &value.as_cell(), location);
-        return Handle(value);
+            return Root(value, &value.as_cell(), location);
+        return Root(value);
     }
 
     auto cell() { return m_handle.cell(); }
@@ -665,28 +665,28 @@ public:
     auto value() const { return *m_value; }
     bool is_null() const { return m_handle.is_null() && !m_value.has_value(); }
 
-    bool operator==(Value const& value) const { return value == m_value; }
-    bool operator==(Handle<Value> const& other) const { return other.m_value == this->m_value; }
+    bool operator==(JS::Value const& value) const { return value == m_value; }
+    bool operator==(Root<JS::Value> const& other) const { return other.m_value == this->m_value; }
 
 private:
-    explicit Handle(Value value)
+    explicit Root(JS::Value value)
         : m_value(value)
     {
     }
 
-    explicit Handle(Value value, CellImpl* cell, SourceLocation location)
+    explicit Root(JS::Value value, Cell* cell, SourceLocation location)
         : m_value(value)
-        , m_handle(Handle<CellImpl>::create(cell, location))
+        , m_handle(Root<Cell>::create(cell, location))
     {
     }
 
-    Optional<Value> m_value;
-    Handle<CellImpl> m_handle;
+    Optional<JS::Value> m_value;
+    Root<Cell> m_handle;
 };
 
-inline Handle<Value> make_handle(Value value, SourceLocation location = SourceLocation::current())
+inline Root<JS::Value> make_root(JS::Value value, SourceLocation location = SourceLocation::current())
 {
-    return Handle<Value>::create(value, location);
+    return Root<JS::Value>::create(value, location);
 }
 
 }
@@ -710,8 +710,8 @@ struct Traits<JS::Value> : DefaultTraits<JS::Value> {
 };
 
 template<>
-struct Traits<JS::Handle<JS::Value>> : public DefaultTraits<JS::Handle<JS::Value>> {
-    static unsigned hash(JS::Handle<JS::Value> const& handle) { return Traits<JS::Value>::hash(handle.value()); }
+struct Traits<GC::Root<JS::Value>> : public DefaultTraits<GC::Root<JS::Value>> {
+    static unsigned hash(GC::Root<JS::Value> const& handle) { return Traits<JS::Value>::hash(handle.value()); }
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/WeakMap.cpp b/Libraries/LibJS/Runtime/WeakMap.cpp
index bcda1710c39..bfd896a4934 100644
--- a/Libraries/LibJS/Runtime/WeakMap.cpp
+++ b/Libraries/LibJS/Runtime/WeakMap.cpp
@@ -8,9 +8,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakMap);
+GC_DEFINE_ALLOCATOR(WeakMap);
 
-NonnullGCPtr<WeakMap> WeakMap::create(Realm& realm)
+GC::Ref<WeakMap> WeakMap::create(Realm& realm)
 {
     return realm.create<WeakMap>(realm.intrinsics().weak_map_prototype());
 }
@@ -21,7 +21,7 @@ WeakMap::WeakMap(Object& prototype)
 {
 }
 
-void WeakMap::remove_dead_cells(Badge<Heap>)
+void WeakMap::remove_dead_cells(Badge<GC::Heap>)
 {
     m_values.remove_all_matching([](Cell* key, Value) {
         return key->state() != Cell::State::Live;
diff --git a/Libraries/LibJS/Runtime/WeakMap.h b/Libraries/LibJS/Runtime/WeakMap.h
index 4f02b4bd5bc..20352146a64 100644
--- a/Libraries/LibJS/Runtime/WeakMap.h
+++ b/Libraries/LibJS/Runtime/WeakMap.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/HashMap.h>
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/WeakContainer.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/Object.h>
 
@@ -15,26 +15,26 @@ namespace JS {
 
 class WeakMap final
     : public Object
-    , public WeakContainer {
+    , public GC::WeakContainer {
     JS_OBJECT(WeakMap, Object);
-    JS_DECLARE_ALLOCATOR(WeakMap);
+    GC_DECLARE_ALLOCATOR(WeakMap);
 
 public:
-    static NonnullGCPtr<WeakMap> create(Realm&);
+    static GC::Ref<WeakMap> create(Realm&);
 
     virtual ~WeakMap() override = default;
 
-    HashMap<GCPtr<Cell>, Value> const& values() const { return m_values; }
-    HashMap<GCPtr<Cell>, Value>& values() { return m_values; }
+    HashMap<GC::Ptr<Cell>, Value> const& values() const { return m_values; }
+    HashMap<GC::Ptr<Cell>, Value>& values() { return m_values; }
 
-    virtual void remove_dead_cells(Badge<Heap>) override;
+    virtual void remove_dead_cells(Badge<GC::Heap>) override;
 
 private:
     explicit WeakMap(Object& prototype);
 
     void visit_edges(Visitor&) override;
 
-    HashMap<GCPtr<Cell>, Value> m_values; // This stores Cell pointers instead of Object pointers to aide with sweeping
+    HashMap<GC::Ptr<Cell>, Value> m_values; // This stores Cell pointers instead of Object pointers to aide with sweeping
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/WeakMapConstructor.cpp b/Libraries/LibJS/Runtime/WeakMapConstructor.cpp
index 60815613655..672e138b567 100644
--- a/Libraries/LibJS/Runtime/WeakMapConstructor.cpp
+++ b/Libraries/LibJS/Runtime/WeakMapConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakMapConstructor);
+GC_DEFINE_ALLOCATOR(WeakMapConstructor);
 
 WeakMapConstructor::WeakMapConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.WeakMap.as_string(), realm.intrinsics().function_prototype())
@@ -41,7 +41,7 @@ ThrowCompletionOr<Value> WeakMapConstructor::call()
 }
 
 // 24.3.1.1 WeakMap ( [ iterable ] ), https://tc39.es/ecma262/#sec-weakmap-iterable
-ThrowCompletionOr<NonnullGCPtr<Object>> WeakMapConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> WeakMapConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto iterable = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/WeakMapConstructor.h b/Libraries/LibJS/Runtime/WeakMapConstructor.h
index 10d31f46878..25d59ae6c6b 100644
--- a/Libraries/LibJS/Runtime/WeakMapConstructor.h
+++ b/Libraries/LibJS/Runtime/WeakMapConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class WeakMapConstructor final : public NativeFunction {
     JS_OBJECT(WeakMapConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(WeakMapConstructor);
+    GC_DECLARE_ALLOCATOR(WeakMapConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~WeakMapConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit WeakMapConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/WeakMapPrototype.cpp b/Libraries/LibJS/Runtime/WeakMapPrototype.cpp
index 9b56f51b67c..821e4528cb7 100644
--- a/Libraries/LibJS/Runtime/WeakMapPrototype.cpp
+++ b/Libraries/LibJS/Runtime/WeakMapPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakMapPrototype);
+GC_DEFINE_ALLOCATOR(WeakMapPrototype);
 
 WeakMapPrototype::WeakMapPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/WeakMapPrototype.h b/Libraries/LibJS/Runtime/WeakMapPrototype.h
index 4526d902964..c4969f8681d 100644
--- a/Libraries/LibJS/Runtime/WeakMapPrototype.h
+++ b/Libraries/LibJS/Runtime/WeakMapPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class WeakMapPrototype final : public PrototypeObject<WeakMapPrototype, WeakMap> {
     JS_PROTOTYPE_OBJECT(WeakMapPrototype, WeakMap, WeakMap);
-    JS_DECLARE_ALLOCATOR(WeakMapPrototype);
+    GC_DECLARE_ALLOCATOR(WeakMapPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/WeakRef.cpp b/Libraries/LibJS/Runtime/WeakRef.cpp
index e78ee0bab21..2743d62c7bf 100644
--- a/Libraries/LibJS/Runtime/WeakRef.cpp
+++ b/Libraries/LibJS/Runtime/WeakRef.cpp
@@ -8,14 +8,14 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakRef);
+GC_DEFINE_ALLOCATOR(WeakRef);
 
-NonnullGCPtr<WeakRef> WeakRef::create(Realm& realm, Object& value)
+GC::Ref<WeakRef> WeakRef::create(Realm& realm, Object& value)
 {
     return realm.create<WeakRef>(value, realm.intrinsics().weak_ref_prototype());
 }
 
-NonnullGCPtr<WeakRef> WeakRef::create(Realm& realm, Symbol& value)
+GC::Ref<WeakRef> WeakRef::create(Realm& realm, Symbol& value)
 {
     return realm.create<WeakRef>(value, realm.intrinsics().weak_ref_prototype());
 }
@@ -36,7 +36,7 @@ WeakRef::WeakRef(Symbol& value, Object& prototype)
 {
 }
 
-void WeakRef::remove_dead_cells(Badge<Heap>)
+void WeakRef::remove_dead_cells(Badge<GC::Heap>)
 {
     if (m_value.visit([](Cell* cell) -> bool { return cell->state() == Cell::State::Live; }, [](Empty) -> bool { VERIFY_NOT_REACHED(); }))
         return;
diff --git a/Libraries/LibJS/Runtime/WeakRef.h b/Libraries/LibJS/Runtime/WeakRef.h
index 9fcf0d0324a..c0f38cdff79 100644
--- a/Libraries/LibJS/Runtime/WeakRef.h
+++ b/Libraries/LibJS/Runtime/WeakRef.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/WeakContainer.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/Object.h>
 
@@ -14,13 +14,13 @@ namespace JS {
 
 class WeakRef final
     : public Object
-    , public WeakContainer {
+    , public GC::WeakContainer {
     JS_OBJECT(WeakRef, Object);
-    JS_DECLARE_ALLOCATOR(WeakRef);
+    GC_DECLARE_ALLOCATOR(WeakRef);
 
 public:
-    static NonnullGCPtr<WeakRef> create(Realm&, Object&);
-    static NonnullGCPtr<WeakRef> create(Realm&, Symbol&);
+    static GC::Ref<WeakRef> create(Realm&, Object&);
+    static GC::Ref<WeakRef> create(Realm&, Symbol&);
 
     virtual ~WeakRef() override = default;
 
@@ -28,7 +28,7 @@ public:
 
     void update_execution_generation() { m_last_execution_generation = vm().execution_generation(); }
 
-    virtual void remove_dead_cells(Badge<Heap>) override;
+    virtual void remove_dead_cells(Badge<GC::Heap>) override;
 
 private:
     explicit WeakRef(Object&, Object& prototype);
@@ -36,7 +36,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    Variant<GCPtr<Object>, GCPtr<Symbol>, Empty> m_value;
+    Variant<GC::Ptr<Object>, GC::Ptr<Symbol>, Empty> m_value;
     u32 m_last_execution_generation { 0 };
 };
 
diff --git a/Libraries/LibJS/Runtime/WeakRefConstructor.cpp b/Libraries/LibJS/Runtime/WeakRefConstructor.cpp
index d77ab2a8a2c..dab091f0e2a 100644
--- a/Libraries/LibJS/Runtime/WeakRefConstructor.cpp
+++ b/Libraries/LibJS/Runtime/WeakRefConstructor.cpp
@@ -12,7 +12,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakRefConstructor);
+GC_DEFINE_ALLOCATOR(WeakRefConstructor);
 
 WeakRefConstructor::WeakRefConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.WeakRef.as_string(), realm.intrinsics().function_prototype())
@@ -40,7 +40,7 @@ ThrowCompletionOr<Value> WeakRefConstructor::call()
 }
 
 // 26.1.1.1 WeakRef ( target ), https://tc39.es/ecma262/#sec-weak-ref-target
-ThrowCompletionOr<NonnullGCPtr<Object>> WeakRefConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> WeakRefConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto target = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/WeakRefConstructor.h b/Libraries/LibJS/Runtime/WeakRefConstructor.h
index 9e8d66031fd..e1f7fef86d4 100644
--- a/Libraries/LibJS/Runtime/WeakRefConstructor.h
+++ b/Libraries/LibJS/Runtime/WeakRefConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class WeakRefConstructor final : public NativeFunction {
     JS_OBJECT(WeakRefConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(WeakRefConstructor);
+    GC_DECLARE_ALLOCATOR(WeakRefConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~WeakRefConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit WeakRefConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/WeakRefPrototype.cpp b/Libraries/LibJS/Runtime/WeakRefPrototype.cpp
index 3f2a1dd3046..56f8c1b77d0 100644
--- a/Libraries/LibJS/Runtime/WeakRefPrototype.cpp
+++ b/Libraries/LibJS/Runtime/WeakRefPrototype.cpp
@@ -9,7 +9,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakRefPrototype);
+GC_DEFINE_ALLOCATOR(WeakRefPrototype);
 
 WeakRefPrototype::WeakRefPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/WeakRefPrototype.h b/Libraries/LibJS/Runtime/WeakRefPrototype.h
index a2e4fcfb6f6..2279e17b47b 100644
--- a/Libraries/LibJS/Runtime/WeakRefPrototype.h
+++ b/Libraries/LibJS/Runtime/WeakRefPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class WeakRefPrototype final : public PrototypeObject<WeakRefPrototype, WeakRef> {
     JS_PROTOTYPE_OBJECT(WeakRefPrototype, WeakRef, WeakRef);
-    JS_DECLARE_ALLOCATOR(WeakRefPrototype);
+    GC_DECLARE_ALLOCATOR(WeakRefPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/WeakSet.cpp b/Libraries/LibJS/Runtime/WeakSet.cpp
index c4ecd202649..cd565de1212 100644
--- a/Libraries/LibJS/Runtime/WeakSet.cpp
+++ b/Libraries/LibJS/Runtime/WeakSet.cpp
@@ -8,9 +8,9 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakSet);
+GC_DEFINE_ALLOCATOR(WeakSet);
 
-NonnullGCPtr<WeakSet> WeakSet::create(Realm& realm)
+GC::Ref<WeakSet> WeakSet::create(Realm& realm)
 {
     return realm.create<WeakSet>(realm.intrinsics().weak_set_prototype());
 }
@@ -21,7 +21,7 @@ WeakSet::WeakSet(Object& prototype)
 {
 }
 
-void WeakSet::remove_dead_cells(Badge<Heap>)
+void WeakSet::remove_dead_cells(Badge<GC::Heap>)
 {
     m_values.remove_all_matching([](Cell* cell) {
         return cell->state() != Cell::State::Live;
diff --git a/Libraries/LibJS/Runtime/WeakSet.h b/Libraries/LibJS/Runtime/WeakSet.h
index 4b038035e7f..1489f83582f 100644
--- a/Libraries/LibJS/Runtime/WeakSet.h
+++ b/Libraries/LibJS/Runtime/WeakSet.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/HashTable.h>
-#include <LibJS/Heap/WeakContainer.h>
+#include <LibGC/WeakContainer.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/Object.h>
 
@@ -15,24 +15,24 @@ namespace JS {
 
 class WeakSet final
     : public Object
-    , public WeakContainer {
+    , public GC::WeakContainer {
     JS_OBJECT(WeakSet, Object);
-    JS_DECLARE_ALLOCATOR(WeakSet);
+    GC_DECLARE_ALLOCATOR(WeakSet);
 
 public:
-    static NonnullGCPtr<WeakSet> create(Realm&);
+    static GC::Ref<WeakSet> create(Realm&);
 
     virtual ~WeakSet() override = default;
 
-    HashTable<GCPtr<Cell>> const& values() const { return m_values; }
-    HashTable<GCPtr<Cell>>& values() { return m_values; }
+    HashTable<GC::Ptr<Cell>> const& values() const { return m_values; }
+    HashTable<GC::Ptr<Cell>>& values() { return m_values; }
 
-    virtual void remove_dead_cells(Badge<Heap>) override;
+    virtual void remove_dead_cells(Badge<GC::Heap>) override;
 
 private:
     explicit WeakSet(Object& prototype);
 
-    HashTable<RawGCPtr<Cell>> m_values; // This stores Cell pointers instead of Object pointers to aide with sweeping
+    HashTable<GC::RawPtr<Cell>> m_values; // This stores Cell pointers instead of Object pointers to aide with sweeping
 };
 
 }
diff --git a/Libraries/LibJS/Runtime/WeakSetConstructor.cpp b/Libraries/LibJS/Runtime/WeakSetConstructor.cpp
index 3c79c269ed9..65dfdcad52e 100644
--- a/Libraries/LibJS/Runtime/WeakSetConstructor.cpp
+++ b/Libraries/LibJS/Runtime/WeakSetConstructor.cpp
@@ -13,7 +13,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakSetConstructor);
+GC_DEFINE_ALLOCATOR(WeakSetConstructor);
 
 WeakSetConstructor::WeakSetConstructor(Realm& realm)
     : NativeFunction(realm.vm().names.WeakSet.as_string(), realm.intrinsics().function_prototype())
@@ -41,7 +41,7 @@ ThrowCompletionOr<Value> WeakSetConstructor::call()
 }
 
 // 24.4.1.1 WeakSet ( [ iterable ] ), https://tc39.es/ecma262/#sec-weakset-iterable
-ThrowCompletionOr<NonnullGCPtr<Object>> WeakSetConstructor::construct(FunctionObject& new_target)
+ThrowCompletionOr<GC::Ref<Object>> WeakSetConstructor::construct(FunctionObject& new_target)
 {
     auto& vm = this->vm();
     auto iterable = vm.argument(0);
diff --git a/Libraries/LibJS/Runtime/WeakSetConstructor.h b/Libraries/LibJS/Runtime/WeakSetConstructor.h
index 650439713f8..da8bd61b021 100644
--- a/Libraries/LibJS/Runtime/WeakSetConstructor.h
+++ b/Libraries/LibJS/Runtime/WeakSetConstructor.h
@@ -12,14 +12,14 @@ namespace JS {
 
 class WeakSetConstructor final : public NativeFunction {
     JS_OBJECT(WeakSetConstructor, NativeFunction);
-    JS_DECLARE_ALLOCATOR(WeakSetConstructor);
+    GC_DECLARE_ALLOCATOR(WeakSetConstructor);
 
 public:
     virtual void initialize(Realm&) override;
     virtual ~WeakSetConstructor() override = default;
 
     virtual ThrowCompletionOr<Value> call() override;
-    virtual ThrowCompletionOr<NonnullGCPtr<Object>> construct(FunctionObject&) override;
+    virtual ThrowCompletionOr<GC::Ref<Object>> construct(FunctionObject&) override;
 
 private:
     explicit WeakSetConstructor(Realm&);
diff --git a/Libraries/LibJS/Runtime/WeakSetPrototype.cpp b/Libraries/LibJS/Runtime/WeakSetPrototype.cpp
index 956ba88edef..f21395d17e1 100644
--- a/Libraries/LibJS/Runtime/WeakSetPrototype.cpp
+++ b/Libraries/LibJS/Runtime/WeakSetPrototype.cpp
@@ -11,7 +11,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WeakSetPrototype);
+GC_DEFINE_ALLOCATOR(WeakSetPrototype);
 
 WeakSetPrototype::WeakSetPrototype(Realm& realm)
     : PrototypeObject(realm.intrinsics().object_prototype())
diff --git a/Libraries/LibJS/Runtime/WeakSetPrototype.h b/Libraries/LibJS/Runtime/WeakSetPrototype.h
index 6121578b7d2..d3e1bb5bcba 100644
--- a/Libraries/LibJS/Runtime/WeakSetPrototype.h
+++ b/Libraries/LibJS/Runtime/WeakSetPrototype.h
@@ -13,7 +13,7 @@ namespace JS {
 
 class WeakSetPrototype final : public PrototypeObject<WeakSetPrototype, WeakSet> {
     JS_PROTOTYPE_OBJECT(WeakSetPrototype, WeakSet, WeakSet);
-    JS_DECLARE_ALLOCATOR(WeakSetPrototype);
+    GC_DECLARE_ALLOCATOR(WeakSetPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.cpp b/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.cpp
index 05b49c18320..ff3f7a3b350 100644
--- a/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.cpp
+++ b/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.cpp
@@ -10,7 +10,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WrapForValidIteratorPrototype);
+GC_DEFINE_ALLOCATOR(WrapForValidIteratorPrototype);
 
 // 27.1.3.2.1.1 The %WrapForValidIteratorPrototype% Object, https://tc39.es/ecma262/#sec-%wrapforvaliditeratorprototype%-object
 WrapForValidIteratorPrototype::WrapForValidIteratorPrototype(Realm& realm)
diff --git a/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.h b/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.h
index 36d37467224..43bc5a94734 100644
--- a/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.h
+++ b/Libraries/LibJS/Runtime/WrapForValidIteratorPrototype.h
@@ -14,7 +14,7 @@ namespace JS {
 
 class WrapForValidIteratorPrototype final : public PrototypeObject<WrapForValidIteratorPrototype, Iterator> {
     JS_PROTOTYPE_OBJECT(WrapForValidIteratorPrototype, Iterator, Iterator);
-    JS_DECLARE_ALLOCATOR(WrapForValidIteratorPrototype);
+    GC_DECLARE_ALLOCATOR(WrapForValidIteratorPrototype);
 
 public:
     virtual void initialize(Realm&) override;
diff --git a/Libraries/LibJS/Runtime/WrappedFunction.cpp b/Libraries/LibJS/Runtime/WrappedFunction.cpp
index a7b21367406..5b25fa7f287 100644
--- a/Libraries/LibJS/Runtime/WrappedFunction.cpp
+++ b/Libraries/LibJS/Runtime/WrappedFunction.cpp
@@ -10,10 +10,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(WrappedFunction);
+GC_DEFINE_ALLOCATOR(WrappedFunction);
 
 // 3.1.1 WrappedFunctionCreate ( callerRealm: a Realm Record, Target: a function object, ), https://tc39.es/proposal-shadowrealm/#sec-wrappedfunctioncreate
-ThrowCompletionOr<NonnullGCPtr<WrappedFunction>> WrappedFunction::create(Realm& realm, Realm& caller_realm, FunctionObject& target)
+ThrowCompletionOr<GC::Ref<WrappedFunction>> WrappedFunction::create(Realm& realm, Realm& caller_realm, FunctionObject& target)
 {
     auto& vm = realm.vm();
 
@@ -99,7 +99,7 @@ ThrowCompletionOr<Value> ordinary_wrapped_function_call(WrappedFunction const& f
     auto* target_realm = TRY(get_function_realm(vm, target));
 
     // 6. Let wrappedArgs be a new empty List.
-    auto wrapped_args = MarkedVector<Value> { vm.heap() };
+    auto wrapped_args = GC::MarkedVector<Value> { vm.heap() };
     wrapped_args.ensure_capacity(arguments_list.size());
 
     // 7. For each element arg of argumentsList, do
diff --git a/Libraries/LibJS/Runtime/WrappedFunction.h b/Libraries/LibJS/Runtime/WrappedFunction.h
index e884c515cac..9cdd0e798c8 100644
--- a/Libraries/LibJS/Runtime/WrappedFunction.h
+++ b/Libraries/LibJS/Runtime/WrappedFunction.h
@@ -13,10 +13,10 @@ namespace JS {
 
 class WrappedFunction final : public FunctionObject {
     JS_OBJECT(WrappedFunction, FunctionObject);
-    JS_DECLARE_ALLOCATOR(WrappedFunction);
+    GC_DECLARE_ALLOCATOR(WrappedFunction);
 
 public:
-    static ThrowCompletionOr<NonnullGCPtr<WrappedFunction>> create(Realm&, Realm& caller_realm, FunctionObject& target_function);
+    static ThrowCompletionOr<GC::Ref<WrappedFunction>> create(Realm&, Realm& caller_realm, FunctionObject& target_function);
 
     virtual ~WrappedFunction() = default;
 
@@ -36,8 +36,8 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // Internal Slots of Wrapped Function Exotic Objects, https://tc39.es/proposal-shadowrealm/#table-internal-slots-of-wrapped-function-exotic-objects
-    NonnullGCPtr<FunctionObject> m_wrapped_target_function; // [[WrappedTargetFunction]]
-    NonnullGCPtr<Realm> m_realm;                            // [[Realm]]
+    GC::Ref<FunctionObject> m_wrapped_target_function; // [[WrappedTargetFunction]]
+    GC::Ref<Realm> m_realm;                            // [[Realm]]
 };
 
 ThrowCompletionOr<Value> ordinary_wrapped_function_call(WrappedFunction const&, Value this_argument, ReadonlySpan<Value> arguments_list);
diff --git a/Libraries/LibJS/Script.cpp b/Libraries/LibJS/Script.cpp
index 80a93cccf61..99a80d43528 100644
--- a/Libraries/LibJS/Script.cpp
+++ b/Libraries/LibJS/Script.cpp
@@ -12,10 +12,10 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(Script);
+GC_DEFINE_ALLOCATOR(Script);
 
 // 16.1.5 ParseScript ( sourceText, realm, hostDefined ), https://tc39.es/ecma262/#sec-parse-script
-Result<NonnullGCPtr<Script>, Vector<ParserError>> Script::parse(StringView source_text, Realm& realm, StringView filename, HostDefined* host_defined, size_t line_number_offset)
+Result<GC::Ref<Script>, Vector<ParserError>> Script::parse(StringView source_text, Realm& realm, StringView filename, HostDefined* host_defined, size_t line_number_offset)
 {
     // 1. Let script be ParseText(sourceText, Script).
     auto parser = Parser(Lexer(source_text, filename, line_number_offset));
diff --git a/Libraries/LibJS/Script.h b/Libraries/LibJS/Script.h
index 17c61e82901..53bbb628a52 100644
--- a/Libraries/LibJS/Script.h
+++ b/Libraries/LibJS/Script.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/NonnullRefPtr.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibJS/ParserError.h>
 #include <LibJS/Runtime/Realm.h>
 
@@ -16,8 +16,8 @@ namespace JS {
 
 // 16.1.4 Script Records, https://tc39.es/ecma262/#sec-script-records
 class Script final : public Cell {
-    JS_CELL(Script, Cell);
-    JS_DECLARE_ALLOCATOR(Script);
+    GC_CELL(Script, Cell);
+    GC_DECLARE_ALLOCATOR(Script);
 
 public:
     struct HostDefined {
@@ -27,7 +27,7 @@ public:
     };
 
     virtual ~Script() override;
-    static Result<NonnullGCPtr<Script>, Vector<ParserError>> parse(StringView source_text, Realm&, StringView filename = {}, HostDefined* = nullptr, size_t line_number_offset = 1);
+    static Result<GC::Ref<Script>, Vector<ParserError>> parse(StringView source_text, Realm&, StringView filename = {}, HostDefined* = nullptr, size_t line_number_offset = 1);
 
     Realm& realm() { return *m_realm; }
     Program const& parse_node() const { return *m_parse_node; }
@@ -42,7 +42,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    GCPtr<Realm> m_realm;                         // [[Realm]]
+    GC::Ptr<Realm> m_realm;                       // [[Realm]]
     NonnullRefPtr<Program> m_parse_node;          // [[ECMAScriptCode]]
     Vector<ModuleWithSpecifier> m_loaded_modules; // [[LoadedModules]]
 
diff --git a/Libraries/LibJS/SourceTextModule.cpp b/Libraries/LibJS/SourceTextModule.cpp
index 8fa932ac6f7..ff200d5fbe3 100644
--- a/Libraries/LibJS/SourceTextModule.cpp
+++ b/Libraries/LibJS/SourceTextModule.cpp
@@ -18,7 +18,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SourceTextModule);
+GC_DEFINE_ALLOCATOR(SourceTextModule);
 
 // 16.2.2.2 Static Semantics: WithClauseToAttributes, https://tc39.es/proposal-import-attributes/#sec-with-clause-to-attributes
 static Vector<ImportAttribute> with_clause_to_assertions(Vector<ImportAttribute> const& source_attributes)
@@ -126,7 +126,7 @@ void SourceTextModule::visit_edges(Cell::Visitor& visitor)
 }
 
 // 16.2.1.6.1 ParseModule ( sourceText, realm, hostDefined ), https://tc39.es/ecma262/#sec-parsemodule
-Result<NonnullGCPtr<SourceTextModule>, Vector<ParserError>> SourceTextModule::parse(StringView source_text, Realm& realm, StringView filename, Script::HostDefined* host_defined)
+Result<GC::Ref<SourceTextModule>, Vector<ParserError>> SourceTextModule::parse(StringView source_text, Realm& realm, StringView filename, Script::HostDefined* host_defined)
 {
     // 1. Let body be ParseText(sourceText, Module).
     auto parser = Parser(Lexer(source_text, filename), Program::Type::Module);
@@ -421,7 +421,7 @@ ThrowCompletionOr<void> SourceTextModule::initialize_environment(VM& vm)
     m_execution_context->realm = &realm();
 
     // 12. Set the ScriptOrModule of moduleContext to module.
-    m_execution_context->script_or_module = NonnullGCPtr<Module>(*this);
+    m_execution_context->script_or_module = GC::Ref<Module>(*this);
 
     // 13. Set the VariableEnvironment of moduleContext to module.[[Environment]].
     m_execution_context->variable_environment = environment;
@@ -671,7 +671,7 @@ ThrowCompletionOr<ResolvedBinding> SourceTextModule::resolve_export(VM& vm, Depr
 }
 
 // 16.2.1.6.5 ExecuteModule ( [ capability ] ), https://tc39.es/ecma262/#sec-source-text-module-record-execute-module
-ThrowCompletionOr<void> SourceTextModule::execute_module(VM& vm, GCPtr<PromiseCapability> capability)
+ThrowCompletionOr<void> SourceTextModule::execute_module(VM& vm, GC::Ptr<PromiseCapability> capability)
 {
     dbgln_if(JS_MODULE_DEBUG, "[JS MODULE] SourceTextModule::execute_module({}, PromiseCapability @ {})", filename(), capability.ptr());
 
@@ -687,7 +687,7 @@ ThrowCompletionOr<void> SourceTextModule::execute_module(VM& vm, GCPtr<PromiseCa
     module_context->realm = &realm();
 
     // 4. Set the ScriptOrModule of moduleContext to module.
-    module_context->script_or_module = NonnullGCPtr<Module>(*this);
+    module_context->script_or_module = GC::Ref<Module>(*this);
 
     // 5. Assert: module has been linked and declarations in its module environment have been instantiated.
     VERIFY(m_status != ModuleStatus::New);
diff --git a/Libraries/LibJS/SourceTextModule.h b/Libraries/LibJS/SourceTextModule.h
index 221808b1461..5e2c37ac442 100644
--- a/Libraries/LibJS/SourceTextModule.h
+++ b/Libraries/LibJS/SourceTextModule.h
@@ -15,13 +15,13 @@ namespace JS {
 
 // 16.2.1.6 Source Text Module Records, https://tc39.es/ecma262/#sec-source-text-module-records
 class SourceTextModule final : public CyclicModule {
-    JS_CELL(SourceTextModule, CyclicModule);
-    JS_DECLARE_ALLOCATOR(SourceTextModule);
+    GC_CELL(SourceTextModule, CyclicModule);
+    GC_DECLARE_ALLOCATOR(SourceTextModule);
 
 public:
     virtual ~SourceTextModule() override;
 
-    static Result<NonnullGCPtr<SourceTextModule>, Vector<ParserError>> parse(StringView source_text, Realm&, StringView filename = {}, Script::HostDefined* host_defined = nullptr);
+    static Result<GC::Ref<SourceTextModule>, Vector<ParserError>> parse(StringView source_text, Realm&, StringView filename = {}, Script::HostDefined* host_defined = nullptr);
 
     Program const& parse_node() const { return *m_ecmascript_code; }
 
@@ -33,7 +33,7 @@ public:
 
 protected:
     virtual ThrowCompletionOr<void> initialize_environment(VM& vm) override;
-    virtual ThrowCompletionOr<void> execute_module(VM& vm, GCPtr<PromiseCapability> capability) override;
+    virtual ThrowCompletionOr<void> execute_module(VM& vm, GC::Ptr<PromiseCapability> capability) override;
 
 private:
     SourceTextModule(Realm&, StringView filename, Script::HostDefined* host_defined, bool has_top_level_await, NonnullRefPtr<Program> body, Vector<ModuleRequest> requested_modules,
@@ -45,7 +45,7 @@ private:
 
     NonnullRefPtr<Program> m_ecmascript_code;            // [[ECMAScriptCode]]
     NonnullOwnPtr<ExecutionContext> m_execution_context; // [[Context]]
-    GCPtr<Object> m_import_meta;                         // [[ImportMeta]]
+    GC::Ptr<Object> m_import_meta;                       // [[ImportMeta]]
     Vector<ImportEntry> m_import_entries;                // [[ImportEntries]]
     Vector<ExportEntry> m_local_export_entries;          // [[LocalExportEntries]]
     Vector<ExportEntry> m_indirect_export_entries;       // [[IndirectExportEntries]]
diff --git a/Libraries/LibJS/SyntheticModule.cpp b/Libraries/LibJS/SyntheticModule.cpp
index 1ef73d59794..f27b700a759 100644
--- a/Libraries/LibJS/SyntheticModule.cpp
+++ b/Libraries/LibJS/SyntheticModule.cpp
@@ -15,7 +15,7 @@
 
 namespace JS {
 
-JS_DEFINE_ALLOCATOR(SyntheticModule);
+GC_DEFINE_ALLOCATOR(SyntheticModule);
 
 // 1.2.1 CreateSyntheticModule ( exportNames, evaluationSteps, realm, hostDefined ), https://tc39.es/proposal-json-modules/#sec-createsyntheticmodule
 SyntheticModule::SyntheticModule(Vector<DeprecatedFlyString> export_names, SyntheticModule::EvaluationFunction evaluation_steps, Realm& realm, StringView filename)
@@ -90,7 +90,7 @@ ThrowCompletionOr<Promise*> SyntheticModule::evaluate(VM& vm)
     module_context->realm = &realm();
 
     // 5. Set the ScriptOrModule of moduleContext to module.
-    module_context->script_or_module = NonnullGCPtr<Module>(*this);
+    module_context->script_or_module = GC::Ref<Module>(*this);
 
     // 6. Set the VariableEnvironment of moduleContext to module.[[Environment]].
     module_context->variable_environment = environment();
@@ -133,11 +133,11 @@ ThrowCompletionOr<void> SyntheticModule::set_synthetic_module_export(DeprecatedF
 }
 
 // 1.3 CreateDefaultExportSyntheticModule ( defaultExport ), https://tc39.es/proposal-json-modules/#sec-create-default-export-synthetic-module
-NonnullGCPtr<SyntheticModule> SyntheticModule::create_default_export_synthetic_module(Value default_export, Realm& realm, StringView filename)
+GC::Ref<SyntheticModule> SyntheticModule::create_default_export_synthetic_module(Value default_export, Realm& realm, StringView filename)
 {
     // Note: Has some changes from PR: https://github.com/tc39/proposal-json-modules/pull/13.
     // 1. Let closure be the a Abstract Closure with parameters (module) that captures defaultExport and performs the following steps when called:
-    auto closure = [default_export = make_handle(default_export)](SyntheticModule& module) -> ThrowCompletionOr<void> {
+    auto closure = [default_export = make_root(default_export)](SyntheticModule& module) -> ThrowCompletionOr<void> {
         // a. Return ? module.SetSyntheticExport("default", defaultExport).
         return module.set_synthetic_module_export("default", default_export.value());
     };
@@ -147,7 +147,7 @@ NonnullGCPtr<SyntheticModule> SyntheticModule::create_default_export_synthetic_m
 }
 
 // 1.4 ParseJSONModule ( source ), https://tc39.es/proposal-json-modules/#sec-parse-json-module
-ThrowCompletionOr<NonnullGCPtr<Module>> parse_json_module(StringView source_text, Realm& realm, StringView filename)
+ThrowCompletionOr<GC::Ref<Module>> parse_json_module(StringView source_text, Realm& realm, StringView filename)
 {
     auto& vm = realm.vm();
 
@@ -162,7 +162,7 @@ ThrowCompletionOr<NonnullGCPtr<Module>> parse_json_module(StringView source_text
 }
 
 // 1.2.3.1 LoadRequestedModules ( ), https://tc39.es/proposal-json-modules/#sec-smr-LoadRequestedModules
-PromiseCapability& SyntheticModule::load_requested_modules(GCPtr<GraphLoadingState::HostDefined>)
+PromiseCapability& SyntheticModule::load_requested_modules(GC::Ptr<GraphLoadingState::HostDefined>)
 {
     // 1. Return ! PromiseResolve(%Promise%, undefined).
     auto& constructor = *vm().current_realm()->intrinsics().promise_constructor();
diff --git a/Libraries/LibJS/SyntheticModule.h b/Libraries/LibJS/SyntheticModule.h
index c99f0186834..a76002f5235 100644
--- a/Libraries/LibJS/SyntheticModule.h
+++ b/Libraries/LibJS/SyntheticModule.h
@@ -12,13 +12,13 @@ namespace JS {
 
 // 1.2 Synthetic Module Records, https://tc39.es/proposal-json-modules/#sec-synthetic-module-records
 class SyntheticModule final : public Module {
-    JS_CELL(SyntheticModule, Module);
-    JS_DECLARE_ALLOCATOR(SyntheticModule);
+    GC_CELL(SyntheticModule, Module);
+    GC_DECLARE_ALLOCATOR(SyntheticModule);
 
 public:
     using EvaluationFunction = Function<ThrowCompletionOr<void>(SyntheticModule&)>;
 
-    static NonnullGCPtr<SyntheticModule> create_default_export_synthetic_module(Value default_export, Realm& realm, StringView filename);
+    static GC::Ref<SyntheticModule> create_default_export_synthetic_module(Value default_export, Realm& realm, StringView filename);
 
     ThrowCompletionOr<void> set_synthetic_module_export(DeprecatedFlyString const& export_name, Value export_value);
 
@@ -26,7 +26,7 @@ public:
     virtual ThrowCompletionOr<Promise*> evaluate(VM& vm) override;
     virtual ThrowCompletionOr<Vector<DeprecatedFlyString>> get_exported_names(VM& vm, Vector<Module*> export_star_set) override;
     virtual ThrowCompletionOr<ResolvedBinding> resolve_export(VM& vm, DeprecatedFlyString const& export_name, Vector<ResolvedBinding> resolve_set) override;
-    virtual PromiseCapability& load_requested_modules(GCPtr<GraphLoadingState::HostDefined>) override;
+    virtual PromiseCapability& load_requested_modules(GC::Ptr<GraphLoadingState::HostDefined>) override;
 
 private:
     SyntheticModule(Vector<DeprecatedFlyString> export_names, EvaluationFunction evaluation_steps, Realm& realm, StringView filename);
@@ -35,6 +35,6 @@ private:
     EvaluationFunction m_evaluation_steps;      // [[EvaluationSteps]]
 };
 
-ThrowCompletionOr<NonnullGCPtr<Module>> parse_json_module(StringView source_text, Realm& realm, StringView filename);
+ThrowCompletionOr<GC::Ref<Module>> parse_json_module(StringView source_text, Realm& realm, StringView filename);
 
 }
diff --git a/Libraries/LibTest/JavaScriptTestRunner.h b/Libraries/LibTest/JavaScriptTestRunner.h
index ccfcb854fd8..66ef1daab47 100644
--- a/Libraries/LibTest/JavaScriptTestRunner.h
+++ b/Libraries/LibTest/JavaScriptTestRunner.h
@@ -214,7 +214,7 @@ inline ByteBuffer load_entire_file(StringView path)
     return buffer_or_error.release_value();
 }
 
-inline AK::Result<JS::NonnullGCPtr<JS::Script>, ParserError> parse_script(StringView path, JS::Realm& realm)
+inline AK::Result<GC::Ref<JS::Script>, ParserError> parse_script(StringView path, JS::Realm& realm)
 {
     auto contents = load_entire_file(path);
     auto script_or_errors = JS::Script::parse(contents, realm, path);
@@ -227,7 +227,7 @@ inline AK::Result<JS::NonnullGCPtr<JS::Script>, ParserError> parse_script(String
     return script_or_errors.release_value();
 }
 
-inline AK::Result<JS::NonnullGCPtr<JS::SourceTextModule>, ParserError> parse_module(StringView path, JS::Realm& realm)
+inline AK::Result<GC::Ref<JS::SourceTextModule>, ParserError> parse_module(StringView path, JS::Realm& realm)
 {
     auto contents = load_entire_file(path);
     auto script_or_errors = JS::SourceTextModule::parse(contents, realm, path);
@@ -278,8 +278,8 @@ inline JSFileResult TestRunner::run_file_test(ByteString const& test_path)
 
     double start_time = get_time_in_ms();
 
-    JS::GCPtr<JS::Realm> realm;
-    JS::GCPtr<TestRunnerGlobalObject> global_object;
+    GC::Ptr<JS::Realm> realm;
+    GC::Ptr<TestRunnerGlobalObject> global_object;
     auto root_execution_context = MUST(JS::Realm::initialize_host_defined_realm(
         *g_vm,
         [&](JS::Realm& realm_) -> JS::GlobalObject* {
diff --git a/Libraries/LibWasm/CMakeLists.txt b/Libraries/LibWasm/CMakeLists.txt
index 163b7dd9cb8..caefd9636a0 100644
--- a/Libraries/LibWasm/CMakeLists.txt
+++ b/Libraries/LibWasm/CMakeLists.txt
@@ -9,6 +9,6 @@ set(SOURCES
 )
 
 serenity_lib(LibWasm wasm)
-target_link_libraries(LibWasm PRIVATE LibCore LibJS)
+target_link_libraries(LibWasm PRIVATE LibCore LibGC LibJS)
 
 include(wasm_spec_tests)
diff --git a/Libraries/LibWeb/Animations/Animatable.cpp b/Libraries/LibWeb/Animations/Animatable.cpp
index 038e6dd94c4..12486bda427 100644
--- a/Libraries/LibWeb/Animations/Animatable.cpp
+++ b/Libraries/LibWeb/Animations/Animatable.cpp
@@ -19,10 +19,10 @@
 namespace Web::Animations {
 
 // https://www.w3.org/TR/web-animations-1/#dom-animatable-animate
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> Animatable::animate(Optional<JS::Handle<JS::Object>> keyframes, Variant<Empty, double, KeyframeAnimationOptions> options)
+WebIDL::ExceptionOr<GC::Ref<Animation>> Animatable::animate(Optional<GC::Root<JS::Object>> keyframes, Variant<Empty, double, KeyframeAnimationOptions> options)
 {
     // 1. Let target be the object on which this method was called.
-    JS::NonnullGCPtr target { *static_cast<DOM::Element*>(this) };
+    GC::Ref target { *static_cast<DOM::Element*>(this) };
     auto& realm = target->realm();
 
     // 2. Construct a new KeyframeEffect object, effect, in the relevant Realm of target by using the same procedure as
@@ -37,7 +37,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> Animatable::animate(Optional<JS
     // 3. If options is a KeyframeAnimationOptions object, let timeline be the timeline member of options or, if
     //    timeline member of options is missing, be the default document timeline of the node document of the element
     //    on which this method was called.
-    Optional<JS::GCPtr<AnimationTimeline>> timeline;
+    Optional<GC::Ptr<AnimationTimeline>> timeline;
     if (options.has<KeyframeAnimationOptions>())
         timeline = options.get<KeyframeAnimationOptions>().timeline;
     if (!timeline.has_value())
@@ -60,13 +60,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> Animatable::animate(Optional<JS
 }
 
 // https://drafts.csswg.org/web-animations-1/#dom-animatable-getanimations
-WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> Animatable::get_animations(Optional<GetAnimationsOptions> options)
+WebIDL::ExceptionOr<Vector<GC::Ref<Animation>>> Animatable::get_animations(Optional<GetAnimationsOptions> options)
 {
     verify_cast<DOM::Element>(*this).document().update_style();
     return get_animations_internal(options);
 }
 
-WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> Animatable::get_animations_internal(Optional<GetAnimationsOptions> options)
+WebIDL::ExceptionOr<Vector<GC::Ref<Animation>>> Animatable::get_animations_internal(Optional<GetAnimationsOptions> options)
 {
     // 1. Let object be the object on which this method was called.
 
@@ -82,11 +82,11 @@ WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> Animatable::get_animati
     //    Otherwise, let target be object.
     // FIXME: We can't refer to pseudo-elements directly, and they also can't be animated yet.
     (void)pseudo_element;
-    JS::NonnullGCPtr target { *static_cast<DOM::Element*>(this) };
+    GC::Ref target { *static_cast<DOM::Element*>(this) };
 
     // 4. If options is passed with subtree set to true, then return the set of relevant animations for a subtree of target.
     //    Otherwise, return the set of relevant animations for target.
-    Vector<JS::NonnullGCPtr<Animation>> relevant_animations;
+    Vector<GC::Ref<Animation>> relevant_animations;
     for (auto const& animation : m_associated_animations) {
         if (animation->is_relevant())
             relevant_animations.append(*animation);
@@ -102,7 +102,7 @@ WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> Animatable::get_animati
 
     // The returned list is sorted using the composite order described for the associated animations of effects in
     // §5.4.2 The effect stack.
-    quick_sort(relevant_animations, [](JS::NonnullGCPtr<Animation>& a, JS::NonnullGCPtr<Animation>& b) {
+    quick_sort(relevant_animations, [](GC::Ref<Animation>& a, GC::Ref<Animation>& b) {
         auto& a_effect = verify_cast<KeyframeEffect>(*a->effect());
         auto& b_effect = verify_cast<KeyframeEffect>(*b->effect());
         return KeyframeEffect::composite_order(a_effect, b_effect) < 0;
@@ -111,13 +111,13 @@ WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> Animatable::get_animati
     return relevant_animations;
 }
 
-void Animatable::associate_with_animation(JS::NonnullGCPtr<Animation> animation)
+void Animatable::associate_with_animation(GC::Ref<Animation> animation)
 {
     m_associated_animations.append(animation);
     m_is_sorted_by_composite_order = false;
 }
 
-void Animatable::disassociate_with_animation(JS::NonnullGCPtr<Animation> animation)
+void Animatable::disassociate_with_animation(GC::Ref<Animation> animation)
 {
     m_associated_animations.remove_first_matching([&](auto element) { return animation == element; });
 }
@@ -148,14 +148,14 @@ Optional<Animatable::TransitionAttributes const&> Animatable::property_transitio
     return {};
 }
 
-JS::GCPtr<CSS::CSSTransition> Animatable::property_transition(CSS::PropertyID property) const
+GC::Ptr<CSS::CSSTransition> Animatable::property_transition(CSS::PropertyID property) const
 {
     if (auto maybe_animation = m_associated_transitions.get(property); maybe_animation.has_value())
         return maybe_animation.value();
     return {};
 }
 
-void Animatable::set_transition(CSS::PropertyID property, JS::NonnullGCPtr<CSS::CSSTransition> animation)
+void Animatable::set_transition(CSS::PropertyID property, GC::Ref<CSS::CSSTransition> animation)
 {
     VERIFY(!m_associated_transitions.contains(property));
     m_associated_transitions.set(property, animation);
@@ -185,14 +185,14 @@ void Animatable::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_associated_transitions);
 }
 
-JS::GCPtr<CSS::CSSStyleDeclaration const> Animatable::cached_animation_name_source(Optional<CSS::Selector::PseudoElement::Type> pseudo_element) const
+GC::Ptr<CSS::CSSStyleDeclaration const> Animatable::cached_animation_name_source(Optional<CSS::Selector::PseudoElement::Type> pseudo_element) const
 {
     if (pseudo_element.has_value())
         return m_cached_animation_name_source[to_underlying(pseudo_element.value()) + 1];
     return m_cached_animation_name_source[0];
 }
 
-void Animatable::set_cached_animation_name_source(JS::GCPtr<CSS::CSSStyleDeclaration const> value, Optional<CSS::Selector::PseudoElement::Type> pseudo_element)
+void Animatable::set_cached_animation_name_source(GC::Ptr<CSS::CSSStyleDeclaration const> value, Optional<CSS::Selector::PseudoElement::Type> pseudo_element)
 {
     if (pseudo_element.has_value()) {
         m_cached_animation_name_source[to_underlying(pseudo_element.value()) + 1] = value;
@@ -201,14 +201,14 @@ void Animatable::set_cached_animation_name_source(JS::GCPtr<CSS::CSSStyleDeclara
     }
 }
 
-JS::GCPtr<Animations::Animation> Animatable::cached_animation_name_animation(Optional<CSS::Selector::PseudoElement::Type> pseudo_element) const
+GC::Ptr<Animations::Animation> Animatable::cached_animation_name_animation(Optional<CSS::Selector::PseudoElement::Type> pseudo_element) const
 {
     if (pseudo_element.has_value())
         return m_cached_animation_name_animation[to_underlying(pseudo_element.value()) + 1];
     return m_cached_animation_name_animation[0];
 }
 
-void Animatable::set_cached_animation_name_animation(JS::GCPtr<Animations::Animation> value, Optional<CSS::Selector::PseudoElement::Type> pseudo_element)
+void Animatable::set_cached_animation_name_animation(GC::Ptr<Animations::Animation> value, Optional<CSS::Selector::PseudoElement::Type> pseudo_element)
 {
     if (pseudo_element.has_value()) {
         m_cached_animation_name_animation[to_underlying(pseudo_element.value()) + 1] = value;
diff --git a/Libraries/LibWeb/Animations/Animatable.h b/Libraries/LibWeb/Animations/Animatable.h
index 80f4504e8f5..1ccaaa6d96f 100644
--- a/Libraries/LibWeb/Animations/Animatable.h
+++ b/Libraries/LibWeb/Animations/Animatable.h
@@ -20,7 +20,7 @@ namespace Web::Animations {
 // https://drafts.csswg.org/web-animations-1/#dictdef-keyframeanimationoptions
 struct KeyframeAnimationOptions : public KeyframeEffectOptions {
     FlyString id { ""_fly_string };
-    Optional<JS::GCPtr<AnimationTimeline>> timeline;
+    Optional<GC::Ptr<AnimationTimeline>> timeline;
 };
 
 // https://drafts.csswg.org/web-animations-1/#dictdef-getanimationsoptions
@@ -40,43 +40,43 @@ public:
 
     virtual ~Animatable() = default;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> animate(Optional<JS::Handle<JS::Object>> keyframes, Variant<Empty, double, KeyframeAnimationOptions> options = {});
-    WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> get_animations(Optional<GetAnimationsOptions> options = {});
-    WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animation>>> get_animations_internal(Optional<GetAnimationsOptions> options = {});
+    WebIDL::ExceptionOr<GC::Ref<Animation>> animate(Optional<GC::Root<JS::Object>> keyframes, Variant<Empty, double, KeyframeAnimationOptions> options = {});
+    WebIDL::ExceptionOr<Vector<GC::Ref<Animation>>> get_animations(Optional<GetAnimationsOptions> options = {});
+    WebIDL::ExceptionOr<Vector<GC::Ref<Animation>>> get_animations_internal(Optional<GetAnimationsOptions> options = {});
 
-    void associate_with_animation(JS::NonnullGCPtr<Animation>);
-    void disassociate_with_animation(JS::NonnullGCPtr<Animation>);
+    void associate_with_animation(GC::Ref<Animation>);
+    void disassociate_with_animation(GC::Ref<Animation>);
 
-    JS::GCPtr<CSS::CSSStyleDeclaration const> cached_animation_name_source(Optional<CSS::Selector::PseudoElement::Type>) const;
-    void set_cached_animation_name_source(JS::GCPtr<CSS::CSSStyleDeclaration const> value, Optional<CSS::Selector::PseudoElement::Type>);
+    GC::Ptr<CSS::CSSStyleDeclaration const> cached_animation_name_source(Optional<CSS::Selector::PseudoElement::Type>) const;
+    void set_cached_animation_name_source(GC::Ptr<CSS::CSSStyleDeclaration const> value, Optional<CSS::Selector::PseudoElement::Type>);
 
-    JS::GCPtr<Animations::Animation> cached_animation_name_animation(Optional<CSS::Selector::PseudoElement::Type>) const;
-    void set_cached_animation_name_animation(JS::GCPtr<Animations::Animation> value, Optional<CSS::Selector::PseudoElement::Type>);
+    GC::Ptr<Animations::Animation> cached_animation_name_animation(Optional<CSS::Selector::PseudoElement::Type>) const;
+    void set_cached_animation_name_animation(GC::Ptr<Animations::Animation> value, Optional<CSS::Selector::PseudoElement::Type>);
 
-    JS::GCPtr<CSS::CSSStyleDeclaration const> cached_transition_property_source() const { return m_cached_transition_property_source; }
-    void set_cached_transition_property_source(JS::GCPtr<CSS::CSSStyleDeclaration const> value) { m_cached_transition_property_source = value; }
+    GC::Ptr<CSS::CSSStyleDeclaration const> cached_transition_property_source() const { return m_cached_transition_property_source; }
+    void set_cached_transition_property_source(GC::Ptr<CSS::CSSStyleDeclaration const> value) { m_cached_transition_property_source = value; }
 
     void add_transitioned_properties(Vector<Vector<CSS::PropertyID>> properties, CSS::StyleValueVector delays, CSS::StyleValueVector durations, CSS::StyleValueVector timing_functions);
     Optional<TransitionAttributes const&> property_transition_attributes(CSS::PropertyID) const;
-    void set_transition(CSS::PropertyID, JS::NonnullGCPtr<CSS::CSSTransition>);
+    void set_transition(CSS::PropertyID, GC::Ref<CSS::CSSTransition>);
     void remove_transition(CSS::PropertyID);
-    JS::GCPtr<CSS::CSSTransition> property_transition(CSS::PropertyID) const;
+    GC::Ptr<CSS::CSSTransition> property_transition(CSS::PropertyID) const;
     void clear_transitions();
 
 protected:
     void visit_edges(JS::Cell::Visitor&);
 
 private:
-    Vector<JS::NonnullGCPtr<Animation>> m_associated_animations;
+    Vector<GC::Ref<Animation>> m_associated_animations;
     bool m_is_sorted_by_composite_order { true };
 
-    Array<JS::GCPtr<CSS::CSSStyleDeclaration const>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount) + 1> m_cached_animation_name_source;
-    Array<JS::GCPtr<Animations::Animation>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount) + 1> m_cached_animation_name_animation;
+    Array<GC::Ptr<CSS::CSSStyleDeclaration const>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount) + 1> m_cached_animation_name_source;
+    Array<GC::Ptr<Animations::Animation>, to_underlying(CSS::Selector::PseudoElement::Type::KnownPseudoElementCount) + 1> m_cached_animation_name_animation;
 
     HashMap<CSS::PropertyID, size_t> m_transition_attribute_indices;
     Vector<TransitionAttributes> m_transition_attributes;
-    JS::GCPtr<CSS::CSSStyleDeclaration const> m_cached_transition_property_source;
-    HashMap<CSS::PropertyID, JS::NonnullGCPtr<CSS::CSSTransition>> m_associated_transitions;
+    GC::Ptr<CSS::CSSStyleDeclaration const> m_cached_transition_property_source;
+    HashMap<CSS::PropertyID, GC::Ref<CSS::CSSTransition>> m_associated_transitions;
 };
 
 }
diff --git a/Libraries/LibWeb/Animations/Animation.cpp b/Libraries/LibWeb/Animations/Animation.cpp
index cabaf248f52..bf618518b1f 100644
--- a/Libraries/LibWeb/Animations/Animation.cpp
+++ b/Libraries/LibWeb/Animations/Animation.cpp
@@ -22,10 +22,10 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(Animation);
+GC_DEFINE_ALLOCATOR(Animation);
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-animation
-JS::NonnullGCPtr<Animation> Animation::create(JS::Realm& realm, JS::GCPtr<AnimationEffect> effect, Optional<JS::GCPtr<AnimationTimeline>> timeline)
+GC::Ref<Animation> Animation::create(JS::Realm& realm, GC::Ptr<AnimationEffect> effect, Optional<GC::Ptr<AnimationTimeline>> timeline)
 {
     // 1. Let animation be a new Animation object.
     auto animation = realm.create<Animation>(realm);
@@ -45,13 +45,13 @@ JS::NonnullGCPtr<Animation> Animation::create(JS::Realm& realm, JS::GCPtr<Animat
     return animation;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> Animation::construct_impl(JS::Realm& realm, JS::GCPtr<AnimationEffect> effect, Optional<JS::GCPtr<AnimationTimeline>> timeline)
+WebIDL::ExceptionOr<GC::Ref<Animation>> Animation::construct_impl(JS::Realm& realm, GC::Ptr<AnimationEffect> effect, Optional<GC::Ptr<AnimationTimeline>> timeline)
 {
     return create(realm, effect, timeline);
 }
 
 // https://www.w3.org/TR/web-animations-1/#animation-set-the-associated-effect-of-an-animation
-void Animation::set_effect(JS::GCPtr<AnimationEffect> new_effect)
+void Animation::set_effect(GC::Ptr<AnimationEffect> new_effect)
 {
     // Setting this attribute updates the object’s associated effect using the procedure to set the associated effect of
     // an animation.
@@ -97,7 +97,7 @@ void Animation::set_effect(JS::GCPtr<AnimationEffect> new_effect)
 }
 
 // https://www.w3.org/TR/web-animations-1/#animation-set-the-timeline-of-an-animation
-void Animation::set_timeline(JS::GCPtr<AnimationTimeline> new_timeline)
+void Animation::set_timeline(GC::Ptr<AnimationTimeline> new_timeline)
 {
     // Setting this attribute updates the object’s timeline using the procedure to set the timeline of an animation.
 
@@ -376,37 +376,37 @@ void Animation::set_replace_state(Bindings::AnimationReplaceState value)
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-onfinish
-JS::GCPtr<WebIDL::CallbackType> Animation::onfinish()
+GC::Ptr<WebIDL::CallbackType> Animation::onfinish()
 {
     return event_handler_attribute(HTML::EventNames::finish);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-onfinish
-void Animation::set_onfinish(JS::GCPtr<WebIDL::CallbackType> event_handler)
+void Animation::set_onfinish(GC::Ptr<WebIDL::CallbackType> event_handler)
 {
     set_event_handler_attribute(HTML::EventNames::finish, event_handler);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-oncancel
-JS::GCPtr<WebIDL::CallbackType> Animation::oncancel()
+GC::Ptr<WebIDL::CallbackType> Animation::oncancel()
 {
     return event_handler_attribute(HTML::EventNames::cancel);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-oncancel
-void Animation::set_oncancel(JS::GCPtr<WebIDL::CallbackType> event_handler)
+void Animation::set_oncancel(GC::Ptr<WebIDL::CallbackType> event_handler)
 {
     set_event_handler_attribute(HTML::EventNames::cancel, event_handler);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-onremove
-JS::GCPtr<WebIDL::CallbackType> Animation::onremove()
+GC::Ptr<WebIDL::CallbackType> Animation::onremove()
 {
     return event_handler_attribute(HTML::EventNames::remove);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animation-onremove
-void Animation::set_onremove(JS::GCPtr<WebIDL::CallbackType> event_handler)
+void Animation::set_onremove(GC::Ptr<WebIDL::CallbackType> event_handler)
 {
     set_event_handler_attribute(HTML::EventNames::remove, event_handler);
 }
@@ -463,7 +463,7 @@ void Animation::cancel(ShouldInvalidate should_invalidate)
                 scheduled_event_time = m_timeline->convert_a_timeline_time_to_an_origin_relative_time(m_timeline->current_time());
             document->append_pending_animation_event({ cancel_event, *this, *this, scheduled_event_time });
         } else {
-            HTML::queue_global_task(HTML::Task::Source::DOMManipulation, realm.global_object(), JS::create_heap_function(heap(), [this, cancel_event]() {
+            HTML::queue_global_task(HTML::Task::Source::DOMManipulation, realm.global_object(), GC::create_function(heap(), [this, cancel_event]() {
                 dispatch_event(cancel_event);
             }));
         }
@@ -918,7 +918,7 @@ Optional<double> Animation::convert_a_timeline_time_to_an_origin_relative_time(O
 }
 
 // https://www.w3.org/TR/web-animations-1/#animation-document-for-timing
-JS::GCPtr<DOM::Document> Animation::document_for_timing() const
+GC::Ptr<DOM::Document> Animation::document_for_timing() const
 {
     // An animation’s document for timing is the Document with which its timeline is associated. If an animation is not
     // associated with a timeline, or its timeline is not associated with a document, then it has no document for
@@ -1105,7 +1105,7 @@ void Animation::update_finished_state(DidSeek did_seek, SynchronouslyNotify sync
     //    steps:
     if (current_finished_state && !m_is_finished) {
         // 1. Let finish notification steps refer to the following procedure:
-        auto finish_notification_steps = JS::create_heap_function(heap(), [this, &realm]() {
+        auto finish_notification_steps = GC::create_function(heap(), [this, &realm]() {
             // 1. If animation’s play state is not equal to finished, abort these steps.
             if (play_state() != Bindings::AnimationPlayState::Finished)
                 return;
@@ -1147,7 +1147,7 @@ void Animation::update_finished_state(DidSeek did_seek, SynchronouslyNotify sync
                 // Manually create a task so its ID can be saved
                 auto& document = verify_cast<HTML::Window>(realm.global_object()).associated_document();
                 auto task = HTML::Task::create(vm(), HTML::Task::Source::DOMManipulation, &document,
-                    JS::create_heap_function(heap(), [this, finish_event]() {
+                    GC::create_function(heap(), [this, finish_event]() {
                         dispatch_event(finish_event);
                     }));
                 m_pending_finish_microtask_id = task->id();
@@ -1304,7 +1304,7 @@ void Animation::run_pending_pause_task()
     update_finished_state(DidSeek::No, SynchronouslyNotify::No);
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> Animation::current_ready_promise() const
+GC::Ref<WebIDL::Promise> Animation::current_ready_promise() const
 {
     if (!m_current_ready_promise) {
         // The current ready promise is initially a resolved Promise created using the procedure to create a new
@@ -1315,7 +1315,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Animation::current_ready_promise() const
     return *m_current_ready_promise;
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> Animation::current_finished_promise() const
+GC::Ref<WebIDL::Promise> Animation::current_finished_promise() const
 {
     if (!m_current_finished_promise) {
         // The current finished promise is initially a pending Promise object.
diff --git a/Libraries/LibWeb/Animations/Animation.h b/Libraries/LibWeb/Animations/Animation.h
index 860628a6843..7491e4c21d2 100644
--- a/Libraries/LibWeb/Animations/Animation.h
+++ b/Libraries/LibWeb/Animations/Animation.h
@@ -24,20 +24,20 @@ enum class AnimationClass {
 // https://www.w3.org/TR/web-animations-1/#the-animation-interface
 class Animation : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(Animation, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Animation);
+    GC_DECLARE_ALLOCATOR(Animation);
 
 public:
-    static JS::NonnullGCPtr<Animation> create(JS::Realm&, JS::GCPtr<AnimationEffect>, Optional<JS::GCPtr<AnimationTimeline>>);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Animation>> construct_impl(JS::Realm&, JS::GCPtr<AnimationEffect>, Optional<JS::GCPtr<AnimationTimeline>>);
+    static GC::Ref<Animation> create(JS::Realm&, GC::Ptr<AnimationEffect>, Optional<GC::Ptr<AnimationTimeline>>);
+    static WebIDL::ExceptionOr<GC::Ref<Animation>> construct_impl(JS::Realm&, GC::Ptr<AnimationEffect>, Optional<GC::Ptr<AnimationTimeline>>);
 
     FlyString const& id() const { return m_id; }
     void set_id(FlyString value) { m_id = move(value); }
 
-    JS::GCPtr<AnimationEffect> effect() const { return m_effect; }
-    void set_effect(JS::GCPtr<AnimationEffect>);
+    GC::Ptr<AnimationEffect> effect() const { return m_effect; }
+    void set_effect(GC::Ptr<AnimationEffect>);
 
-    JS::GCPtr<AnimationTimeline> timeline() const { return m_timeline; }
-    void set_timeline(JS::GCPtr<AnimationTimeline>);
+    GC::Ptr<AnimationTimeline> timeline() const { return m_timeline; }
+    void set_timeline(GC::Ptr<AnimationTimeline>);
 
     Optional<double> const& start_time() const { return m_start_time; }
     void set_start_time(Optional<double> const&);
@@ -60,18 +60,18 @@ public:
     bool pending() const { return m_pending_play_task == TaskState::Scheduled || m_pending_pause_task == TaskState::Scheduled; }
 
     // https://www.w3.org/TR/web-animations-1/#dom-animation-ready
-    JS::NonnullGCPtr<WebIDL::Promise> ready() const { return current_ready_promise(); }
+    GC::Ref<WebIDL::Promise> ready() const { return current_ready_promise(); }
 
     // https://www.w3.org/TR/web-animations-1/#dom-animation-finished
-    JS::NonnullGCPtr<WebIDL::Promise> finished() const { return current_finished_promise(); }
+    GC::Ref<WebIDL::Promise> finished() const { return current_finished_promise(); }
     bool is_finished() const { return m_is_finished; }
 
-    JS::GCPtr<WebIDL::CallbackType> onfinish();
-    void set_onfinish(JS::GCPtr<WebIDL::CallbackType>);
-    JS::GCPtr<WebIDL::CallbackType> oncancel();
-    void set_oncancel(JS::GCPtr<WebIDL::CallbackType>);
-    JS::GCPtr<WebIDL::CallbackType> onremove();
-    void set_onremove(JS::GCPtr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> onfinish();
+    void set_onfinish(GC::Ptr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> oncancel();
+    void set_oncancel(GC::Ptr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> onremove();
+    void set_onremove(GC::Ptr<WebIDL::CallbackType>);
 
     enum class AutoRewind {
         Yes,
@@ -93,7 +93,7 @@ public:
     Optional<double> convert_an_animation_time_to_timeline_time(Optional<double>) const;
     Optional<double> convert_a_timeline_time_to_an_origin_relative_time(Optional<double>) const;
 
-    JS::GCPtr<DOM::Document> document_for_timing() const;
+    GC::Ptr<DOM::Document> document_for_timing() const;
     void notify_timeline_time_did_change();
 
     void effect_timing_changed(Badge<AnimationEffect>);
@@ -101,11 +101,11 @@ public:
     virtual bool is_css_animation() const { return false; }
     virtual bool is_css_transition() const { return false; }
 
-    JS::GCPtr<DOM::Element> owning_element() const { return m_owning_element; }
-    void set_owning_element(JS::GCPtr<DOM::Element> value) { m_owning_element = value; }
+    GC::Ptr<DOM::Element> owning_element() const { return m_owning_element; }
+    void set_owning_element(GC::Ptr<DOM::Element> value) { m_owning_element = value; }
 
     virtual AnimationClass animation_class() const { return AnimationClass::None; }
-    virtual Optional<int> class_specific_composite_order(JS::NonnullGCPtr<Animation>) const { return {}; }
+    virtual Optional<int> class_specific_composite_order(GC::Ref<Animation>) const { return {}; }
 
     unsigned int global_animation_list_order() const { return m_global_animation_list_order; }
 
@@ -144,8 +144,8 @@ private:
     void run_pending_play_task();
     void run_pending_pause_task();
 
-    JS::NonnullGCPtr<WebIDL::Promise> current_ready_promise() const;
-    JS::NonnullGCPtr<WebIDL::Promise> current_finished_promise() const;
+    GC::Ref<WebIDL::Promise> current_ready_promise() const;
+    GC::Ref<WebIDL::Promise> current_finished_promise() const;
 
     void invalidate_effect();
 
@@ -156,10 +156,10 @@ private:
     unsigned int m_global_animation_list_order { 0 };
 
     // https://www.w3.org/TR/web-animations-1/#dom-animation-effect
-    JS::GCPtr<AnimationEffect> m_effect;
+    GC::Ptr<AnimationEffect> m_effect;
 
     // https://www.w3.org/TR/web-animations-1/#dom-animation-timeline
-    JS::GCPtr<AnimationTimeline> m_timeline;
+    GC::Ptr<AnimationTimeline> m_timeline;
 
     // https://www.w3.org/TR/web-animations-1/#animation-start-time
     Optional<double> m_start_time {};
@@ -181,10 +181,10 @@ private:
 
     // Note: The following promises are initialized lazily to avoid constructing them outside of an execution context
     // https://www.w3.org/TR/web-animations-1/#current-ready-promise
-    mutable JS::GCPtr<WebIDL::Promise> m_current_ready_promise;
+    mutable GC::Ptr<WebIDL::Promise> m_current_ready_promise;
 
     // https://www.w3.org/TR/web-animations-1/#current-finished-promise
-    mutable JS::GCPtr<WebIDL::Promise> m_current_finished_promise;
+    mutable GC::Ptr<WebIDL::Promise> m_current_finished_promise;
     bool m_is_finished { false };
 
     // https://www.w3.org/TR/web-animations-1/#pending-play-task
@@ -194,7 +194,7 @@ private:
     TaskState m_pending_pause_task { TaskState::None };
 
     // https://www.w3.org/TR/css-animations-2/#owning-element-section
-    JS::GCPtr<DOM::Element> m_owning_element;
+    GC::Ptr<DOM::Element> m_owning_element;
 
     Optional<HTML::TaskID> m_pending_finish_microtask_id;
 
diff --git a/Libraries/LibWeb/Animations/AnimationEffect.cpp b/Libraries/LibWeb/Animations/AnimationEffect.cpp
index 6dfe4652678..a5bd22a919e 100644
--- a/Libraries/LibWeb/Animations/AnimationEffect.cpp
+++ b/Libraries/LibWeb/Animations/AnimationEffect.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(AnimationEffect);
+GC_DEFINE_ALLOCATOR(AnimationEffect);
 
 Bindings::FillMode css_fill_mode_to_bindings_fill_mode(CSS::AnimationFillMode mode)
 {
@@ -201,7 +201,7 @@ WebIDL::ExceptionOr<void> AnimationEffect::update_timing(OptionalEffectTiming ti
     return {};
 }
 
-void AnimationEffect::set_associated_animation(JS::GCPtr<Animation> value)
+void AnimationEffect::set_associated_animation(GC::Ptr<Animation> value)
 {
     m_associated_animation = value;
 }
diff --git a/Libraries/LibWeb/Animations/AnimationEffect.h b/Libraries/LibWeb/Animations/AnimationEffect.h
index bcc584fe6f8..9b6a2de42ef 100644
--- a/Libraries/LibWeb/Animations/AnimationEffect.h
+++ b/Libraries/LibWeb/Animations/AnimationEffect.h
@@ -62,7 +62,7 @@ Bindings::PlaybackDirection css_animation_direction_to_bindings_playback_directi
 // https://www.w3.org/TR/web-animations-1/#the-animationeffect-interface
 class AnimationEffect : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AnimationEffect, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AnimationEffect);
+    GC_DECLARE_ALLOCATOR(AnimationEffect);
 
 public:
     static RefPtr<CSS::CSSStyleValue const> parse_easing_string(JS::Realm& realm, StringView value);
@@ -95,8 +95,8 @@ public:
     CSS::EasingStyleValue::Function const& timing_function() { return m_timing_function; }
     void set_timing_function(CSS::EasingStyleValue::Function value) { m_timing_function = move(value); }
 
-    JS::GCPtr<Animation> associated_animation() const { return m_associated_animation; }
-    void set_associated_animation(JS::GCPtr<Animation> value);
+    GC::Ptr<Animation> associated_animation() const { return m_associated_animation; }
+    void set_associated_animation(GC::Ptr<Animation> value);
 
     AnimationDirection animation_direction() const;
 
@@ -175,7 +175,7 @@ protected:
     Bindings::PlaybackDirection m_playback_direction { Bindings::PlaybackDirection::Normal };
 
     // https://www.w3.org/TR/web-animations-1/#animation-associated-effect
-    JS::GCPtr<Animation> m_associated_animation {};
+    GC::Ptr<Animation> m_associated_animation {};
 
     // https://www.w3.org/TR/web-animations-1/#time-transformations
     CSS::EasingStyleValue::Function m_timing_function { CSS::EasingStyleValue::Linear::identity() };
diff --git a/Libraries/LibWeb/Animations/AnimationPlaybackEvent.cpp b/Libraries/LibWeb/Animations/AnimationPlaybackEvent.cpp
index ff54b5041bd..ca762783f20 100644
--- a/Libraries/LibWeb/Animations/AnimationPlaybackEvent.cpp
+++ b/Libraries/LibWeb/Animations/AnimationPlaybackEvent.cpp
@@ -10,15 +10,15 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(AnimationPlaybackEvent);
+GC_DEFINE_ALLOCATOR(AnimationPlaybackEvent);
 
-JS::NonnullGCPtr<AnimationPlaybackEvent> AnimationPlaybackEvent::create(JS::Realm& realm, FlyString const& type, AnimationPlaybackEventInit const& event_init)
+GC::Ref<AnimationPlaybackEvent> AnimationPlaybackEvent::create(JS::Realm& realm, FlyString const& type, AnimationPlaybackEventInit const& event_init)
 {
     return realm.create<AnimationPlaybackEvent>(realm, type, event_init);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-animationplaybackevent-animationplaybackevent
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AnimationPlaybackEvent>> AnimationPlaybackEvent::construct_impl(JS::Realm& realm, FlyString const& type, AnimationPlaybackEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<AnimationPlaybackEvent>> AnimationPlaybackEvent::construct_impl(JS::Realm& realm, FlyString const& type, AnimationPlaybackEventInit const& event_init)
 {
     return create(realm, type, event_init);
 }
diff --git a/Libraries/LibWeb/Animations/AnimationPlaybackEvent.h b/Libraries/LibWeb/Animations/AnimationPlaybackEvent.h
index 70f9a361dcb..029a0aaf72a 100644
--- a/Libraries/LibWeb/Animations/AnimationPlaybackEvent.h
+++ b/Libraries/LibWeb/Animations/AnimationPlaybackEvent.h
@@ -20,11 +20,11 @@ struct AnimationPlaybackEventInit : public DOM::EventInit {
 // https://www.w3.org/TR/web-animations-1/#animationplaybackevent
 class AnimationPlaybackEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(AnimationPlaybackEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(AnimationPlaybackEvent);
+    GC_DECLARE_ALLOCATOR(AnimationPlaybackEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<AnimationPlaybackEvent> create(JS::Realm&, FlyString const& type, AnimationPlaybackEventInit const& event_init = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AnimationPlaybackEvent>> construct_impl(JS::Realm&, FlyString const& type, AnimationPlaybackEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<AnimationPlaybackEvent> create(JS::Realm&, FlyString const& type, AnimationPlaybackEventInit const& event_init = {});
+    static WebIDL::ExceptionOr<GC::Ref<AnimationPlaybackEvent>> construct_impl(JS::Realm&, FlyString const& type, AnimationPlaybackEventInit const& event_init);
 
     virtual ~AnimationPlaybackEvent() override = default;
 
diff --git a/Libraries/LibWeb/Animations/AnimationTimeline.cpp b/Libraries/LibWeb/Animations/AnimationTimeline.cpp
index aa98820565f..6761da42ec7 100644
--- a/Libraries/LibWeb/Animations/AnimationTimeline.cpp
+++ b/Libraries/LibWeb/Animations/AnimationTimeline.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(AnimationTimeline);
+GC_DEFINE_ALLOCATOR(AnimationTimeline);
 
 void AnimationTimeline::set_current_time(Optional<double> value)
 {
@@ -28,7 +28,7 @@ void AnimationTimeline::set_current_time(Optional<double> value)
         animation->notify_timeline_time_did_change();
 }
 
-void AnimationTimeline::set_associated_document(JS::GCPtr<DOM::Document> document)
+void AnimationTimeline::set_associated_document(GC::Ptr<DOM::Document> document)
 {
     if (document)
         document->associate_with_timeline(*this);
diff --git a/Libraries/LibWeb/Animations/AnimationTimeline.h b/Libraries/LibWeb/Animations/AnimationTimeline.h
index 8ef4c156b5c..814a867475e 100644
--- a/Libraries/LibWeb/Animations/AnimationTimeline.h
+++ b/Libraries/LibWeb/Animations/AnimationTimeline.h
@@ -13,14 +13,14 @@ namespace Web::Animations {
 // https://www.w3.org/TR/web-animations-1/#animationtimeline
 class AnimationTimeline : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AnimationTimeline, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AnimationTimeline);
+    GC_DECLARE_ALLOCATOR(AnimationTimeline);
 
 public:
     Optional<double> current_time() const { return m_current_time; }
     virtual void set_current_time(Optional<double>);
 
-    JS::GCPtr<DOM::Document> associated_document() const { return m_associated_document; }
-    void set_associated_document(JS::GCPtr<DOM::Document>);
+    GC::Ptr<DOM::Document> associated_document() const { return m_associated_document; }
+    void set_associated_document(GC::Ptr<DOM::Document>);
 
     virtual bool is_inactive() const;
     bool is_monotonically_increasing() const { return m_is_monotonically_increasing; }
@@ -29,9 +29,9 @@ public:
     virtual Optional<double> convert_a_timeline_time_to_an_origin_relative_time(Optional<double>) { VERIFY_NOT_REACHED(); }
     virtual bool can_convert_a_timeline_time_to_an_origin_relative_time() const { return false; }
 
-    void associate_with_animation(JS::NonnullGCPtr<Animation> value) { m_associated_animations.set(value); }
-    void disassociate_with_animation(JS::NonnullGCPtr<Animation> value) { m_associated_animations.remove(value); }
-    HashTable<JS::NonnullGCPtr<Animation>> const& associated_animations() const { return m_associated_animations; }
+    void associate_with_animation(GC::Ref<Animation> value) { m_associated_animations.set(value); }
+    void disassociate_with_animation(GC::Ref<Animation> value) { m_associated_animations.remove(value); }
+    HashTable<GC::Ref<Animation>> const& associated_animations() const { return m_associated_animations; }
 
 protected:
     AnimationTimeline(JS::Realm&);
@@ -47,9 +47,9 @@ protected:
     bool m_is_monotonically_increasing { true };
 
     // https://www.w3.org/TR/web-animations-1/#timeline-associated-with-a-document
-    JS::GCPtr<DOM::Document> m_associated_document {};
+    GC::Ptr<DOM::Document> m_associated_document {};
 
-    HashTable<JS::NonnullGCPtr<Animation>> m_associated_animations {};
+    HashTable<GC::Ref<Animation>> m_associated_animations {};
 };
 
 }
diff --git a/Libraries/LibWeb/Animations/DocumentTimeline.cpp b/Libraries/LibWeb/Animations/DocumentTimeline.cpp
index 480e4e62d68..04f2b5c086d 100644
--- a/Libraries/LibWeb/Animations/DocumentTimeline.cpp
+++ b/Libraries/LibWeb/Animations/DocumentTimeline.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Animations/DocumentTimeline.h>
 #include <LibWeb/Bindings/DocumentTimelinePrototype.h>
@@ -15,9 +15,9 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(DocumentTimeline);
+GC_DEFINE_ALLOCATOR(DocumentTimeline);
 
-JS::NonnullGCPtr<DocumentTimeline> DocumentTimeline::create(JS::Realm& realm, DOM::Document& document, HighResolutionTime::DOMHighResTimeStamp origin_time)
+GC::Ref<DocumentTimeline> DocumentTimeline::create(JS::Realm& realm, DOM::Document& document, HighResolutionTime::DOMHighResTimeStamp origin_time)
 {
     auto timeline = realm.create<DocumentTimeline>(realm, document, origin_time);
     auto current_time = document.last_animation_frame_timestamp();
@@ -32,7 +32,7 @@ JS::NonnullGCPtr<DocumentTimeline> DocumentTimeline::create(JS::Realm& realm, DO
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-documenttimeline-documenttimeline
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentTimeline>> DocumentTimeline::construct_impl(JS::Realm& realm, DocumentTimelineOptions options)
+WebIDL::ExceptionOr<GC::Ref<DocumentTimeline>> DocumentTimeline::construct_impl(JS::Realm& realm, DocumentTimelineOptions options)
 {
     // Creates a new DocumentTimeline. The Document with which the timeline is associated is the Document associated
     // with the Window that is the current global object.
diff --git a/Libraries/LibWeb/Animations/DocumentTimeline.h b/Libraries/LibWeb/Animations/DocumentTimeline.h
index d63571db8d9..bcf9c63fec8 100644
--- a/Libraries/LibWeb/Animations/DocumentTimeline.h
+++ b/Libraries/LibWeb/Animations/DocumentTimeline.h
@@ -20,11 +20,11 @@ struct DocumentTimelineOptions {
 // https://www.w3.org/TR/web-animations-1/#the-documenttimeline-interface
 class DocumentTimeline : public AnimationTimeline {
     WEB_PLATFORM_OBJECT(DocumentTimeline, AnimationTimeline);
-    JS_DECLARE_ALLOCATOR(DocumentTimeline);
+    GC_DECLARE_ALLOCATOR(DocumentTimeline);
 
 public:
-    static JS::NonnullGCPtr<DocumentTimeline> create(JS::Realm&, DOM::Document&, HighResolutionTime::DOMHighResTimeStamp origin_time);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentTimeline>> construct_impl(JS::Realm&, DocumentTimelineOptions options = {});
+    static GC::Ref<DocumentTimeline> create(JS::Realm&, DOM::Document&, HighResolutionTime::DOMHighResTimeStamp origin_time);
+    static WebIDL::ExceptionOr<GC::Ref<DocumentTimeline>> construct_impl(JS::Realm&, DocumentTimelineOptions options = {});
 
     virtual void set_current_time(Optional<double> current_time) override;
     virtual bool is_inactive() const override;
diff --git a/Libraries/LibWeb/Animations/KeyframeEffect.cpp b/Libraries/LibWeb/Animations/KeyframeEffect.cpp
index cb6bb4fef67..3b5500e506d 100644
--- a/Libraries/LibWeb/Animations/KeyframeEffect.cpp
+++ b/Libraries/LibWeb/Animations/KeyframeEffect.cpp
@@ -18,7 +18,7 @@
 
 namespace Web::Animations {
 
-JS_DEFINE_ALLOCATOR(KeyframeEffect);
+GC_DEFINE_ALLOCATOR(KeyframeEffect);
 
 template<typename T>
 WebIDL::ExceptionOr<Variant<T, Vector<T>>> convert_value_to_maybe_list(JS::Realm& realm, JS::Value value, Function<WebIDL::ExceptionOr<T>(JS::Value)>& value_converter)
@@ -312,7 +312,7 @@ static bool is_loosely_sorted_by_offset(Vector<BaseKeyframe> const& keyframes)
 }
 
 // https://www.w3.org/TR/web-animations-1/#process-a-keyframes-argument
-static WebIDL::ExceptionOr<Vector<BaseKeyframe>> process_a_keyframes_argument(JS::Realm& realm, JS::GCPtr<JS::Object> object)
+static WebIDL::ExceptionOr<Vector<BaseKeyframe>> process_a_keyframes_argument(JS::Realm& realm, GC::Ptr<JS::Object> object)
 {
     auto& vm = realm.vm();
 
@@ -617,7 +617,7 @@ void KeyframeEffect::generate_initial_and_final_frames(RefPtr<KeyFrameSet> keyfr
 }
 
 // https://www.w3.org/TR/web-animations-1/#animation-composite-order
-int KeyframeEffect::composite_order(JS::NonnullGCPtr<KeyframeEffect> a, JS::NonnullGCPtr<KeyframeEffect> b)
+int KeyframeEffect::composite_order(GC::Ref<KeyframeEffect> a, GC::Ref<KeyframeEffect> b)
 {
     // 1. Let the associated animation of an animation effect be the animation associated with the animation effect.
     auto a_animation = a->associated_animation();
@@ -646,16 +646,16 @@ int KeyframeEffect::composite_order(JS::NonnullGCPtr<KeyframeEffect> a, JS::Nonn
     return a_animation->global_animation_list_order() - b_animation->global_animation_list_order();
 }
 
-JS::NonnullGCPtr<KeyframeEffect> KeyframeEffect::create(JS::Realm& realm)
+GC::Ref<KeyframeEffect> KeyframeEffect::create(JS::Realm& realm)
 {
     return realm.create<KeyframeEffect>(realm);
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-keyframeeffect-keyframeeffect
-WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyframeEffect>> KeyframeEffect::construct_impl(
+WebIDL::ExceptionOr<GC::Ref<KeyframeEffect>> KeyframeEffect::construct_impl(
     JS::Realm& realm,
-    JS::Handle<DOM::Element> const& target,
-    Optional<JS::Handle<JS::Object>> const& keyframes,
+    GC::Root<DOM::Element> const& target,
+    Optional<GC::Root<JS::Object>> const& keyframes,
     Variant<double, KeyframeEffectOptions> options)
 {
     // 1. Create a new KeyframeEffect object, effect.
@@ -717,7 +717,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyframeEffect>> KeyframeEffect::construct_
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-keyframeeffect-keyframeeffect-source
-WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyframeEffect>> KeyframeEffect::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<KeyframeEffect> source)
+WebIDL::ExceptionOr<GC::Ref<KeyframeEffect>> KeyframeEffect::construct_impl(JS::Realm& realm, GC::Ref<KeyframeEffect> source)
 {
     // 1. Create a new KeyframeEffect object, effect.
     auto effect = realm.create<KeyframeEffect>(realm);
@@ -798,7 +798,7 @@ Optional<CSS::Selector::PseudoElement::Type> KeyframeEffect::pseudo_element_type
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-keyframeeffect-getkeyframes
-WebIDL::ExceptionOr<JS::MarkedVector<JS::Object*>> KeyframeEffect::get_keyframes()
+WebIDL::ExceptionOr<GC::MarkedVector<JS::Object*>> KeyframeEffect::get_keyframes()
 {
     if (m_keyframe_objects.size() != m_keyframes.size()) {
         auto& vm = this->vm();
@@ -833,17 +833,17 @@ WebIDL::ExceptionOr<JS::MarkedVector<JS::Object*>> KeyframeEffect::get_keyframes
         }
     }
 
-    JS::MarkedVector<JS::Object*> keyframes { heap() };
+    GC::MarkedVector<JS::Object*> keyframes { heap() };
     for (auto const& keyframe : m_keyframe_objects)
         keyframes.append(keyframe);
     return keyframes;
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-keyframeeffect-setkeyframes
-WebIDL::ExceptionOr<void> KeyframeEffect::set_keyframes(Optional<JS::Handle<JS::Object>> const& keyframe_object)
+WebIDL::ExceptionOr<void> KeyframeEffect::set_keyframes(Optional<GC::Root<JS::Object>> const& keyframe_object)
 {
     m_keyframe_objects.clear();
-    m_keyframes = TRY(process_a_keyframes_argument(realm(), keyframe_object.has_value() ? JS::GCPtr { keyframe_object->ptr() } : JS::GCPtr<Object> {}));
+    m_keyframes = TRY(process_a_keyframes_argument(realm(), keyframe_object.has_value() ? GC::Ptr { keyframe_object->ptr() } : GC::Ptr<Object> {}));
     // FIXME: After processing the keyframe argument, we need to turn the set of keyframes into a set of computed
     //        keyframes using the procedure outlined in the second half of
     //        https://www.w3.org/TR/web-animations-1/#calculating-computed-keyframes. For now, just compute the
diff --git a/Libraries/LibWeb/Animations/KeyframeEffect.h b/Libraries/LibWeb/Animations/KeyframeEffect.h
index a716afce74a..305babea3d4 100644
--- a/Libraries/LibWeb/Animations/KeyframeEffect.h
+++ b/Libraries/LibWeb/Animations/KeyframeEffect.h
@@ -56,7 +56,7 @@ struct BaseKeyframe {
 // https://www.w3.org/TR/web-animations-1/#the-keyframeeffect-interface
 class KeyframeEffect : public AnimationEffect {
     WEB_PLATFORM_OBJECT(KeyframeEffect, AnimationEffect);
-    JS_DECLARE_ALLOCATOR(KeyframeEffect);
+    GC_DECLARE_ALLOCATOR(KeyframeEffect);
 
 public:
     constexpr static double AnimationKeyFrameKeyScaleFactor = 1000.0; // 0..100000
@@ -72,17 +72,17 @@ public:
     };
     static void generate_initial_and_final_frames(RefPtr<KeyFrameSet>, HashTable<CSS::PropertyID> const& animated_properties);
 
-    static int composite_order(JS::NonnullGCPtr<KeyframeEffect>, JS::NonnullGCPtr<KeyframeEffect>);
+    static int composite_order(GC::Ref<KeyframeEffect>, GC::Ref<KeyframeEffect>);
 
-    static JS::NonnullGCPtr<KeyframeEffect> create(JS::Realm&);
+    static GC::Ref<KeyframeEffect> create(JS::Realm&);
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyframeEffect>> construct_impl(
+    static WebIDL::ExceptionOr<GC::Ref<KeyframeEffect>> construct_impl(
         JS::Realm&,
-        JS::Handle<DOM::Element> const& target,
-        Optional<JS::Handle<JS::Object>> const& keyframes,
+        GC::Root<DOM::Element> const& target,
+        Optional<GC::Root<JS::Object>> const& keyframes,
         Variant<double, KeyframeEffectOptions> options = KeyframeEffectOptions {});
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyframeEffect>> construct_impl(JS::Realm&, JS::NonnullGCPtr<KeyframeEffect> source);
+    static WebIDL::ExceptionOr<GC::Ref<KeyframeEffect>> construct_impl(JS::Realm&, GC::Ref<KeyframeEffect> source);
 
     DOM::Element* target() const override { return m_target_element; }
     void set_target(DOM::Element* target);
@@ -97,8 +97,8 @@ public:
     Bindings::CompositeOperation composite() const { return m_composite; }
     void set_composite(Bindings::CompositeOperation value) { m_composite = value; }
 
-    WebIDL::ExceptionOr<JS::MarkedVector<JS::Object*>> get_keyframes();
-    WebIDL::ExceptionOr<void> set_keyframes(Optional<JS::Handle<JS::Object>> const&);
+    WebIDL::ExceptionOr<GC::MarkedVector<JS::Object*>> get_keyframes();
+    WebIDL::ExceptionOr<void> set_keyframes(Optional<GC::Root<JS::Object>> const&);
 
     KeyFrameSet const* key_frame_set() { return m_key_frame_set; }
     void set_key_frame_set(RefPtr<KeyFrameSet const> key_frame_set) { m_key_frame_set = key_frame_set; }
@@ -118,7 +118,7 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://www.w3.org/TR/web-animations-1/#effect-target-target-element
-    JS::GCPtr<DOM::Element> m_target_element {};
+    GC::Ptr<DOM::Element> m_target_element {};
 
     // https://www.w3.org/TR/web-animations-1/#dom-keyframeeffect-pseudoelement
     Optional<CSS::Selector::PseudoElement> m_target_pseudo_selector {};
@@ -130,7 +130,7 @@ private:
     Vector<BaseKeyframe> m_keyframes {};
 
     // A cached version of m_keyframes suitable for returning from get_keyframes()
-    Vector<JS::NonnullGCPtr<JS::Object>> m_keyframe_objects {};
+    Vector<GC::Ref<JS::Object>> m_keyframe_objects {};
 
     RefPtr<KeyFrameSet const> m_key_frame_set {};
 
diff --git a/Libraries/LibWeb/Bindings/AudioConstructor.cpp b/Libraries/LibWeb/Bindings/AudioConstructor.cpp
index a5fda03f237..87bda24cdc2 100644
--- a/Libraries/LibWeb/Bindings/AudioConstructor.cpp
+++ b/Libraries/LibWeb/Bindings/AudioConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(AudioConstructor);
+GC_DEFINE_ALLOCATOR(AudioConstructor);
 
 AudioConstructor::AudioConstructor(JS::Realm& realm)
     : NativeFunction(realm.intrinsics().function_prototype())
@@ -36,7 +36,7 @@ JS::ThrowCompletionOr<JS::Value> AudioConstructor::call()
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-audio
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> AudioConstructor::construct(FunctionObject&)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> AudioConstructor::construct(FunctionObject&)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibWeb/Bindings/AudioConstructor.h b/Libraries/LibWeb/Bindings/AudioConstructor.h
index bc1f3e70b41..a7b2e1976ce 100644
--- a/Libraries/LibWeb/Bindings/AudioConstructor.h
+++ b/Libraries/LibWeb/Bindings/AudioConstructor.h
@@ -13,7 +13,7 @@ namespace Web::Bindings {
 
 class AudioConstructor final : public JS::NativeFunction {
     JS_OBJECT(AudioConstructor, JS::NativeFunction);
-    JS_DECLARE_ALLOCATOR(AudioConstructor);
+    GC_DECLARE_ALLOCATOR(AudioConstructor);
 
 public:
     explicit AudioConstructor(JS::Realm&);
@@ -21,7 +21,7 @@ public:
     virtual ~AudioConstructor() override = default;
 
     virtual JS::ThrowCompletionOr<JS::Value> call() override;
-    virtual JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> construct(JS::FunctionObject& new_target) override;
+    virtual JS::ThrowCompletionOr<GC::Ref<JS::Object>> construct(JS::FunctionObject& new_target) override;
 
 private:
     virtual bool has_constructor() const override { return true; }
diff --git a/Libraries/LibWeb/Bindings/ExceptionOrUtils.h b/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
index 61e7f942640..d3561b3d654 100644
--- a/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
+++ b/Libraries/LibWeb/Bindings/ExceptionOrUtils.h
@@ -75,7 +75,7 @@ ALWAYS_INLINE JS::Completion dom_exception_to_throw_completion(JS::VM& vm, auto&
                 VERIFY_NOT_REACHED();
             }
         },
-        [&](JS::NonnullGCPtr<WebIDL::DOMException> const& exception) {
+        [&](GC::Ref<WebIDL::DOMException> const& exception) {
             return throw_completion(exception);
         },
         [&](JS::Completion const& completion) {
diff --git a/Libraries/LibWeb/Bindings/HostDefined.h b/Libraries/LibWeb/Bindings/HostDefined.h
index 89c564418ea..ca43d9fa1fe 100644
--- a/Libraries/LibWeb/Bindings/HostDefined.h
+++ b/Libraries/LibWeb/Bindings/HostDefined.h
@@ -6,21 +6,21 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Bindings {
 
 struct HostDefined : public JS::Realm::HostDefined {
-    explicit HostDefined(JS::NonnullGCPtr<Intrinsics> intrinsics)
+    explicit HostDefined(GC::Ref<Intrinsics> intrinsics)
         : intrinsics(intrinsics)
     {
     }
     virtual ~HostDefined() override = default;
     virtual void visit_edges(JS::Cell::Visitor& visitor) override;
 
-    JS::NonnullGCPtr<Intrinsics> intrinsics;
+    GC::Ref<Intrinsics> intrinsics;
 };
 
 }
diff --git a/Libraries/LibWeb/Bindings/ImageConstructor.cpp b/Libraries/LibWeb/Bindings/ImageConstructor.cpp
index 594fc880fcd..4e275433983 100644
--- a/Libraries/LibWeb/Bindings/ImageConstructor.cpp
+++ b/Libraries/LibWeb/Bindings/ImageConstructor.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(ImageConstructor);
+GC_DEFINE_ALLOCATOR(ImageConstructor);
 
 ImageConstructor::ImageConstructor(JS::Realm& realm)
     : NativeFunction(realm.intrinsics().function_prototype())
@@ -37,7 +37,7 @@ JS::ThrowCompletionOr<JS::Value> ImageConstructor::call()
 
 // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-image
 // https://whatpr.org/html/9893/embedded-content.html#dom-image
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> ImageConstructor::construct(FunctionObject&)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> ImageConstructor::construct(FunctionObject&)
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibWeb/Bindings/ImageConstructor.h b/Libraries/LibWeb/Bindings/ImageConstructor.h
index 4c08de4ca5a..fbeba7205b6 100644
--- a/Libraries/LibWeb/Bindings/ImageConstructor.h
+++ b/Libraries/LibWeb/Bindings/ImageConstructor.h
@@ -13,7 +13,7 @@ namespace Web::Bindings {
 
 class ImageConstructor final : public JS::NativeFunction {
     JS_OBJECT(ImageConstructor, JS::NativeFunction);
-    JS_DECLARE_ALLOCATOR(ImageConstructor);
+    GC_DECLARE_ALLOCATOR(ImageConstructor);
 
 public:
     explicit ImageConstructor(JS::Realm&);
@@ -21,7 +21,7 @@ public:
     virtual ~ImageConstructor() override = default;
 
     virtual JS::ThrowCompletionOr<JS::Value> call() override;
-    virtual JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> construct(JS::FunctionObject& new_target) override;
+    virtual JS::ThrowCompletionOr<GC::Ref<JS::Object>> construct(JS::FunctionObject& new_target) override;
 
 private:
     virtual bool has_constructor() const override { return true; }
diff --git a/Libraries/LibWeb/Bindings/Intrinsics.cpp b/Libraries/LibWeb/Bindings/Intrinsics.cpp
index 61fc83d386d..e077138ed57 100644
--- a/Libraries/LibWeb/Bindings/Intrinsics.cpp
+++ b/Libraries/LibWeb/Bindings/Intrinsics.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(Intrinsics);
+GC_DEFINE_ALLOCATOR(Intrinsics);
 
 void Intrinsics::visit_edges(JS::Cell::Visitor& visitor)
 {
diff --git a/Libraries/LibWeb/Bindings/Intrinsics.h b/Libraries/LibWeb/Bindings/Intrinsics.h
index dad208e8e07..d2140b5618e 100644
--- a/Libraries/LibWeb/Bindings/Intrinsics.h
+++ b/Libraries/LibWeb/Bindings/Intrinsics.h
@@ -9,9 +9,9 @@
 #include <AK/FlyString.h>
 #include <AK/Forward.h>
 #include <AK/HashMap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/VM.h>
 
 #define WEB_SET_PROTOTYPE_FOR_INTERFACE_WITH_CUSTOM_NAME(interface_class, interface_name)                  \
@@ -25,8 +25,8 @@
 namespace Web::Bindings {
 
 class Intrinsics final : public JS::Cell {
-    JS_CELL(Intrinsics, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Intrinsics);
+    GC_CELL(Intrinsics, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Intrinsics);
 
 public:
     Intrinsics(JS::Realm& realm)
@@ -75,10 +75,10 @@ private:
     template<typename PrototypeType>
     void create_web_prototype_and_constructor(JS::Realm& realm);
 
-    HashMap<FlyString, JS::NonnullGCPtr<JS::Object>> m_namespaces;
-    HashMap<FlyString, JS::NonnullGCPtr<JS::Object>> m_prototypes;
-    HashMap<FlyString, JS::GCPtr<JS::NativeFunction>> m_constructors;
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    HashMap<FlyString, GC::Ref<JS::Object>> m_namespaces;
+    HashMap<FlyString, GC::Ref<JS::Object>> m_prototypes;
+    HashMap<FlyString, GC::Ptr<JS::NativeFunction>> m_constructors;
+    GC::Ref<JS::Realm> m_realm;
 };
 
 Intrinsics& host_defined_intrinsics(JS::Realm& realm);
diff --git a/Libraries/LibWeb/Bindings/MainThreadVM.cpp b/Libraries/LibWeb/Bindings/MainThreadVM.cpp
index 85738fd1854..3be54fd7ba1 100644
--- a/Libraries/LibWeb/Bindings/MainThreadVM.cpp
+++ b/Libraries/LibWeb/Bindings/MainThreadVM.cpp
@@ -7,8 +7,8 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibGC/DeferGC.h>
 #include <LibJS/AST.h>
-#include <LibJS/Heap/DeferGC.h>
 #include <LibJS/Module.h>
 #include <LibJS/Runtime/Array.h>
 #include <LibJS/Runtime/Environment.h>
@@ -71,10 +71,10 @@ HTML::Script* active_script()
     // 2. If record is null, return null.
     // 3. Return record.[[HostDefined]].
     return record.visit(
-        [](JS::NonnullGCPtr<JS::Script>& js_script) -> HTML::Script* {
+        [](GC::Ref<JS::Script>& js_script) -> HTML::Script* {
             return verify_cast<HTML::ClassicScript>(js_script->host_defined());
         },
-        [](JS::NonnullGCPtr<JS::Module>& js_module) -> HTML::Script* {
+        [](GC::Ref<JS::Module>& js_module) -> HTML::Script* {
             return verify_cast<HTML::ModuleScript>(js_module->host_defined());
         },
         [](Empty) -> HTML::Script* {
@@ -137,10 +137,10 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         //    The running script is the script in the [[HostDefined]] field in the ScriptOrModule component of the running JavaScript execution context.
         HTML::Script* script { nullptr };
         vm.running_execution_context().script_or_module.visit(
-            [&script](JS::NonnullGCPtr<JS::Script>& js_script) {
+            [&script](GC::Ref<JS::Script>& js_script) {
                 script = verify_cast<HTML::ClassicScript>(js_script->host_defined());
             },
-            [&script](JS::NonnullGCPtr<JS::Module>& js_module) {
+            [&script](GC::Ref<JS::Module>& js_module) {
                 script = verify_cast<HTML::ModuleScript>(js_module->host_defined());
             },
             [](Empty) {
@@ -186,7 +186,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
 
             // 4. Queue a global task on the DOM manipulation task source given global to fire an event named rejectionhandled at global, using PromiseRejectionEvent,
             //    with the promise attribute initialized to promise, and the reason attribute initialized to the value of promise's [[PromiseResult]] internal slot.
-            HTML::queue_global_task(HTML::Task::Source::DOMManipulation, global, JS::create_heap_function(s_main_thread_vm->heap(), [&global, &promise] {
+            HTML::queue_global_task(HTML::Task::Source::DOMManipulation, global, GC::create_function(s_main_thread_vm->heap(), [&global, &promise] {
                 // FIXME: This currently assumes that global is a WindowObject.
                 auto& window = verify_cast<HTML::Window>(global);
 
@@ -245,7 +245,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         auto& global = finalization_registry.realm().global_object();
 
         // 2. Queue a global task on the JavaScript engine task source given global to perform the following steps:
-        HTML::queue_global_task(HTML::Task::Source::JavaScriptEngine, global, JS::create_heap_function(s_main_thread_vm->heap(), [&finalization_registry] {
+        HTML::queue_global_task(HTML::Task::Source::JavaScriptEngine, global, GC::create_function(s_main_thread_vm->heap(), [&finalization_registry] {
             // 1. Let entry be finalizationRegistry.[[CleanupCallback]].[[Callback]].[[Realm]].
             auto& entry = *finalization_registry.cleanup_callback().callback().realm();
 
@@ -270,7 +270,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
 
     // 8.1.5.4.3 HostEnqueuePromiseJob(job, realm), https://html.spec.whatwg.org/multipage/webappapis.html#hostenqueuepromisejob
     // // https://whatpr.org/html/9893/webappapis.html#hostenqueuepromisejob
-    s_main_thread_vm->host_enqueue_promise_job = [](JS::NonnullGCPtr<JS::HeapFunction<JS::ThrowCompletionOr<JS::Value>()>> job, JS::Realm* realm) {
+    s_main_thread_vm->host_enqueue_promise_job = [](GC::Ref<GC::Function<JS::ThrowCompletionOr<JS::Value>()>> job, JS::Realm* realm) {
         auto& vm = *s_main_thread_vm;
 
         // IMPLEMENTATION DEFINED: The JS spec says we must take implementation defined steps to make the currently active script or module at the time of HostEnqueuePromiseJob being invoked
@@ -284,7 +284,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         auto* script = active_script();
 
         auto& heap = realm ? realm->heap() : vm.heap();
-        HTML::queue_a_microtask(script ? script->settings_object().responsible_document().ptr() : nullptr, JS::create_heap_function(heap, [&vm, realm, job = move(job), script_or_module = move(script_or_module)] {
+        HTML::queue_a_microtask(script ? script->settings_object().responsible_document().ptr() : nullptr, GC::create_function(heap, [&vm, realm, job = move(job), script_or_module = move(script_or_module)] {
             // The dummy execution context has to be kept up here to keep it alive for the duration of the function.
             OwnPtr<JS::ExecutionContext> dummy_execution_context;
 
@@ -338,7 +338,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
 
     // 8.1.5.4.4 HostMakeJobCallback(callable), https://html.spec.whatwg.org/multipage/webappapis.html#hostmakejobcallback
     // https://whatpr.org/html/9893/webappapis.html#hostmakejobcallback
-    s_main_thread_vm->host_make_job_callback = [](JS::FunctionObject& callable) -> JS::NonnullGCPtr<JS::JobCallback> {
+    s_main_thread_vm->host_make_job_callback = [](JS::FunctionObject& callable) -> GC::Ref<JS::JobCallback> {
         // 1. Let incumbent realm be the incumbent realm.
         auto& incumbent_realm = HTML::incumbent_realm();
 
@@ -355,10 +355,10 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
             script_execution_context->function = nullptr;
             script_execution_context->realm = &script->realm();
             if (is<HTML::ClassicScript>(script)) {
-                script_execution_context->script_or_module = JS::NonnullGCPtr<JS::Script>(*verify_cast<HTML::ClassicScript>(script)->script_record());
+                script_execution_context->script_or_module = GC::Ref<JS::Script>(*verify_cast<HTML::ClassicScript>(script)->script_record());
             } else if (is<HTML::ModuleScript>(script)) {
                 if (is<HTML::JavaScriptModuleScript>(script)) {
-                    script_execution_context->script_or_module = JS::NonnullGCPtr<JS::Module>(*verify_cast<HTML::JavaScriptModuleScript>(script)->record());
+                    script_execution_context->script_or_module = GC::Ref<JS::Module>(*verify_cast<HTML::JavaScriptModuleScript>(script)->record());
                 } else {
                     // NOTE: Handle CSS and JSON module scripts once we have those.
                     VERIFY_NOT_REACHED();
@@ -388,7 +388,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         auto url_string = module_script.base_url().serialize();
 
         // 4. Let steps be the following steps, given the argument specifier:
-        auto steps = [module_script = JS::NonnullGCPtr { module_script }](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
+        auto steps = [module_script = GC::Ref { module_script }](JS::VM& vm) -> JS::ThrowCompletionOr<JS::Value> {
             auto specifier = vm.argument(0);
 
             // 1. Set specifier to ? ToString(specifier).
@@ -425,7 +425,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
 
     // 8.1.6.7.3 HostLoadImportedModule(referrer, moduleRequest, loadState, payload), https://html.spec.whatwg.org/multipage/webappapis.html#hostloadimportedmodule
     // https://whatpr.org/html/9893/webappapis.html#hostloadimportedmodule
-    s_main_thread_vm->host_load_imported_module = [](JS::ImportedModuleReferrer referrer, JS::ModuleRequest const& module_request, JS::GCPtr<JS::GraphLoadingState::HostDefined> load_state, JS::ImportedModulePayload payload) -> void {
+    s_main_thread_vm->host_load_imported_module = [](JS::ImportedModuleReferrer referrer, JS::ModuleRequest const& module_request, GC::Ptr<JS::GraphLoadingState::HostDefined> load_state, JS::ImportedModulePayload payload) -> void {
         auto& vm = *s_main_thread_vm;
 
         // 1. Let moduleMapRealm be the current realm.
@@ -443,9 +443,9 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         Fetch::Infrastructure::Request::ReferrerType fetch_referrer = Fetch::Infrastructure::Request::Referrer::Client;
 
         // 6. If referrer is a Script Record or a Cyclic Module Record, then:
-        if (referrer.has<JS::NonnullGCPtr<JS::Script>>() || referrer.has<JS::NonnullGCPtr<JS::CyclicModule>>()) {
+        if (referrer.has<GC::Ref<JS::Script>>() || referrer.has<GC::Ref<JS::CyclicModule>>()) {
             // 1. Set referencingScript to referrer.[[HostDefined]].
-            referencing_script = verify_cast<HTML::Script>(referrer.has<JS::NonnullGCPtr<JS::Script>>() ? *referrer.get<JS::NonnullGCPtr<JS::Script>>()->host_defined() : *referrer.get<JS::NonnullGCPtr<JS::CyclicModule>>()->host_defined());
+            referencing_script = verify_cast<HTML::Script>(referrer.has<GC::Ref<JS::Script>>() ? *referrer.get<GC::Ref<JS::Script>>()->host_defined() : *referrer.get<GC::Ref<JS::CyclicModule>>()->host_defined());
 
             // 2. Set fetchReferrer to referencingScript's base URL.
             fetch_referrer = referencing_script->base_url();
@@ -488,7 +488,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
         auto destination = Fetch::Infrastructure::Request::Destination::Script;
 
         // 14. Let fetchClient be moduleMapRealm's principal realm's settings object.
-        JS::NonnullGCPtr fetch_client { HTML::principal_realm_settings_object(HTML::principal_realm(*module_map_realm)) };
+        GC::Ref fetch_client { HTML::principal_realm_settings_object(HTML::principal_realm(*module_map_realm)) };
 
         // 14. If loadState is not undefined, then:
         HTML::PerformTheFetchHook perform_fetch;
@@ -505,7 +505,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
             perform_fetch = fetch_context.perform_fetch;
         }
 
-        auto on_single_fetch_complete = HTML::create_on_fetch_script_complete(module_map_realm->heap(), [referrer, module_map_realm, load_state, module_request, payload](JS::GCPtr<HTML::Script> const& module_script) -> void {
+        auto on_single_fetch_complete = HTML::create_on_fetch_script_complete(module_map_realm->heap(), [referrer, module_map_realm, load_state, module_request, payload](GC::Ptr<HTML::Script> const& module_script) -> void {
             auto& realm = *module_map_realm;
             // onSingleFetchComplete given moduleScript is the following algorithm:
             // 1. Let completion be null.
@@ -513,9 +513,9 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
             //       use JS::ThrowCompletionOr here.
 
             auto& vm = realm.vm();
-            JS::GCPtr<JS::Module> module = nullptr;
+            GC::Ptr<JS::Module> module = nullptr;
 
-            auto completion = [&]() -> JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Module>> {
+            auto completion = [&]() -> JS::ThrowCompletionOr<GC::Ref<JS::Module>> {
                 // 2. If moduleScript is null, then set completion to Completion Record { [[Type]]: throw, [[Value]]: a new TypeError, [[Target]]: empty }.
                 if (!module_script) {
                     return JS::throw_completion(JS::TypeError::create(realm, ByteString::formatted("Loading imported module '{}' failed.", module_request.module_specifier)));
@@ -541,7 +541,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
                 // 4. Otherwise, set completion to Completion Record { [[Type]]: normal, [[Value]]: moduleScript's record, [[Target]]: empty }.
                 else {
                     module = static_cast<HTML::JavaScriptModuleScript&>(*module_script).record();
-                    return JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Module>>(*module);
+                    return JS::ThrowCompletionOr<GC::Ref<JS::Module>>(*module);
                 }
             }();
 
@@ -551,7 +551,7 @@ ErrorOr<void> initialize_main_thread_vm(HTML::EventLoop::Type type)
             auto module_execution_context = JS::ExecutionContext::create();
             module_execution_context->realm = realm;
             if (module)
-                module_execution_context->script_or_module = JS::NonnullGCPtr { *module };
+                module_execution_context->script_or_module = GC::Ref { *module };
             vm.push_execution_context(*module_execution_context);
 
             JS::finish_loading_imported_module(referrer, module_request, payload, completion);
@@ -636,12 +636,12 @@ void queue_mutation_observer_microtask(DOM::Document const& document)
     // 3. Queue a microtask to notify mutation observers.
     // NOTE: This uses the implied document concept. In the case of mutation observers, it is always done in a node context, so document should be that node's document.
     // FIXME: Is it safe to pass custom_data through?
-    HTML::queue_a_microtask(&document, JS::create_heap_function(vm.heap(), [&custom_data, &heap = document.heap()]() {
+    HTML::queue_a_microtask(&document, GC::create_function(vm.heap(), [&custom_data, &heap = document.heap()]() {
         // 1. Set the surrounding agent’s mutation observer microtask queued to false.
         custom_data.mutation_observer_microtask_queued = false;
 
         // 2. Let notifySet be a clone of the surrounding agent’s mutation observers.
-        JS::MarkedVector<DOM::MutationObserver*> notify_set(heap);
+        GC::MarkedVector<DOM::MutationObserver*> notify_set(heap);
         for (auto& observer : custom_data.mutation_observers)
             notify_set.append(observer);
 
@@ -714,13 +714,13 @@ NonnullOwnPtr<JS::ExecutionContext> create_a_new_javascript_realm(JS::VM& vm, Fu
     return realm_execution_context;
 }
 
-void WebEngineCustomData::spin_event_loop_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition)
+void WebEngineCustomData::spin_event_loop_until(GC::Root<GC::Function<bool()>> goal_condition)
 {
     Platform::EventLoopPlugin::the().spin_until(move(goal_condition));
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#invoke-custom-element-reactions
-void invoke_custom_element_reactions(Vector<JS::Handle<DOM::Element>>& element_queue)
+void invoke_custom_element_reactions(Vector<GC::Root<DOM::Element>>& element_queue)
 {
     // 1. While queue is not empty:
     while (!element_queue.is_empty()) {
diff --git a/Libraries/LibWeb/Bindings/MainThreadVM.h b/Libraries/LibWeb/Bindings/MainThreadVM.h
index e490bd211cc..97ca4ca133b 100644
--- a/Libraries/LibWeb/Bindings/MainThreadVM.h
+++ b/Libraries/LibWeb/Bindings/MainThreadVM.h
@@ -24,11 +24,11 @@ struct CustomElementReactionsStack {
     // https://html.spec.whatwg.org/multipage/custom-elements.html#element-queue
     // Each item in the stack is an element queue, which is initially empty as well. Each item in an element queue is an element.
     // (The elements are not necessarily custom yet, since this queue is used for upgrades as well.)
-    Vector<Vector<JS::Handle<DOM::Element>>> element_queue_stack;
+    Vector<Vector<GC::Root<DOM::Element>>> element_queue_stack;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#backup-element-queue
     // Each custom element reactions stack has an associated backup element queue, which an initially-empty element queue.
-    Vector<JS::Handle<DOM::Element>> backup_element_queue;
+    Vector<GC::Root<DOM::Element>> backup_element_queue;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#processing-the-backup-element-queue
     // To prevent reentrancy when processing the backup element queue, each custom element reactions stack also has a processing the backup element queue flag, initially unset.
@@ -38,9 +38,9 @@ struct CustomElementReactionsStack {
 struct WebEngineCustomData final : public JS::VM::CustomData {
     virtual ~WebEngineCustomData() override = default;
 
-    virtual void spin_event_loop_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition) override;
+    virtual void spin_event_loop_until(GC::Root<GC::Function<bool()>> goal_condition) override;
 
-    JS::Handle<HTML::EventLoop> event_loop;
+    GC::Root<HTML::EventLoop> event_loop;
 
     // FIXME: These should only be on similar-origin window agents, but we don't currently differentiate agent types.
 
@@ -49,9 +49,9 @@ struct WebEngineCustomData final : public JS::VM::CustomData {
 
     // https://dom.spec.whatwg.org/#mutation-observer-list
     // FIXME: This should be a set.
-    Vector<JS::NonnullGCPtr<DOM::MutationObserver>> mutation_observers;
+    Vector<GC::Ref<DOM::MutationObserver>> mutation_observers;
 
-    JS::Handle<JS::Realm> internal_realm;
+    GC::Root<JS::Realm> internal_realm;
 
     OwnPtr<JS::ExecutionContext> root_execution_context;
 
@@ -61,8 +61,8 @@ struct WebEngineCustomData final : public JS::VM::CustomData {
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#current-element-queue
     // A similar-origin window agent's current element queue is the element queue at the top of its custom element reactions stack.
-    Vector<JS::Handle<DOM::Element>>& current_element_queue() { return custom_element_reactions_stack.element_queue_stack.last(); }
-    Vector<JS::Handle<DOM::Element>> const& current_element_queue() const { return custom_element_reactions_stack.element_queue_stack.last(); }
+    Vector<GC::Root<DOM::Element>>& current_element_queue() { return custom_element_reactions_stack.element_queue_stack.last(); }
+    Vector<GC::Root<DOM::Element>> const& current_element_queue() const { return custom_element_reactions_stack.element_queue_stack.last(); }
 };
 
 struct WebEngineCustomJobCallbackData final : public JS::JobCallback::CustomData {
@@ -74,7 +74,7 @@ struct WebEngineCustomJobCallbackData final : public JS::JobCallback::CustomData
 
     virtual ~WebEngineCustomJobCallbackData() override = default;
 
-    JS::NonnullGCPtr<JS::Realm> incumbent_realm;
+    GC::Ref<JS::Realm> incumbent_realm;
     OwnPtr<JS::ExecutionContext> active_script_context;
 };
 
@@ -85,6 +85,6 @@ JS::VM& main_thread_vm();
 
 void queue_mutation_observer_microtask(DOM::Document const&);
 NonnullOwnPtr<JS::ExecutionContext> create_a_new_javascript_realm(JS::VM&, Function<JS::Object*(JS::Realm&)> create_global_object, Function<JS::Object*(JS::Realm&)> create_global_this_value);
-void invoke_custom_element_reactions(Vector<JS::Handle<DOM::Element>>& element_queue);
+void invoke_custom_element_reactions(Vector<GC::Root<DOM::Element>>& element_queue);
 
 }
diff --git a/Libraries/LibWeb/Bindings/OptionConstructor.cpp b/Libraries/LibWeb/Bindings/OptionConstructor.cpp
index ecf1de0710d..fc6ae0ed46c 100644
--- a/Libraries/LibWeb/Bindings/OptionConstructor.cpp
+++ b/Libraries/LibWeb/Bindings/OptionConstructor.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(OptionConstructor);
+GC_DEFINE_ALLOCATOR(OptionConstructor);
 
 OptionConstructor::OptionConstructor(JS::Realm& realm)
     : NativeFunction(realm.intrinsics().function_prototype())
@@ -40,7 +40,7 @@ JS::ThrowCompletionOr<JS::Value> OptionConstructor::call()
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-option
 // https://whatpr.org/html/9893/form-elements.html#dom-option
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> OptionConstructor::construct(FunctionObject&)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> OptionConstructor::construct(FunctionObject&)
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
@@ -56,7 +56,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> OptionConstructor::construct
 
     // 2. Let option be the result of creating an element given document, option, and the HTML namespace.
     auto element = TRY(Bindings::throw_dom_exception_if_needed(vm, [&]() { return DOM::create_element(document, HTML::TagNames::option, Namespace::HTML); }));
-    JS::NonnullGCPtr<HTML::HTMLOptionElement> option_element = verify_cast<HTML::HTMLOptionElement>(*element);
+    GC::Ref<HTML::HTMLOptionElement> option_element = verify_cast<HTML::HTMLOptionElement>(*element);
 
     // 3. If text is not the empty string, then append to option a new Text node whose data is text.
     auto text = TRY(text_value.to_string(vm));
diff --git a/Libraries/LibWeb/Bindings/OptionConstructor.h b/Libraries/LibWeb/Bindings/OptionConstructor.h
index c9471e828eb..e37de160efb 100644
--- a/Libraries/LibWeb/Bindings/OptionConstructor.h
+++ b/Libraries/LibWeb/Bindings/OptionConstructor.h
@@ -13,7 +13,7 @@ namespace Web::Bindings {
 
 class OptionConstructor final : public JS::NativeFunction {
     JS_OBJECT(OptionConstructor, JS::NativeFunction);
-    JS_DECLARE_ALLOCATOR(OptionConstructor);
+    GC_DECLARE_ALLOCATOR(OptionConstructor);
 
 public:
     explicit OptionConstructor(JS::Realm&);
@@ -21,7 +21,7 @@ public:
     virtual ~OptionConstructor() override = default;
 
     virtual JS::ThrowCompletionOr<JS::Value> call() override;
-    virtual JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> construct(JS::FunctionObject& new_target) override;
+    virtual JS::ThrowCompletionOr<GC::Ref<JS::Object>> construct(JS::FunctionObject& new_target) override;
 
 private:
     virtual bool has_constructor() const override { return true; }
diff --git a/Libraries/LibWeb/Bindings/PlatformObject.cpp b/Libraries/LibWeb/Bindings/PlatformObject.cpp
index dd985621841..a014d4d237a 100644
--- a/Libraries/LibWeb/Bindings/PlatformObject.cpp
+++ b/Libraries/LibWeb/Bindings/PlatformObject.cpp
@@ -400,7 +400,7 @@ JS::ThrowCompletionOr<bool> PlatformObject::internal_prevent_extensions()
 }
 
 // https://webidl.spec.whatwg.org/#legacy-platform-object-ownpropertykeys
-JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> PlatformObject::internal_own_property_keys() const
+JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> PlatformObject::internal_own_property_keys() const
 {
     if (!m_legacy_platform_object_flags.has_value() || m_legacy_platform_object_flags->has_global_interface_extended_attribute)
         return Base::internal_own_property_keys();
@@ -408,7 +408,7 @@ JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> PlatformObject::internal_own_
     auto& vm = this->vm();
 
     // 1. Let keys be a new empty list of ECMAScript String and Symbol values.
-    JS::MarkedVector<JS::Value> keys { heap() };
+    GC::MarkedVector<JS::Value> keys { heap() };
 
     // 2. If O supports indexed properties, then for each index of O’s supported property indices, in ascending numerical order, append ! ToString(index) to keys.
     if (m_legacy_platform_object_flags->supports_indexed_properties) {
diff --git a/Libraries/LibWeb/Bindings/PlatformObject.h b/Libraries/LibWeb/Bindings/PlatformObject.h
index a4162360710..16089d87d46 100644
--- a/Libraries/LibWeb/Bindings/PlatformObject.h
+++ b/Libraries/LibWeb/Bindings/PlatformObject.h
@@ -40,7 +40,7 @@ public:
     virtual JS::ThrowCompletionOr<bool> internal_define_own_property(JS::PropertyKey const&, JS::PropertyDescriptor const&, Optional<JS::PropertyDescriptor>* precomputed_get_own_property = nullptr) override;
     virtual JS::ThrowCompletionOr<bool> internal_delete(JS::PropertyKey const&) override;
     virtual JS::ThrowCompletionOr<bool> internal_prevent_extensions() override;
-    virtual JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> internal_own_property_keys() const override;
+    virtual JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> internal_own_property_keys() const override;
 
     JS::ThrowCompletionOr<bool> is_named_property_exposed_on_object(JS::PropertyKey const&) const;
 
diff --git a/Libraries/LibWeb/Bindings/PrincipalHostDefined.h b/Libraries/LibWeb/Bindings/PrincipalHostDefined.h
index c1f9df16564..140478309de 100644
--- a/Libraries/LibWeb/Bindings/PrincipalHostDefined.h
+++ b/Libraries/LibWeb/Bindings/PrincipalHostDefined.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/HostDefined.h>
 #include <LibWeb/Forward.h>
@@ -15,7 +15,7 @@
 namespace Web::Bindings {
 
 struct PrincipalHostDefined : public HostDefined {
-    PrincipalHostDefined(JS::NonnullGCPtr<HTML::EnvironmentSettingsObject> eso, JS::NonnullGCPtr<Intrinsics> intrinsics, JS::NonnullGCPtr<Page> page)
+    PrincipalHostDefined(GC::Ref<HTML::EnvironmentSettingsObject> eso, GC::Ref<Intrinsics> intrinsics, GC::Ref<Page> page)
         : HostDefined(intrinsics)
         , environment_settings_object(eso)
         , page(page)
@@ -24,8 +24,8 @@ struct PrincipalHostDefined : public HostDefined {
     virtual ~PrincipalHostDefined() override = default;
     virtual void visit_edges(JS::Cell::Visitor& visitor) override;
 
-    JS::NonnullGCPtr<HTML::EnvironmentSettingsObject> environment_settings_object;
-    JS::NonnullGCPtr<Page> page;
+    GC::Ref<HTML::EnvironmentSettingsObject> environment_settings_object;
+    GC::Ref<Page> page;
 };
 
 [[nodiscard]] inline HTML::EnvironmentSettingsObject& principal_host_defined_environment_settings_object(JS::Realm& realm)
diff --git a/Libraries/LibWeb/Bindings/SyntheticHostDefined.h b/Libraries/LibWeb/Bindings/SyntheticHostDefined.h
index 157298801c1..ba2efb074ee 100644
--- a/Libraries/LibWeb/Bindings/SyntheticHostDefined.h
+++ b/Libraries/LibWeb/Bindings/SyntheticHostDefined.h
@@ -14,7 +14,7 @@
 namespace Web::Bindings {
 
 struct SyntheticHostDefined : public HostDefined {
-    SyntheticHostDefined(HTML::SyntheticRealmSettings synthetic_realm_settings, JS::NonnullGCPtr<Intrinsics> intrinsics)
+    SyntheticHostDefined(HTML::SyntheticRealmSettings synthetic_realm_settings, GC::Ref<Intrinsics> intrinsics)
         : HostDefined(intrinsics)
         , synthetic_realm_settings(move(synthetic_realm_settings))
     {
diff --git a/Libraries/LibWeb/CMakeLists.txt b/Libraries/LibWeb/CMakeLists.txt
index 5afa23adf24..d86e9ab8714 100644
--- a/Libraries/LibWeb/CMakeLists.txt
+++ b/Libraries/LibWeb/CMakeLists.txt
@@ -848,7 +848,7 @@ set(GENERATED_SOURCES
 
 serenity_lib(LibWeb web)
 
-target_link_libraries(LibWeb PRIVATE LibCore LibCrypto LibJS LibHTTP LibGfx LibIPC LibRegex LibSyntax LibTextCodec LibUnicode LibMedia LibWasm LibXML LibIDL LibURL LibTLS LibRequests skia)
+target_link_libraries(LibWeb PRIVATE LibCore LibCrypto LibJS LibHTTP LibGfx LibIPC LibRegex LibSyntax LibTextCodec LibUnicode LibMedia LibWasm LibXML LibIDL LibURL LibTLS LibRequests LibGC skia)
 
 generate_js_bindings(LibWeb)
 
diff --git a/Libraries/LibWeb/CSS/AnimationEvent.cpp b/Libraries/LibWeb/CSS/AnimationEvent.cpp
index 4cb8edd1a84..b5afefb4e84 100644
--- a/Libraries/LibWeb/CSS/AnimationEvent.cpp
+++ b/Libraries/LibWeb/CSS/AnimationEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(AnimationEvent);
+GC_DEFINE_ALLOCATOR(AnimationEvent);
 
-JS::NonnullGCPtr<AnimationEvent> AnimationEvent::create(JS::Realm& realm, FlyString const& type, AnimationEventInit const& event_init)
+GC::Ref<AnimationEvent> AnimationEvent::create(JS::Realm& realm, FlyString const& type, AnimationEventInit const& event_init)
 {
     return realm.create<AnimationEvent>(realm, type, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AnimationEvent>> AnimationEvent::construct_impl(JS::Realm& realm, FlyString const& type, AnimationEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<AnimationEvent>> AnimationEvent::construct_impl(JS::Realm& realm, FlyString const& type, AnimationEventInit const& event_init)
 {
     return create(realm, type, event_init);
 }
diff --git a/Libraries/LibWeb/CSS/AnimationEvent.h b/Libraries/LibWeb/CSS/AnimationEvent.h
index e93d4113253..0dfea036623 100644
--- a/Libraries/LibWeb/CSS/AnimationEvent.h
+++ b/Libraries/LibWeb/CSS/AnimationEvent.h
@@ -21,11 +21,11 @@ struct AnimationEventInit : public DOM::EventInit {
 // https://www.w3.org/TR/css-animations-1/#animationevent
 class AnimationEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(AnimationEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(AnimationEvent);
+    GC_DECLARE_ALLOCATOR(AnimationEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<AnimationEvent> create(JS::Realm&, FlyString const& type, AnimationEventInit const& event_init = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AnimationEvent>> construct_impl(JS::Realm&, FlyString const& type, AnimationEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<AnimationEvent> create(JS::Realm&, FlyString const& type, AnimationEventInit const& event_init = {});
+    static WebIDL::ExceptionOr<GC::Ref<AnimationEvent>> construct_impl(JS::Realm&, FlyString const& type, AnimationEventInit const& event_init);
 
     virtual ~AnimationEvent() override = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSAnimation.cpp b/Libraries/LibWeb/CSS/CSSAnimation.cpp
index c9f911f8e15..6e300610d7a 100644
--- a/Libraries/LibWeb/CSS/CSSAnimation.cpp
+++ b/Libraries/LibWeb/CSS/CSSAnimation.cpp
@@ -12,17 +12,17 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSAnimation);
+GC_DEFINE_ALLOCATOR(CSSAnimation);
 
-JS::NonnullGCPtr<CSSAnimation> CSSAnimation::create(JS::Realm& realm)
+GC::Ref<CSSAnimation> CSSAnimation::create(JS::Realm& realm)
 {
     return realm.create<CSSAnimation>(realm);
 }
 
 // https://www.w3.org/TR/css-animations-2/#animation-composite-order
-Optional<int> CSSAnimation::class_specific_composite_order(JS::NonnullGCPtr<Animations::Animation> other_animation) const
+Optional<int> CSSAnimation::class_specific_composite_order(GC::Ref<Animations::Animation> other_animation) const
 {
-    auto other = JS::NonnullGCPtr { verify_cast<CSSAnimation>(*other_animation) };
+    auto other = GC::Ref { verify_cast<CSSAnimation>(*other_animation) };
 
     // The existance of an owning element determines the animation class, so both animations should have their owning
     // element in the same state
diff --git a/Libraries/LibWeb/CSS/CSSAnimation.h b/Libraries/LibWeb/CSS/CSSAnimation.h
index a150bf4ad0b..a4fc1c5311f 100644
--- a/Libraries/LibWeb/CSS/CSSAnimation.h
+++ b/Libraries/LibWeb/CSS/CSSAnimation.h
@@ -15,15 +15,15 @@ namespace Web::CSS {
 // https://www.w3.org/TR/css-animations-2/#cssanimation
 class CSSAnimation : public Animations::Animation {
     WEB_PLATFORM_OBJECT(CSSAnimation, Animations::Animation);
-    JS_DECLARE_ALLOCATOR(CSSAnimation);
+    GC_DECLARE_ALLOCATOR(CSSAnimation);
 
 public:
-    static JS::NonnullGCPtr<CSSAnimation> create(JS::Realm&);
+    static GC::Ref<CSSAnimation> create(JS::Realm&);
 
     FlyString const& animation_name() const { return id(); }
 
     virtual Animations::AnimationClass animation_class() const override;
-    virtual Optional<int> class_specific_composite_order(JS::NonnullGCPtr<Animations::Animation> other) const override;
+    virtual Optional<int> class_specific_composite_order(GC::Ref<Animations::Animation> other) const override;
 
 private:
     explicit CSSAnimation(JS::Realm&);
diff --git a/Libraries/LibWeb/CSS/CSSFontFaceRule.cpp b/Libraries/LibWeb/CSS/CSSFontFaceRule.cpp
index 7eea18b7226..26e20cfa52b 100644
--- a/Libraries/LibWeb/CSS/CSSFontFaceRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSFontFaceRule.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSFontFaceRule);
+GC_DEFINE_ALLOCATOR(CSSFontFaceRule);
 
-JS::NonnullGCPtr<CSSFontFaceRule> CSSFontFaceRule::create(JS::Realm& realm, ParsedFontFace&& font_face)
+GC::Ref<CSSFontFaceRule> CSSFontFaceRule::create(JS::Realm& realm, ParsedFontFace&& font_face)
 {
     return realm.create<CSSFontFaceRule>(realm, move(font_face));
 }
diff --git a/Libraries/LibWeb/CSS/CSSFontFaceRule.h b/Libraries/LibWeb/CSS/CSSFontFaceRule.h
index 69657f73c4d..89cdc2cf7be 100644
--- a/Libraries/LibWeb/CSS/CSSFontFaceRule.h
+++ b/Libraries/LibWeb/CSS/CSSFontFaceRule.h
@@ -14,10 +14,10 @@ namespace Web::CSS {
 
 class CSSFontFaceRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSFontFaceRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSFontFaceRule);
+    GC_DECLARE_ALLOCATOR(CSSFontFaceRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSFontFaceRule> create(JS::Realm&, ParsedFontFace&&);
+    [[nodiscard]] static GC::Ref<CSSFontFaceRule> create(JS::Realm&, ParsedFontFace&&);
 
     virtual ~CSSFontFaceRule() override = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSGroupingRule.h b/Libraries/LibWeb/CSS/CSSGroupingRule.h
index 20dcc9987ba..eff8541dd36 100644
--- a/Libraries/LibWeb/CSS/CSSGroupingRule.h
+++ b/Libraries/LibWeb/CSS/CSSGroupingRule.h
@@ -38,7 +38,7 @@ protected:
     virtual void clear_caches() override;
 
 private:
-    JS::NonnullGCPtr<CSSRuleList> m_rules;
+    GC::Ref<CSSRuleList> m_rules;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/CSSImportRule.cpp b/Libraries/LibWeb/CSS/CSSImportRule.cpp
index ca251187223..23fbac26a4a 100644
--- a/Libraries/LibWeb/CSS/CSSImportRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSImportRule.cpp
@@ -20,9 +20,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSImportRule);
+GC_DEFINE_ALLOCATOR(CSSImportRule);
 
-JS::NonnullGCPtr<CSSImportRule> CSSImportRule::create(URL::URL url, DOM::Document& document)
+GC::Ref<CSSImportRule> CSSImportRule::create(URL::URL url, DOM::Document& document)
 {
     auto& realm = document.realm();
     return realm.create<CSSImportRule>(move(url), document);
diff --git a/Libraries/LibWeb/CSS/CSSImportRule.h b/Libraries/LibWeb/CSS/CSSImportRule.h
index 0f9680f3bdb..cf9910581ff 100644
--- a/Libraries/LibWeb/CSS/CSSImportRule.h
+++ b/Libraries/LibWeb/CSS/CSSImportRule.h
@@ -20,10 +20,10 @@ class CSSImportRule final
     : public CSSRule
     , public ResourceClient {
     WEB_PLATFORM_OBJECT(CSSImportRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSImportRule);
+    GC_DECLARE_ALLOCATOR(CSSImportRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSImportRule> create(URL::URL, DOM::Document&);
+    [[nodiscard]] static GC::Ref<CSSImportRule> create(URL::URL, DOM::Document&);
 
     virtual ~CSSImportRule() = default;
 
@@ -49,8 +49,8 @@ private:
     virtual void resource_did_load() override;
 
     URL::URL m_url;
-    JS::GCPtr<DOM::Document> m_document;
-    JS::GCPtr<CSSStyleSheet> m_style_sheet;
+    GC::Ptr<DOM::Document> m_document;
+    GC::Ptr<CSSStyleSheet> m_style_sheet;
     Optional<DOM::DocumentLoadEventDelayer> m_document_load_event_delayer;
 };
 
diff --git a/Libraries/LibWeb/CSS/CSSKeyframeRule.cpp b/Libraries/LibWeb/CSS/CSSKeyframeRule.cpp
index 11f44c4d9e1..ede8de3ce00 100644
--- a/Libraries/LibWeb/CSS/CSSKeyframeRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSKeyframeRule.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSKeyframeRule);
+GC_DEFINE_ALLOCATOR(CSSKeyframeRule);
 
-JS::NonnullGCPtr<CSSKeyframeRule> CSSKeyframeRule::create(JS::Realm& realm, CSS::Percentage key, Web::CSS::PropertyOwningCSSStyleDeclaration& declarations)
+GC::Ref<CSSKeyframeRule> CSSKeyframeRule::create(JS::Realm& realm, CSS::Percentage key, Web::CSS::PropertyOwningCSSStyleDeclaration& declarations)
 {
     return realm.create<CSSKeyframeRule>(realm, key, declarations);
 }
diff --git a/Libraries/LibWeb/CSS/CSSKeyframeRule.h b/Libraries/LibWeb/CSS/CSSKeyframeRule.h
index d6acc9fe4e5..343066bda35 100644
--- a/Libraries/LibWeb/CSS/CSSKeyframeRule.h
+++ b/Libraries/LibWeb/CSS/CSSKeyframeRule.h
@@ -18,16 +18,16 @@ namespace Web::CSS {
 // https://drafts.csswg.org/css-animations/#interface-csskeyframerule
 class CSSKeyframeRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSKeyframeRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSKeyframeRule);
+    GC_DECLARE_ALLOCATOR(CSSKeyframeRule);
 
 public:
-    static JS::NonnullGCPtr<CSSKeyframeRule> create(JS::Realm&, CSS::Percentage key, PropertyOwningCSSStyleDeclaration&);
+    static GC::Ref<CSSKeyframeRule> create(JS::Realm&, CSS::Percentage key, PropertyOwningCSSStyleDeclaration&);
 
     virtual ~CSSKeyframeRule() = default;
 
     CSS::Percentage key() const { return m_key; }
-    JS::NonnullGCPtr<CSSStyleDeclaration> style() const { return m_declarations; }
-    JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration> style_as_property_owning_style_declaration() const { return m_declarations; }
+    GC::Ref<CSSStyleDeclaration> style() const { return m_declarations; }
+    GC::Ref<PropertyOwningCSSStyleDeclaration> style_as_property_owning_style_declaration() const { return m_declarations; }
 
     String key_text() const
     {
@@ -47,7 +47,7 @@ private:
     virtual String serialized() const override;
 
     CSS::Percentage m_key;
-    JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration> m_declarations;
+    GC::Ref<PropertyOwningCSSStyleDeclaration> m_declarations;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSKeyframesRule.cpp b/Libraries/LibWeb/CSS/CSSKeyframesRule.cpp
index 85e92a9d3fb..06a2c9c6e4f 100644
--- a/Libraries/LibWeb/CSS/CSSKeyframesRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSKeyframesRule.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSKeyframesRule);
+GC_DEFINE_ALLOCATOR(CSSKeyframesRule);
 
-JS::NonnullGCPtr<CSSKeyframesRule> CSSKeyframesRule::create(JS::Realm& realm, FlyString name, JS::NonnullGCPtr<CSSRuleList> css_rules)
+GC::Ref<CSSKeyframesRule> CSSKeyframesRule::create(JS::Realm& realm, FlyString name, GC::Ref<CSSRuleList> css_rules)
 {
     return realm.create<CSSKeyframesRule>(realm, move(name), move(css_rules));
 }
 
-CSSKeyframesRule::CSSKeyframesRule(JS::Realm& realm, FlyString name, JS::NonnullGCPtr<CSSRuleList> keyframes)
+CSSKeyframesRule::CSSKeyframesRule(JS::Realm& realm, FlyString name, GC::Ref<CSSRuleList> keyframes)
     : CSSRule(realm, Type::Keyframes)
     , m_name(move(name))
     , m_rules(move(keyframes))
diff --git a/Libraries/LibWeb/CSS/CSSKeyframesRule.h b/Libraries/LibWeb/CSS/CSSKeyframesRule.h
index 4d6a8e9f899..d93cadfd6d8 100644
--- a/Libraries/LibWeb/CSS/CSSKeyframesRule.h
+++ b/Libraries/LibWeb/CSS/CSSKeyframesRule.h
@@ -9,7 +9,7 @@
 
 #include <AK/FlyString.h>
 #include <AK/NonnullRefPtr.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/CSS/CSSKeyframeRule.h>
 #include <LibWeb/CSS/CSSRule.h>
 #include <LibWeb/Forward.h>
@@ -21,10 +21,10 @@ namespace Web::CSS {
 // https://drafts.csswg.org/css-animations/#interface-csskeyframesrule
 class CSSKeyframesRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSKeyframesRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSKeyframesRule);
+    GC_DECLARE_ALLOCATOR(CSSKeyframesRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSKeyframesRule> create(JS::Realm&, FlyString name, JS::NonnullGCPtr<CSSRuleList>);
+    [[nodiscard]] static GC::Ref<CSSKeyframesRule> create(JS::Realm&, FlyString name, GC::Ref<CSSRuleList>);
 
     virtual ~CSSKeyframesRule() = default;
 
@@ -35,14 +35,14 @@ public:
     void set_name(String const& name) { m_name = name; }
 
 private:
-    CSSKeyframesRule(JS::Realm&, FlyString name, JS::NonnullGCPtr<CSSRuleList> keyframes);
+    CSSKeyframesRule(JS::Realm&, FlyString name, GC::Ref<CSSRuleList> keyframes);
     virtual void visit_edges(Visitor&) override;
 
     virtual void initialize(JS::Realm&) override;
     virtual String serialized() const override;
 
     FlyString m_name;
-    JS::NonnullGCPtr<CSSRuleList> m_rules;
+    GC::Ref<CSSRuleList> m_rules;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSLayerBlockRule.cpp b/Libraries/LibWeb/CSS/CSSLayerBlockRule.cpp
index 5296b0f5331..cb7b750a8a8 100644
--- a/Libraries/LibWeb/CSS/CSSLayerBlockRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSLayerBlockRule.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSLayerBlockRule);
+GC_DEFINE_ALLOCATOR(CSSLayerBlockRule);
 
-JS::NonnullGCPtr<CSSLayerBlockRule> CSSLayerBlockRule::create(JS::Realm& realm, FlyString name, CSSRuleList& rules)
+GC::Ref<CSSLayerBlockRule> CSSLayerBlockRule::create(JS::Realm& realm, FlyString name, CSSRuleList& rules)
 {
     return realm.create<CSSLayerBlockRule>(realm, move(name), rules);
 }
diff --git a/Libraries/LibWeb/CSS/CSSLayerBlockRule.h b/Libraries/LibWeb/CSS/CSSLayerBlockRule.h
index 1be089a70ce..afdf3fc2277 100644
--- a/Libraries/LibWeb/CSS/CSSLayerBlockRule.h
+++ b/Libraries/LibWeb/CSS/CSSLayerBlockRule.h
@@ -13,10 +13,10 @@ namespace Web::CSS {
 // https://drafts.csswg.org/css-cascade-5/#the-csslayerblockrule-interface
 class CSSLayerBlockRule final : public CSSGroupingRule {
     WEB_PLATFORM_OBJECT(CSSLayerBlockRule, CSSGroupingRule);
-    JS_DECLARE_ALLOCATOR(CSSLayerBlockRule);
+    GC_DECLARE_ALLOCATOR(CSSLayerBlockRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSLayerBlockRule> create(JS::Realm&, FlyString name, CSSRuleList&);
+    [[nodiscard]] static GC::Ref<CSSLayerBlockRule> create(JS::Realm&, FlyString name, CSSRuleList&);
 
     static FlyString next_unique_anonymous_layer_name();
 
diff --git a/Libraries/LibWeb/CSS/CSSLayerStatementRule.cpp b/Libraries/LibWeb/CSS/CSSLayerStatementRule.cpp
index f20d1aacce1..76a1a146c15 100644
--- a/Libraries/LibWeb/CSS/CSSLayerStatementRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSLayerStatementRule.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSLayerStatementRule);
+GC_DEFINE_ALLOCATOR(CSSLayerStatementRule);
 
-JS::NonnullGCPtr<CSSLayerStatementRule> CSSLayerStatementRule::create(JS::Realm& realm, Vector<FlyString> name_list)
+GC::Ref<CSSLayerStatementRule> CSSLayerStatementRule::create(JS::Realm& realm, Vector<FlyString> name_list)
 {
     return realm.create<CSSLayerStatementRule>(realm, move(name_list));
 }
diff --git a/Libraries/LibWeb/CSS/CSSLayerStatementRule.h b/Libraries/LibWeb/CSS/CSSLayerStatementRule.h
index aca2f9b1df6..7cd42c929f7 100644
--- a/Libraries/LibWeb/CSS/CSSLayerStatementRule.h
+++ b/Libraries/LibWeb/CSS/CSSLayerStatementRule.h
@@ -13,10 +13,10 @@ namespace Web::CSS {
 // https://drafts.csswg.org/css-cascade-5/#the-csslayerstatementrule-interface
 class CSSLayerStatementRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSLayerStatementRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSLayerStatementRule);
+    GC_DECLARE_ALLOCATOR(CSSLayerStatementRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSLayerStatementRule> create(JS::Realm&, Vector<FlyString> name_list);
+    [[nodiscard]] static GC::Ref<CSSLayerStatementRule> create(JS::Realm&, Vector<FlyString> name_list);
 
     virtual ~CSSLayerStatementRule() = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSMediaRule.cpp b/Libraries/LibWeb/CSS/CSSMediaRule.cpp
index 5bf33243770..3458cde09ea 100644
--- a/Libraries/LibWeb/CSS/CSSMediaRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSMediaRule.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSMediaRule);
+GC_DEFINE_ALLOCATOR(CSSMediaRule);
 
-JS::NonnullGCPtr<CSSMediaRule> CSSMediaRule::create(JS::Realm& realm, MediaList& media_queries, CSSRuleList& rules)
+GC::Ref<CSSMediaRule> CSSMediaRule::create(JS::Realm& realm, MediaList& media_queries, CSSRuleList& rules)
 {
     return realm.create<CSSMediaRule>(realm, media_queries, rules);
 }
diff --git a/Libraries/LibWeb/CSS/CSSMediaRule.h b/Libraries/LibWeb/CSS/CSSMediaRule.h
index 7470d5a160a..b64a2fc9b9a 100644
--- a/Libraries/LibWeb/CSS/CSSMediaRule.h
+++ b/Libraries/LibWeb/CSS/CSSMediaRule.h
@@ -16,10 +16,10 @@ namespace Web::CSS {
 // https://www.w3.org/TR/css-conditional-3/#the-cssmediarule-interface
 class CSSMediaRule final : public CSSConditionRule {
     WEB_PLATFORM_OBJECT(CSSMediaRule, CSSConditionRule);
-    JS_DECLARE_ALLOCATOR(CSSMediaRule);
+    GC_DECLARE_ALLOCATOR(CSSMediaRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSMediaRule> create(JS::Realm&, MediaList& media_queries, CSSRuleList&);
+    [[nodiscard]] static GC::Ref<CSSMediaRule> create(JS::Realm&, MediaList& media_queries, CSSRuleList&);
 
     virtual ~CSSMediaRule() = default;
 
@@ -37,7 +37,7 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
     virtual String serialized() const override;
 
-    JS::NonnullGCPtr<MediaList> m_media;
+    GC::Ref<MediaList> m_media;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSNamespaceRule.cpp b/Libraries/LibWeb/CSS/CSSNamespaceRule.cpp
index 0d7228432cf..684d6421086 100644
--- a/Libraries/LibWeb/CSS/CSSNamespaceRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSNamespaceRule.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/CSSNamespaceRulePrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
@@ -14,7 +14,7 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSNamespaceRule);
+GC_DEFINE_ALLOCATOR(CSSNamespaceRule);
 
 CSSNamespaceRule::CSSNamespaceRule(JS::Realm& realm, Optional<FlyString> prefix, FlyString namespace_uri)
     : CSSRule(realm, Type::Namespace)
@@ -23,7 +23,7 @@ CSSNamespaceRule::CSSNamespaceRule(JS::Realm& realm, Optional<FlyString> prefix,
 {
 }
 
-JS::NonnullGCPtr<CSSNamespaceRule> CSSNamespaceRule::create(JS::Realm& realm, Optional<FlyString> prefix, FlyString namespace_uri)
+GC::Ref<CSSNamespaceRule> CSSNamespaceRule::create(JS::Realm& realm, Optional<FlyString> prefix, FlyString namespace_uri)
 {
     return realm.create<CSSNamespaceRule>(realm, move(prefix), move(namespace_uri));
 }
diff --git a/Libraries/LibWeb/CSS/CSSNamespaceRule.h b/Libraries/LibWeb/CSS/CSSNamespaceRule.h
index bf9304a5742..bda09ff4d04 100644
--- a/Libraries/LibWeb/CSS/CSSNamespaceRule.h
+++ b/Libraries/LibWeb/CSS/CSSNamespaceRule.h
@@ -12,10 +12,10 @@ namespace Web::CSS {
 
 class CSSNamespaceRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSNamespaceRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSNamespaceRule);
+    GC_DECLARE_ALLOCATOR(CSSNamespaceRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSNamespaceRule> create(JS::Realm&, Optional<FlyString> prefix, FlyString namespace_uri);
+    [[nodiscard]] static GC::Ref<CSSNamespaceRule> create(JS::Realm&, Optional<FlyString> prefix, FlyString namespace_uri);
 
     virtual ~CSSNamespaceRule() = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSNestedDeclarations.cpp b/Libraries/LibWeb/CSS/CSSNestedDeclarations.cpp
index f566495e76e..0463f865422 100644
--- a/Libraries/LibWeb/CSS/CSSNestedDeclarations.cpp
+++ b/Libraries/LibWeb/CSS/CSSNestedDeclarations.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSNestedDeclarations);
+GC_DEFINE_ALLOCATOR(CSSNestedDeclarations);
 
-JS::NonnullGCPtr<CSSNestedDeclarations> CSSNestedDeclarations::create(JS::Realm& realm, PropertyOwningCSSStyleDeclaration& declaration)
+GC::Ref<CSSNestedDeclarations> CSSNestedDeclarations::create(JS::Realm& realm, PropertyOwningCSSStyleDeclaration& declaration)
 {
     return realm.create<CSSNestedDeclarations>(realm, declaration);
 }
diff --git a/Libraries/LibWeb/CSS/CSSNestedDeclarations.h b/Libraries/LibWeb/CSS/CSSNestedDeclarations.h
index 581cde36c9d..18206b52664 100644
--- a/Libraries/LibWeb/CSS/CSSNestedDeclarations.h
+++ b/Libraries/LibWeb/CSS/CSSNestedDeclarations.h
@@ -12,10 +12,10 @@ namespace Web::CSS {
 
 class CSSNestedDeclarations final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSNestedDeclarations, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSNestedDeclarations);
+    GC_DECLARE_ALLOCATOR(CSSNestedDeclarations);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSNestedDeclarations> create(JS::Realm&, PropertyOwningCSSStyleDeclaration&);
+    [[nodiscard]] static GC::Ref<CSSNestedDeclarations> create(JS::Realm&, PropertyOwningCSSStyleDeclaration&);
 
     virtual ~CSSNestedDeclarations() override = default;
 
@@ -33,8 +33,8 @@ private:
     virtual String serialized() const override;
     virtual void clear_caches() override;
 
-    JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration> m_declaration;
-    JS::GCPtr<CSSStyleRule const> mutable m_parent_style_rule;
+    GC::Ref<PropertyOwningCSSStyleDeclaration> m_declaration;
+    GC::Ptr<CSSStyleRule const> mutable m_parent_style_rule;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSPropertyRule.cpp b/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
index 5c57fcc2837..ab9c7fd4580 100644
--- a/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSPropertyRule.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSPropertyRule);
+GC_DEFINE_ALLOCATOR(CSSPropertyRule);
 
-JS::NonnullGCPtr<CSSPropertyRule> CSSPropertyRule::create(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, Optional<String> initial_value)
+GC::Ref<CSSPropertyRule> CSSPropertyRule::create(JS::Realm& realm, FlyString name, FlyString syntax, bool inherits, Optional<String> initial_value)
 {
     return realm.create<CSSPropertyRule>(realm, move(name), move(syntax), inherits, move(initial_value));
 }
diff --git a/Libraries/LibWeb/CSS/CSSPropertyRule.h b/Libraries/LibWeb/CSS/CSSPropertyRule.h
index d37c86d0efd..58802c020a8 100644
--- a/Libraries/LibWeb/CSS/CSSPropertyRule.h
+++ b/Libraries/LibWeb/CSS/CSSPropertyRule.h
@@ -18,10 +18,10 @@ namespace Web::CSS {
 // https://drafts.css-houdini.org/css-properties-values-api/#the-css-property-rule-interface
 class CSSPropertyRule final : public CSSRule {
     WEB_PLATFORM_OBJECT(CSSPropertyRule, CSSRule);
-    JS_DECLARE_ALLOCATOR(CSSPropertyRule);
+    GC_DECLARE_ALLOCATOR(CSSPropertyRule);
 
 public:
-    static JS::NonnullGCPtr<CSSPropertyRule> create(JS::Realm&, FlyString name, FlyString syntax, bool inherits, Optional<String> initial_value);
+    static GC::Ref<CSSPropertyRule> create(JS::Realm&, FlyString name, FlyString syntax, bool inherits, Optional<String> initial_value);
 
     virtual ~CSSPropertyRule() = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSRule.h b/Libraries/LibWeb/CSS/CSSRule.h
index caded862ba9..ab0dda8d390 100644
--- a/Libraries/LibWeb/CSS/CSSRule.h
+++ b/Libraries/LibWeb/CSS/CSSRule.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/String.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/CSS/CSSStyleDeclaration.h>
 #include <LibWeb/CSS/Selector.h>
@@ -75,8 +75,8 @@ protected:
     [[nodiscard]] FlyString const& parent_layer_internal_qualified_name_slow_case() const;
 
     Type m_type;
-    JS::GCPtr<CSSRule> m_parent_rule;
-    JS::GCPtr<CSSStyleSheet> m_parent_style_sheet;
+    GC::Ptr<CSSRule> m_parent_rule;
+    GC::Ptr<CSSStyleSheet> m_parent_style_sheet;
 
     mutable Optional<FlyString> m_cached_layer_name;
 };
diff --git a/Libraries/LibWeb/CSS/CSSRuleList.cpp b/Libraries/LibWeb/CSS/CSSRuleList.cpp
index a3173a9bf17..c688cf45b74 100644
--- a/Libraries/LibWeb/CSS/CSSRuleList.cpp
+++ b/Libraries/LibWeb/CSS/CSSRuleList.cpp
@@ -19,9 +19,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSRuleList);
+GC_DEFINE_ALLOCATOR(CSSRuleList);
 
-JS::NonnullGCPtr<CSSRuleList> CSSRuleList::create(JS::Realm& realm, JS::MarkedVector<CSSRule*> const& rules)
+GC::Ref<CSSRuleList> CSSRuleList::create(JS::Realm& realm, GC::MarkedVector<CSSRule*> const& rules)
 {
     auto rule_list = realm.create<CSSRuleList>(realm);
     for (auto* rule : rules)
@@ -35,7 +35,7 @@ CSSRuleList::CSSRuleList(JS::Realm& realm)
     m_legacy_platform_object_flags = LegacyPlatformObjectFlags { .supports_indexed_properties = 1 };
 }
 
-JS::NonnullGCPtr<CSSRuleList> CSSRuleList::create_empty(JS::Realm& realm)
+GC::Ref<CSSRuleList> CSSRuleList::create_empty(JS::Realm& realm)
 {
     return realm.create<CSSRuleList>(realm);
 }
diff --git a/Libraries/LibWeb/CSS/CSSRuleList.h b/Libraries/LibWeb/CSS/CSSRuleList.h
index 422ad37dda8..8b1f395116a 100644
--- a/Libraries/LibWeb/CSS/CSSRuleList.h
+++ b/Libraries/LibWeb/CSS/CSSRuleList.h
@@ -22,11 +22,11 @@ namespace Web::CSS {
 // https://www.w3.org/TR/cssom/#the-cssrulelist-interface
 class CSSRuleList : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CSSRuleList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CSSRuleList);
+    GC_DECLARE_ALLOCATOR(CSSRuleList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSRuleList> create(JS::Realm&, JS::MarkedVector<CSSRule*> const&);
-    [[nodiscard]] static JS::NonnullGCPtr<CSSRuleList> create_empty(JS::Realm&);
+    [[nodiscard]] static GC::Ref<CSSRuleList> create(JS::Realm&, GC::MarkedVector<CSSRule*> const&);
+    [[nodiscard]] static GC::Ref<CSSRuleList> create_empty(JS::Realm&);
 
     ~CSSRuleList() = default;
 
@@ -61,7 +61,7 @@ public:
     // Returns whether the match state of any media queries changed after evaluation.
     bool evaluate_media_queries(HTML::Window const&);
 
-    void set_rules(Badge<CSSStyleSheet>, Vector<JS::NonnullGCPtr<CSSRule>> rules) { m_rules = move(rules); }
+    void set_rules(Badge<CSSStyleSheet>, Vector<GC::Ref<CSSRule>> rules) { m_rules = move(rules); }
 
     Function<void()> on_change;
 
@@ -71,7 +71,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<JS::NonnullGCPtr<CSSRule>> m_rules;
+    Vector<GC::Ref<CSSRule>> m_rules;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/CSSStyleDeclaration.cpp b/Libraries/LibWeb/CSS/CSSStyleDeclaration.cpp
index 98480f66de0..56315c7aa4a 100644
--- a/Libraries/LibWeb/CSS/CSSStyleDeclaration.cpp
+++ b/Libraries/LibWeb/CSS/CSSStyleDeclaration.cpp
@@ -17,9 +17,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSStyleDeclaration);
-JS_DEFINE_ALLOCATOR(PropertyOwningCSSStyleDeclaration);
-JS_DEFINE_ALLOCATOR(ElementInlineCSSStyleDeclaration);
+GC_DEFINE_ALLOCATOR(CSSStyleDeclaration);
+GC_DEFINE_ALLOCATOR(PropertyOwningCSSStyleDeclaration);
+GC_DEFINE_ALLOCATOR(ElementInlineCSSStyleDeclaration);
 
 CSSStyleDeclaration::CSSStyleDeclaration(JS::Realm& realm)
     : PlatformObject(realm)
@@ -35,12 +35,12 @@ void CSSStyleDeclaration::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(CSSStyleDeclaration);
 }
 
-JS::GCPtr<CSSRule> CSSStyleDeclaration::parent_rule() const
+GC::Ptr<CSSRule> CSSStyleDeclaration::parent_rule() const
 {
     return nullptr;
 }
 
-JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration> PropertyOwningCSSStyleDeclaration::create(JS::Realm& realm, Vector<StyleProperty> properties, HashMap<FlyString, StyleProperty> custom_properties)
+GC::Ref<PropertyOwningCSSStyleDeclaration> PropertyOwningCSSStyleDeclaration::create(JS::Realm& realm, Vector<StyleProperty> properties, HashMap<FlyString, StyleProperty> custom_properties)
 {
     return realm.create<PropertyOwningCSSStyleDeclaration>(realm, move(properties), move(custom_properties));
 }
@@ -69,7 +69,7 @@ String PropertyOwningCSSStyleDeclaration::item(size_t index) const
     return CSS::string_from_property_id(m_properties[index].property_id).to_string();
 }
 
-JS::NonnullGCPtr<ElementInlineCSSStyleDeclaration> ElementInlineCSSStyleDeclaration::create(DOM::Element& element, Vector<StyleProperty> properties, HashMap<FlyString, StyleProperty> custom_properties)
+GC::Ref<ElementInlineCSSStyleDeclaration> ElementInlineCSSStyleDeclaration::create(DOM::Element& element, Vector<StyleProperty> properties, HashMap<FlyString, StyleProperty> custom_properties)
 {
     auto& realm = element.realm();
     return realm.create<ElementInlineCSSStyleDeclaration>(element, move(properties), move(custom_properties));
@@ -505,12 +505,12 @@ WebIDL::ExceptionOr<void> ElementInlineCSSStyleDeclaration::set_css_text(StringV
     return {};
 }
 
-JS::GCPtr<CSSRule> PropertyOwningCSSStyleDeclaration::parent_rule() const
+GC::Ptr<CSSRule> PropertyOwningCSSStyleDeclaration::parent_rule() const
 {
     return m_parent_rule;
 }
 
-void PropertyOwningCSSStyleDeclaration::set_parent_rule(JS::NonnullGCPtr<CSSRule> rule)
+void PropertyOwningCSSStyleDeclaration::set_parent_rule(GC::Ref<CSSRule> rule)
 {
     m_parent_rule = rule;
 }
diff --git a/Libraries/LibWeb/CSS/CSSStyleDeclaration.h b/Libraries/LibWeb/CSS/CSSStyleDeclaration.h
index 6f7e41f79c0..8fb18c23f06 100644
--- a/Libraries/LibWeb/CSS/CSSStyleDeclaration.h
+++ b/Libraries/LibWeb/CSS/CSSStyleDeclaration.h
@@ -19,7 +19,7 @@ class CSSStyleDeclaration
     : public Bindings::PlatformObject
     , public Bindings::GeneratedCSSStyleProperties {
     WEB_PLATFORM_OBJECT(CSSStyleDeclaration, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CSSStyleDeclaration);
+    GC_DECLARE_ALLOCATOR(CSSStyleDeclaration);
 
 public:
     virtual ~CSSStyleDeclaration() = default;
@@ -47,7 +47,7 @@ public:
 
     virtual String serialized() const = 0;
 
-    virtual JS::GCPtr<CSSRule> parent_rule() const;
+    virtual GC::Ptr<CSSRule> parent_rule() const;
 
 protected:
     explicit CSSStyleDeclaration(JS::Realm&);
@@ -61,12 +61,12 @@ private:
 
 class PropertyOwningCSSStyleDeclaration : public CSSStyleDeclaration {
     WEB_PLATFORM_OBJECT(PropertyOwningCSSStyleDeclaration, CSSStyleDeclaration);
-    JS_DECLARE_ALLOCATOR(PropertyOwningCSSStyleDeclaration);
+    GC_DECLARE_ALLOCATOR(PropertyOwningCSSStyleDeclaration);
 
     friend class ElementInlineCSSStyleDeclaration;
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration>
+    [[nodiscard]] static GC::Ref<PropertyOwningCSSStyleDeclaration>
     create(JS::Realm&, Vector<StyleProperty>, HashMap<FlyString, StyleProperty> custom_properties);
 
     virtual ~PropertyOwningCSSStyleDeclaration() override = default;
@@ -87,8 +87,8 @@ public:
     virtual String serialized() const final override;
     virtual WebIDL::ExceptionOr<void> set_css_text(StringView) override;
 
-    virtual JS::GCPtr<CSSRule> parent_rule() const override;
-    void set_parent_rule(JS::NonnullGCPtr<CSSRule>);
+    virtual GC::Ptr<CSSRule> parent_rule() const override;
+    void set_parent_rule(GC::Ref<CSSRule>);
 
 protected:
     PropertyOwningCSSStyleDeclaration(JS::Realm&, Vector<StyleProperty>, HashMap<FlyString, StyleProperty>);
@@ -103,17 +103,17 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<CSSRule> m_parent_rule;
+    GC::Ptr<CSSRule> m_parent_rule;
     Vector<StyleProperty> m_properties;
     HashMap<FlyString, StyleProperty> m_custom_properties;
 };
 
 class ElementInlineCSSStyleDeclaration final : public PropertyOwningCSSStyleDeclaration {
     WEB_PLATFORM_OBJECT(ElementInlineCSSStyleDeclaration, PropertyOwningCSSStyleDeclaration);
-    JS_DECLARE_ALLOCATOR(ElementInlineCSSStyleDeclaration);
+    GC_DECLARE_ALLOCATOR(ElementInlineCSSStyleDeclaration);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ElementInlineCSSStyleDeclaration> create(DOM::Element&, Vector<StyleProperty>, HashMap<FlyString, StyleProperty> custom_properties);
+    [[nodiscard]] static GC::Ref<ElementInlineCSSStyleDeclaration> create(DOM::Element&, Vector<StyleProperty>, HashMap<FlyString, StyleProperty> custom_properties);
 
     virtual ~ElementInlineCSSStyleDeclaration() override = default;
 
@@ -131,7 +131,7 @@ private:
 
     virtual void update_style_attribute() override;
 
-    JS::GCPtr<DOM::Element> m_element;
+    GC::Ptr<DOM::Element> m_element;
 
     // https://drafts.csswg.org/cssom/#cssstyledeclaration-updating-flag
     bool m_updating { false };
diff --git a/Libraries/LibWeb/CSS/CSSStyleRule.cpp b/Libraries/LibWeb/CSS/CSSStyleRule.cpp
index 88a3571f023..618b0e56a55 100644
--- a/Libraries/LibWeb/CSS/CSSStyleRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSStyleRule.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSStyleRule);
+GC_DEFINE_ALLOCATOR(CSSStyleRule);
 
-JS::NonnullGCPtr<CSSStyleRule> CSSStyleRule::create(JS::Realm& realm, SelectorList&& selectors, PropertyOwningCSSStyleDeclaration& declaration, CSSRuleList& nested_rules)
+GC::Ref<CSSStyleRule> CSSStyleRule::create(JS::Realm& realm, SelectorList&& selectors, PropertyOwningCSSStyleDeclaration& declaration, CSSRuleList& nested_rules)
 {
     return realm.create<CSSStyleRule>(realm, move(selectors), declaration, nested_rules);
 }
diff --git a/Libraries/LibWeb/CSS/CSSStyleRule.h b/Libraries/LibWeb/CSS/CSSStyleRule.h
index f416c2f9705..1370600e5f4 100644
--- a/Libraries/LibWeb/CSS/CSSStyleRule.h
+++ b/Libraries/LibWeb/CSS/CSSStyleRule.h
@@ -16,10 +16,10 @@ namespace Web::CSS {
 
 class CSSStyleRule final : public CSSGroupingRule {
     WEB_PLATFORM_OBJECT(CSSStyleRule, CSSGroupingRule);
-    JS_DECLARE_ALLOCATOR(CSSStyleRule);
+    GC_DECLARE_ALLOCATOR(CSSStyleRule);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSStyleRule> create(JS::Realm&, SelectorList&&, PropertyOwningCSSStyleDeclaration&, CSSRuleList&);
+    [[nodiscard]] static GC::Ref<CSSStyleRule> create(JS::Realm&, SelectorList&&, PropertyOwningCSSStyleDeclaration&, CSSRuleList&);
 
     virtual ~CSSStyleRule() override = default;
 
@@ -46,7 +46,7 @@ private:
 
     SelectorList m_selectors;
     mutable Optional<SelectorList> m_cached_absolutized_selectors;
-    JS::NonnullGCPtr<PropertyOwningCSSStyleDeclaration> m_declaration;
+    GC::Ref<PropertyOwningCSSStyleDeclaration> m_declaration;
 };
 
 template<>
diff --git a/Libraries/LibWeb/CSS/CSSStyleSheet.cpp b/Libraries/LibWeb/CSS/CSSStyleSheet.cpp
index d031e244f20..eab6b0a5640 100644
--- a/Libraries/LibWeb/CSS/CSSStyleSheet.cpp
+++ b/Libraries/LibWeb/CSS/CSSStyleSheet.cpp
@@ -21,15 +21,15 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSStyleSheet);
+GC_DEFINE_ALLOCATOR(CSSStyleSheet);
 
-JS::NonnullGCPtr<CSSStyleSheet> CSSStyleSheet::create(JS::Realm& realm, CSSRuleList& rules, MediaList& media, Optional<URL::URL> location)
+GC::Ref<CSSStyleSheet> CSSStyleSheet::create(JS::Realm& realm, CSSRuleList& rules, MediaList& media, Optional<URL::URL> location)
 {
     return realm.create<CSSStyleSheet>(realm, rules, media, move(location));
 }
 
 // https://drafts.csswg.org/cssom/#dom-cssstylesheet-cssstylesheet
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CSSStyleSheet>> CSSStyleSheet::construct_impl(JS::Realm& realm, Optional<CSSStyleSheetInit> const& options)
+WebIDL::ExceptionOr<GC::Ref<CSSStyleSheet>> CSSStyleSheet::construct_impl(JS::Realm& realm, Optional<CSSStyleSheetInit> const& options)
 {
     // 1. Construct a new CSSStyleSheet object sheet.
     auto sheet = create(realm, CSSRuleList::create_empty(realm), CSS::MediaList::create(realm, {}), {});
@@ -82,7 +82,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CSSStyleSheet>> CSSStyleSheet::construct_im
         if (options->media.has<String>()) {
             sheet->set_media(options->media.get<String>());
         } else {
-            sheet->m_media = *options->media.get<JS::Handle<MediaList>>();
+            sheet->m_media = *options->media.get<GC::Root<MediaList>>();
         }
     }
 
@@ -187,7 +187,7 @@ WebIDL::ExceptionOr<void> CSSStyleSheet::delete_rule(unsigned index)
 }
 
 // https://drafts.csswg.org/cssom/#dom-cssstylesheet-replace
-JS::NonnullGCPtr<WebIDL::Promise> CSSStyleSheet::replace(String text)
+GC::Ref<WebIDL::Promise> CSSStyleSheet::replace(String text)
 {
     auto& realm = this->realm();
 
@@ -209,7 +209,7 @@ JS::NonnullGCPtr<WebIDL::Promise> CSSStyleSheet::replace(String text)
     set_disallow_modification(true);
 
     // 4. In parallel, do these steps:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, this, text = move(text), promise = JS::Handle(promise)] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, this, text = move(text), promise = GC::Root(promise)] {
         HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
         // 1. Let rules be the result of running parse a stylesheet’s contents from text.
@@ -218,7 +218,7 @@ JS::NonnullGCPtr<WebIDL::Promise> CSSStyleSheet::replace(String text)
         auto& rules = parsed_stylesheet->rules();
 
         // 2. If rules contains one or more @import rules, remove those rules from rules.
-        JS::MarkedVector<JS::NonnullGCPtr<CSSRule>> rules_without_import(realm.heap());
+        GC::MarkedVector<GC::Ref<CSSRule>> rules_without_import(realm.heap());
         for (auto rule : rules) {
             if (rule->type() != CSSRule::Type::Import)
                 rules_without_import.append(rule);
@@ -252,7 +252,7 @@ WebIDL::ExceptionOr<void> CSSStyleSheet::replace_sync(StringView text)
     auto& rules = parsed_stylesheet->rules();
 
     // 3. If rules contains one or more @import rules, remove those rules from rules.
-    JS::MarkedVector<JS::NonnullGCPtr<CSSRule>> rules_without_import(realm().heap());
+    GC::MarkedVector<GC::Ref<CSSRule>> rules_without_import(realm().heap());
     for (auto rule : rules) {
         if (rule->type() != CSSRule::Type::Import)
             rules_without_import.append(rule);
@@ -352,7 +352,7 @@ Optional<FlyString> CSSStyleSheet::default_namespace() const
 Optional<FlyString> CSSStyleSheet::namespace_uri(StringView namespace_prefix) const
 {
     return m_namespace_rules.get(namespace_prefix)
-        .map([](JS::GCPtr<CSSNamespaceRule> namespace_) {
+        .map([](GC::Ptr<CSSNamespaceRule> namespace_) {
             return namespace_->namespace_uri();
         });
 }
diff --git a/Libraries/LibWeb/CSS/CSSStyleSheet.h b/Libraries/LibWeb/CSS/CSSStyleSheet.h
index eaac750dec5..bdfba05d40f 100644
--- a/Libraries/LibWeb/CSS/CSSStyleSheet.h
+++ b/Libraries/LibWeb/CSS/CSSStyleSheet.h
@@ -22,22 +22,22 @@ class FontLoader;
 
 struct CSSStyleSheetInit {
     Optional<String> base_url {};
-    Variant<JS::Handle<MediaList>, String> media { String {} };
+    Variant<GC::Root<MediaList>, String> media { String {} };
     bool disabled { false };
 };
 
 class CSSStyleSheet final : public StyleSheet {
     WEB_PLATFORM_OBJECT(CSSStyleSheet, StyleSheet);
-    JS_DECLARE_ALLOCATOR(CSSStyleSheet);
+    GC_DECLARE_ALLOCATOR(CSSStyleSheet);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CSSStyleSheet> create(JS::Realm&, CSSRuleList&, MediaList&, Optional<URL::URL> location);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CSSStyleSheet>> construct_impl(JS::Realm&, Optional<CSSStyleSheetInit> const& options = {});
+    [[nodiscard]] static GC::Ref<CSSStyleSheet> create(JS::Realm&, CSSRuleList&, MediaList&, Optional<URL::URL> location);
+    static WebIDL::ExceptionOr<GC::Ref<CSSStyleSheet>> construct_impl(JS::Realm&, Optional<CSSStyleSheetInit> const& options = {});
 
     virtual ~CSSStyleSheet() override = default;
 
-    JS::GCPtr<CSSRule const> owner_rule() const { return m_owner_css_rule; }
-    JS::GCPtr<CSSRule> owner_rule() { return m_owner_css_rule; }
+    GC::Ptr<CSSRule const> owner_rule() const { return m_owner_css_rule; }
+    GC::Ptr<CSSRule> owner_rule() { return m_owner_css_rule; }
     void set_owner_css_rule(CSSRule* rule) { m_owner_css_rule = rule; }
 
     virtual String type() const override { return "text/css"_string; }
@@ -53,7 +53,7 @@ public:
     WebIDL::ExceptionOr<void> remove_rule(Optional<WebIDL::UnsignedLong> index);
     WebIDL::ExceptionOr<void> delete_rule(unsigned index);
 
-    JS::NonnullGCPtr<WebIDL::Promise> replace(String text);
+    GC::Ref<WebIDL::Promise> replace(String text);
     WebIDL::ExceptionOr<void> replace_sync(StringView text);
 
     void for_each_effective_rule(TraversalOrder, Function<void(CSSRule const&)> const& callback) const;
@@ -62,23 +62,23 @@ public:
     bool evaluate_media_queries(HTML::Window const&);
     void for_each_effective_keyframes_at_rule(Function<void(CSSKeyframesRule const&)> const& callback) const;
 
-    JS::GCPtr<StyleSheetList> style_sheet_list() const { return m_style_sheet_list; }
+    GC::Ptr<StyleSheetList> style_sheet_list() const { return m_style_sheet_list; }
     void set_style_sheet_list(Badge<StyleSheetList>, StyleSheetList*);
 
     Optional<FlyString> default_namespace() const;
-    JS::GCPtr<CSSNamespaceRule> default_namespace_rule() const { return m_default_namespace_rule; }
+    GC::Ptr<CSSNamespaceRule> default_namespace_rule() const { return m_default_namespace_rule; }
 
     Optional<FlyString> namespace_uri(StringView namespace_prefix) const;
 
-    Vector<JS::NonnullGCPtr<CSSImportRule>> const& import_rules() const { return m_import_rules; }
+    Vector<GC::Ref<CSSImportRule>> const& import_rules() const { return m_import_rules; }
 
     Optional<URL::URL> base_url() const { return m_base_url; }
     void set_base_url(Optional<URL::URL> base_url) { m_base_url = move(base_url); }
 
     bool constructed() const { return m_constructed; }
 
-    JS::GCPtr<DOM::Document const> constructor_document() const { return m_constructor_document; }
-    void set_constructor_document(JS::GCPtr<DOM::Document const> constructor_document) { m_constructor_document = constructor_document; }
+    GC::Ptr<DOM::Document const> constructor_document() const { return m_constructor_document; }
+    void set_constructor_document(GC::Ptr<DOM::Document const> constructor_document) { m_constructor_document = constructor_document; }
 
     bool disallow_modification() const { return m_disallow_modification; }
 
@@ -104,16 +104,16 @@ private:
 
     Optional<String> m_source_text;
 
-    JS::GCPtr<CSSRuleList> m_rules;
-    JS::GCPtr<CSSNamespaceRule> m_default_namespace_rule;
-    HashMap<FlyString, JS::GCPtr<CSSNamespaceRule>> m_namespace_rules;
-    Vector<JS::NonnullGCPtr<CSSImportRule>> m_import_rules;
+    GC::Ptr<CSSRuleList> m_rules;
+    GC::Ptr<CSSNamespaceRule> m_default_namespace_rule;
+    HashMap<FlyString, GC::Ptr<CSSNamespaceRule>> m_namespace_rules;
+    Vector<GC::Ref<CSSImportRule>> m_import_rules;
 
-    JS::GCPtr<StyleSheetList> m_style_sheet_list;
-    JS::GCPtr<CSSRule> m_owner_css_rule;
+    GC::Ptr<StyleSheetList> m_style_sheet_list;
+    GC::Ptr<CSSRule> m_owner_css_rule;
 
     Optional<URL::URL> m_base_url;
-    JS::GCPtr<DOM::Document const> m_constructor_document;
+    GC::Ptr<DOM::Document const> m_constructor_document;
     bool m_constructed { false };
     bool m_disallow_modification { false };
     Optional<bool> m_did_match;
diff --git a/Libraries/LibWeb/CSS/CSSSupportsRule.cpp b/Libraries/LibWeb/CSS/CSSSupportsRule.cpp
index a011ea41e80..765bcd8ed06 100644
--- a/Libraries/LibWeb/CSS/CSSSupportsRule.cpp
+++ b/Libraries/LibWeb/CSS/CSSSupportsRule.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSSupportsRule);
+GC_DEFINE_ALLOCATOR(CSSSupportsRule);
 
-JS::NonnullGCPtr<CSSSupportsRule> CSSSupportsRule::create(JS::Realm& realm, NonnullRefPtr<Supports>&& supports, CSSRuleList& rules)
+GC::Ref<CSSSupportsRule> CSSSupportsRule::create(JS::Realm& realm, NonnullRefPtr<Supports>&& supports, CSSRuleList& rules)
 {
     return realm.create<CSSSupportsRule>(realm, move(supports), rules);
 }
diff --git a/Libraries/LibWeb/CSS/CSSSupportsRule.h b/Libraries/LibWeb/CSS/CSSSupportsRule.h
index c3d2efaee29..215632550c5 100644
--- a/Libraries/LibWeb/CSS/CSSSupportsRule.h
+++ b/Libraries/LibWeb/CSS/CSSSupportsRule.h
@@ -17,10 +17,10 @@ namespace Web::CSS {
 // https://www.w3.org/TR/css-conditional-3/#the-csssupportsrule-interface
 class CSSSupportsRule final : public CSSConditionRule {
     WEB_PLATFORM_OBJECT(CSSSupportsRule, CSSConditionRule);
-    JS_DECLARE_ALLOCATOR(CSSSupportsRule);
+    GC_DECLARE_ALLOCATOR(CSSSupportsRule);
 
 public:
-    static JS::NonnullGCPtr<CSSSupportsRule> create(JS::Realm&, NonnullRefPtr<Supports>&&, CSSRuleList&);
+    static GC::Ref<CSSSupportsRule> create(JS::Realm&, NonnullRefPtr<Supports>&&, CSSRuleList&);
 
     virtual ~CSSSupportsRule() = default;
 
diff --git a/Libraries/LibWeb/CSS/CSSTransition.cpp b/Libraries/LibWeb/CSS/CSSTransition.cpp
index d2c066c792c..c8ac7e30e02 100644
--- a/Libraries/LibWeb/CSS/CSSTransition.cpp
+++ b/Libraries/LibWeb/CSS/CSSTransition.cpp
@@ -17,9 +17,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(CSSTransition);
+GC_DEFINE_ALLOCATOR(CSSTransition);
 
-JS::NonnullGCPtr<CSSTransition> CSSTransition::start_a_transition(DOM::Element& element, PropertyID property_id, size_t transition_generation,
+GC::Ref<CSSTransition> CSSTransition::start_a_transition(DOM::Element& element, PropertyID property_id, size_t transition_generation,
     double start_time, double end_time, NonnullRefPtr<CSSStyleValue const> start_value, NonnullRefPtr<CSSStyleValue const> end_value,
     NonnullRefPtr<CSSStyleValue const> reversing_adjusted_start_value, double reversing_shortening_factor)
 {
@@ -32,9 +32,9 @@ Animations::AnimationClass CSSTransition::animation_class() const
     return Animations::AnimationClass::CSSTransition;
 }
 
-Optional<int> CSSTransition::class_specific_composite_order(JS::NonnullGCPtr<Animations::Animation> other_animation) const
+Optional<int> CSSTransition::class_specific_composite_order(GC::Ref<Animations::Animation> other_animation) const
 {
-    auto other = JS::NonnullGCPtr { verify_cast<CSSTransition>(*other_animation) };
+    auto other = GC::Ref { verify_cast<CSSTransition>(*other_animation) };
 
     // Within the set of CSS Transitions, two animations A and B are sorted in composite order (first to last) as
     // follows:
diff --git a/Libraries/LibWeb/CSS/CSSTransition.h b/Libraries/LibWeb/CSS/CSSTransition.h
index ac017e208f9..e8b1cc91819 100644
--- a/Libraries/LibWeb/CSS/CSSTransition.h
+++ b/Libraries/LibWeb/CSS/CSSTransition.h
@@ -17,17 +17,17 @@ namespace Web::CSS {
 
 class CSSTransition : public Animations::Animation {
     WEB_PLATFORM_OBJECT(CSSTransition, Animations::Animation);
-    JS_DECLARE_ALLOCATOR(CSSTransition);
+    GC_DECLARE_ALLOCATOR(CSSTransition);
 
 public:
-    static JS::NonnullGCPtr<CSSTransition> start_a_transition(DOM::Element&, PropertyID, size_t transition_generation,
+    static GC::Ref<CSSTransition> start_a_transition(DOM::Element&, PropertyID, size_t transition_generation,
         double start_time, double end_time, NonnullRefPtr<CSSStyleValue const> start_value, NonnullRefPtr<CSSStyleValue const> end_value,
         NonnullRefPtr<CSSStyleValue const> reversing_adjusted_start_value, double reversing_shortening_factor);
 
     StringView transition_property() const { return string_from_property_id(m_transition_property); }
 
     virtual Animations::AnimationClass animation_class() const override;
-    virtual Optional<int> class_specific_composite_order(JS::NonnullGCPtr<Animations::Animation> other) const override;
+    virtual Optional<int> class_specific_composite_order(GC::Ref<Animations::Animation> other) const override;
 
     double transition_start_time() const { return m_start_time; }
     double transition_end_time() const { return m_end_time; }
@@ -72,9 +72,9 @@ private:
     // https://drafts.csswg.org/css-transitions/#transition-reversing-shortening-factor
     double m_reversing_shortening_factor;
 
-    JS::NonnullGCPtr<Animations::KeyframeEffect> m_keyframe_effect;
+    GC::Ref<Animations::KeyframeEffect> m_keyframe_effect;
 
-    JS::GCPtr<CSS::CSSStyleDeclaration const> m_cached_declaration;
+    GC::Ptr<CSS::CSSStyleDeclaration const> m_cached_declaration;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/FontFace.cpp b/Libraries/LibWeb/CSS/FontFace.cpp
index 87297f41809..67bddedd1f3 100644
--- a/Libraries/LibWeb/CSS/FontFace.cpp
+++ b/Libraries/LibWeb/CSS/FontFace.cpp
@@ -5,10 +5,10 @@
  */
 
 #include <LibCore/Promise.h>
+#include <LibGC/Heap.h>
 #include <LibGfx/Font/Typeface.h>
 #include <LibGfx/Font/WOFF/Loader.h>
 #include <LibGfx/Font/WOFF2/Loader.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/ArrayBuffer.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/FontFacePrototype.h>
@@ -31,7 +31,7 @@ static NonnullRefPtr<Core::Promise<NonnullRefPtr<Gfx::Typeface>>> load_vector_fo
 
     // FIXME: 'Asynchronously' shouldn't mean 'later on the main thread'.
     //        Can we defer this to a background thread?
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&data, promise] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&data, promise] {
         // FIXME: This should be de-duplicated with StyleComputer::FontLoader::try_load_font
         // We don't have the luxury of knowing the MIME type, so we have to try all formats.
         auto ttf = Gfx::Typeface::try_load_from_externally_owned_memory(data);
@@ -55,7 +55,7 @@ static NonnullRefPtr<Core::Promise<NonnullRefPtr<Gfx::Typeface>>> load_vector_fo
     return promise;
 }
 
-JS_DEFINE_ALLOCATOR(FontFace);
+GC_DEFINE_ALLOCATOR(FontFace);
 
 template<CSS::PropertyID PropertyID>
 RefPtr<CSSStyleValue const> parse_property_string(JS::Realm& realm, StringView value)
@@ -65,7 +65,7 @@ RefPtr<CSSStyleValue const> parse_property_string(JS::Realm& realm, StringView v
 }
 
 // https://drafts.csswg.org/css-font-loading/#font-face-constructor
-JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, FontFaceSource source, FontFaceDescriptors const& descriptors)
+GC::Ref<FontFace> FontFace::construct_impl(JS::Realm& realm, String family, FontFaceSource source, FontFaceDescriptors const& descriptors)
 {
     auto& vm = realm.vm();
     auto base_url = HTML::relevant_settings_object(realm.global_object()).api_base_url();
@@ -93,7 +93,7 @@ JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String fam
         if (sources.is_empty())
             WebIDL::reject_promise(realm, promise, WebIDL::SyntaxError::create(realm, "FontFace constructor: Invalid source string"_string));
     } else {
-        auto buffer_source = source.get<JS::Handle<WebIDL::BufferSource>>();
+        auto buffer_source = source.get<GC::Root<WebIDL::BufferSource>>();
         auto maybe_buffer = WebIDL::get_buffer_source_copy(buffer_source->raw_object());
         if (maybe_buffer.is_error()) {
             VERIFY(maybe_buffer.error().code() == ENOMEM);
@@ -118,7 +118,7 @@ JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String fam
     if (font->m_binary_data.is_empty())
         return font;
 
-    HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), JS::create_heap_function(vm.heap(), [&realm, font] {
+    HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(vm.heap(), [&realm, font] {
         // 1.  Set font face’s status attribute to "loading".
         font->m_status = Bindings::FontFaceLoadStatus::Loading;
 
@@ -128,8 +128,8 @@ JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String fam
         //    When this is completed, successfully or not, queue a task to run the following steps synchronously:
         font->m_font_load_promise = load_vector_font(realm, font->m_binary_data);
 
-        font->m_font_load_promise->when_resolved([font = JS::make_handle(font)](auto const& vector_font) -> ErrorOr<void> {
-            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), JS::create_heap_function(font->heap(), [font = JS::NonnullGCPtr(*font), vector_font] {
+        font->m_font_load_promise->when_resolved([font = GC::make_root(font)](auto const& vector_font) -> ErrorOr<void> {
+            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font), vector_font] {
                 HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
                 // 1. If the load was successful, font face now represents the parsed font;
                 //    fulfill font face’s [[FontStatusPromise]] with font face, and set its status attribute to "loaded".
@@ -145,8 +145,8 @@ JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String fam
             }));
             return {};
         });
-        font->m_font_load_promise->when_rejected([font = JS::make_handle(font)](auto const& error) {
-            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), JS::create_heap_function(font->heap(), [font = JS::NonnullGCPtr(*font), error = Error::copy(error)] {
+        font->m_font_load_promise->when_rejected([font = GC::make_root(font)](auto const& error) {
+            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font), error = Error::copy(error)] {
                 HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
                 // 2. Otherwise, reject font face’s [[FontStatusPromise]] with a DOMException named "SyntaxError"
                 //    and set font face’s status attribute to "error".
@@ -163,7 +163,7 @@ JS::NonnullGCPtr<FontFace> FontFace::construct_impl(JS::Realm& realm, String fam
     return font;
 }
 
-FontFace::FontFace(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String font_family, FontFaceDescriptors const& descriptors)
+FontFace::FontFace(JS::Realm& realm, GC::Ref<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String font_family, FontFaceDescriptors const& descriptors)
     : Bindings::PlatformObject(realm)
     , m_font_status_promise(font_status_promise)
     , m_urls(move(urls))
@@ -205,7 +205,7 @@ void FontFace::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_font_status_promise);
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> FontFace::loaded() const
+GC::Ref<WebIDL::Promise> FontFace::loaded() const
 {
     return m_font_status_promise;
 }
@@ -320,7 +320,7 @@ WebIDL::ExceptionOr<void> FontFace::set_line_gap_override(String const&)
 }
 
 // https://drafts.csswg.org/css-font-loading/#dom-fontface-load
-JS::NonnullGCPtr<WebIDL::Promise> FontFace::load()
+GC::Ref<WebIDL::Promise> FontFace::load()
 {
     //  1. Let font face be the FontFace object on which this method was called.
     auto& font_face = *this;
@@ -349,13 +349,13 @@ void FontFace::load_font_source()
     //    and continue executing the rest of this algorithm asynchronously.
     m_status = Bindings::FontFaceLoadStatus::Loading;
 
-    Web::Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [font = JS::make_handle(this)] {
+    Web::Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [font = GC::make_root(this)] {
         // 4. Using the value of font face’s [[Urls]] slot, attempt to load a font as defined in [CSS-FONTS-3],
         //     as if it was the value of a @font-face rule’s src descriptor.
 
         // 5. When the load operation completes, successfully or not, queue a task to run the following steps synchronously:
         auto on_error = [font] {
-            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), JS::create_heap_function(font->heap(), [font = JS::NonnullGCPtr(*font)] {
+            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font)] {
                 HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
                 //     1. If the attempt to load fails, reject font face’s [[FontStatusPromise]] with a DOMException whose name
@@ -369,7 +369,7 @@ void FontFace::load_font_source()
 
         auto on_load = [font](FontLoader const& loader) {
             // FIXME: We are assuming that the font loader will live as long as the document! This is an unsafe capture
-            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), JS::create_heap_function(font->heap(), [font = JS::NonnullGCPtr(*font), &loader] {
+            HTML::queue_global_task(HTML::Task::Source::FontLoading, HTML::relevant_global_object(*font), GC::create_function(font->heap(), [font = GC::Ref(*font), &loader] {
                 HTML::TemporaryExecutionContext context(font->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
                 // 2. Otherwise, font face now represents the loaded font; fulfill font face’s [[FontStatusPromise]] with font face
diff --git a/Libraries/LibWeb/CSS/FontFace.h b/Libraries/LibWeb/CSS/FontFace.h
index c074ebb8400..a8d680dba06 100644
--- a/Libraries/LibWeb/CSS/FontFace.h
+++ b/Libraries/LibWeb/CSS/FontFace.h
@@ -29,12 +29,12 @@ struct FontFaceDescriptors {
 
 class FontFace final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(FontFace, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(FontFace);
+    GC_DECLARE_ALLOCATOR(FontFace);
 
 public:
-    using FontFaceSource = Variant<String, JS::Handle<WebIDL::BufferSource>>;
+    using FontFaceSource = Variant<String, GC::Root<WebIDL::BufferSource>>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<FontFace> construct_impl(JS::Realm&, String family, FontFaceSource source, FontFaceDescriptors const& descriptors);
+    [[nodiscard]] static GC::Ref<FontFace> construct_impl(JS::Realm&, String family, FontFaceSource source, FontFaceDescriptors const& descriptors);
     virtual ~FontFace() override;
 
     String family() const { return m_family; }
@@ -74,15 +74,15 @@ public:
 
     Bindings::FontFaceLoadStatus status() const { return m_status; }
 
-    JS::NonnullGCPtr<WebIDL::Promise> load();
-    JS::NonnullGCPtr<WebIDL::Promise> loaded() const;
+    GC::Ref<WebIDL::Promise> load();
+    GC::Ref<WebIDL::Promise> loaded() const;
 
     void load_font_source();
 
-    JS::NonnullGCPtr<WebIDL::Promise> font_status_promise() { return m_font_status_promise; }
+    GC::Ref<WebIDL::Promise> font_status_promise() { return m_font_status_promise; }
 
 private:
-    FontFace(JS::Realm&, JS::NonnullGCPtr<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String family, FontFaceDescriptors const& descriptors);
+    FontFace(JS::Realm&, GC::Ref<WebIDL::Promise> font_status_promise, Vector<ParsedFontFace::Source> urls, ByteBuffer data, String family, FontFaceDescriptors const& descriptors);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor&) override;
@@ -104,9 +104,9 @@ private:
     // https://drafts.csswg.org/css-font-loading/#dom-fontface-status
     Bindings::FontFaceLoadStatus m_status { Bindings::FontFaceLoadStatus::Unloaded };
 
-    JS::NonnullGCPtr<WebIDL::Promise> m_font_status_promise; // [[FontStatusPromise]]
-    Vector<ParsedFontFace::Source> m_urls;                   // [[Urls]]
-    ByteBuffer m_binary_data;                                // [[Data]]
+    GC::Ref<WebIDL::Promise> m_font_status_promise; // [[FontStatusPromise]]
+    Vector<ParsedFontFace::Source> m_urls;          // [[Urls]]
+    ByteBuffer m_binary_data;                       // [[Data]]
 
     RefPtr<Gfx::Typeface> m_parsed_font;
     RefPtr<Core::Promise<NonnullRefPtr<Gfx::Typeface>>> m_font_load_promise;
diff --git a/Libraries/LibWeb/CSS/FontFaceSet.cpp b/Libraries/LibWeb/CSS/FontFaceSet.cpp
index f46a5a70983..254cb3dfa3d 100644
--- a/Libraries/LibWeb/CSS/FontFaceSet.cpp
+++ b/Libraries/LibWeb/CSS/FontFaceSet.cpp
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibJS/Runtime/Set.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
@@ -25,10 +25,10 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(FontFaceSet);
+GC_DEFINE_ALLOCATOR(FontFaceSet);
 
 // https://drafts.csswg.org/css-font-loading/#dom-fontfaceset-fontfaceset
-JS::NonnullGCPtr<FontFaceSet> FontFaceSet::construct_impl(JS::Realm& realm, Vector<JS::Handle<FontFace>> const& initial_faces)
+GC::Ref<FontFaceSet> FontFaceSet::construct_impl(JS::Realm& realm, Vector<GC::Root<FontFace>> const& initial_faces)
 {
     auto ready_promise = WebIDL::create_promise(realm);
     auto set_entries = JS::Set::create(realm);
@@ -40,12 +40,12 @@ JS::NonnullGCPtr<FontFaceSet> FontFaceSet::construct_impl(JS::Realm& realm, Vect
     return realm.create<FontFaceSet>(realm, ready_promise, set_entries);
 }
 
-JS::NonnullGCPtr<FontFaceSet> FontFaceSet::create(JS::Realm& realm)
+GC::Ref<FontFaceSet> FontFaceSet::create(JS::Realm& realm)
 {
     return construct_impl(realm, {});
 }
 
-FontFaceSet::FontFaceSet(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::Promise> ready_promise, JS::NonnullGCPtr<JS::Set> set_entries)
+FontFaceSet::FontFaceSet(JS::Realm& realm, GC::Ref<WebIDL::Promise> ready_promise, GC::Ref<JS::Set> set_entries)
     : DOM::EventTarget(realm)
     , m_set_entries(set_entries)
     , m_ready_promise(ready_promise)
@@ -71,12 +71,12 @@ void FontFaceSet::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://drafts.csswg.org/css-font-loading/#dom-fontfaceset-add
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FontFaceSet>>
-FontFaceSet::add(JS::Handle<FontFace> face)
+WebIDL::ExceptionOr<GC::Ref<FontFaceSet>>
+FontFaceSet::add(GC::Root<FontFace> face)
 {
     // 1. If font is already in the FontFaceSet’s set entries, skip to the last step of this algorithm immediately.
     if (m_set_entries->set_has(face))
-        return JS::NonnullGCPtr<FontFaceSet>(*this);
+        return GC::Ref<FontFaceSet>(*this);
 
     // 2. If font is CSS-connected, throw an InvalidModificationError exception and exit this algorithm immediately.
     if (face->is_css_connected()) {
@@ -99,11 +99,11 @@ FontFaceSet::add(JS::Handle<FontFace> face)
     }
 
     // 5. Return the FontFaceSet.
-    return JS::NonnullGCPtr<FontFaceSet>(*this);
+    return GC::Ref<FontFaceSet>(*this);
 }
 
 // https://drafts.csswg.org/css-font-loading/#dom-fontfaceset-delete
-bool FontFaceSet::delete_(JS::Handle<FontFace> face)
+bool FontFaceSet::delete_(GC::Root<FontFace> face)
 {
     // 1. If font is CSS-connected, return false and exit this algorithm immediately.
     if (face->is_css_connected()) {
@@ -171,7 +171,7 @@ WebIDL::CallbackType* FontFaceSet::onloadingerror()
 }
 
 // https://drafts.csswg.org/css-font-loading/#find-the-matching-font-faces
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Set>> find_matching_font_faces(JS::Realm& realm, FontFaceSet& font_face_set, String const& font, String const&)
+static WebIDL::ExceptionOr<GC::Ref<JS::Set>> find_matching_font_faces(JS::Realm& realm, FontFaceSet& font_face_set, String const& font, String const&)
 {
     // 1. Parse font using the CSS value syntax of the font property. If a syntax error occurs, return a syntax error.
     auto parser = CSS::Parser::Parser::create(CSS::Parser::ParsingContext(realm), font);
@@ -227,15 +227,15 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Set>> find_matching_font_faces(J
 }
 
 // https://drafts.csswg.org/css-font-loading/#dom-fontfaceset-load
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> FontFaceSet::load(String const& font, String const& text)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> FontFaceSet::load(String const& font, String const& text)
 {
     auto& realm = this->realm();
 
     // 1. Let font face set be the FontFaceSet object this method was called on. Let promise be a newly-created promise object.
-    JS::NonnullGCPtr font_face_set = *this;
+    GC::Ref font_face_set = *this;
     auto promise = WebIDL::create_promise(realm);
 
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, font_face_set, promise, font, text]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, font_face_set, promise, font, text]() mutable {
         // 3. Find the matching font faces from font face set using the font and text arguments passed to the function,
         //    and let font face list be the return value (ignoring the found faces flag). If a syntax error was returned,
         //    reject promise with a SyntaxError exception and terminate these steps.
@@ -249,8 +249,8 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> FontFaceSet::load(Strin
         auto matched_font_faces = result.release_value();
 
         // 4. Queue a task to run the following steps synchronously:
-        HTML::queue_a_task(HTML::Task::Source::FontLoading, nullptr, nullptr, JS::create_heap_function(realm.heap(), [&realm, promise, matched_font_faces] {
-            JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> promises(realm.heap());
+        HTML::queue_a_task(HTML::Task::Source::FontLoading, nullptr, nullptr, GC::create_function(realm.heap(), [&realm, promise, matched_font_faces] {
+            GC::MarkedVector<GC::Ref<WebIDL::Promise>> promises(realm.heap());
 
             // 1. For all of the font faces in the font face list, call their load() method.
             for (auto font_face_value : *matched_font_faces) {
@@ -282,7 +282,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> FontFaceSet::load(Strin
 }
 
 // https://drafts.csswg.org/css-font-loading/#font-face-set-ready
-JS::NonnullGCPtr<WebIDL::Promise> FontFaceSet::ready() const
+GC::Ref<WebIDL::Promise> FontFaceSet::ready() const
 {
     return m_ready_promise;
 }
diff --git a/Libraries/LibWeb/CSS/FontFaceSet.h b/Libraries/LibWeb/CSS/FontFaceSet.h
index 9cd6e5c34cc..1c84ed10f91 100644
--- a/Libraries/LibWeb/CSS/FontFaceSet.h
+++ b/Libraries/LibWeb/CSS/FontFaceSet.h
@@ -18,17 +18,17 @@ namespace Web::CSS {
 
 class FontFaceSet final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(FontFaceSet, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(FontFaceSet);
+    GC_DECLARE_ALLOCATOR(FontFaceSet);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FontFaceSet> construct_impl(JS::Realm&, Vector<JS::Handle<FontFace>> const& initial_faces);
-    [[nodiscard]] static JS::NonnullGCPtr<FontFaceSet> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<FontFaceSet> construct_impl(JS::Realm&, Vector<GC::Root<FontFace>> const& initial_faces);
+    [[nodiscard]] static GC::Ref<FontFaceSet> create(JS::Realm&);
     virtual ~FontFaceSet() override = default;
 
-    JS::NonnullGCPtr<JS::Set> set_entries() const { return m_set_entries; }
+    GC::Ref<JS::Set> set_entries() const { return m_set_entries; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<FontFaceSet>> add(JS::Handle<FontFace>);
-    bool delete_(JS::Handle<FontFace>);
+    WebIDL::ExceptionOr<GC::Ref<FontFaceSet>> add(GC::Root<FontFace>);
+    bool delete_(GC::Root<FontFace>);
     void clear();
 
     void set_onloading(WebIDL::CallbackType*);
@@ -38,25 +38,25 @@ public:
     void set_onloadingerror(WebIDL::CallbackType*);
     WebIDL::CallbackType* onloadingerror();
 
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> load(String const& font, String const& text);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> load(String const& font, String const& text);
 
-    JS::NonnullGCPtr<WebIDL::Promise> ready() const;
+    GC::Ref<WebIDL::Promise> ready() const;
     Bindings::FontFaceSetLoadStatus status() const { return m_status; }
 
     void resolve_ready_promise();
 
 private:
-    FontFaceSet(JS::Realm&, JS::NonnullGCPtr<WebIDL::Promise> ready_promise, JS::NonnullGCPtr<JS::Set> set_entries);
+    FontFaceSet(JS::Realm&, GC::Ref<WebIDL::Promise> ready_promise, GC::Ref<JS::Set> set_entries);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<JS::Set> m_set_entries;
-    JS::NonnullGCPtr<WebIDL::Promise> m_ready_promise; // [[ReadyPromise]]
+    GC::Ref<JS::Set> m_set_entries;
+    GC::Ref<WebIDL::Promise> m_ready_promise; // [[ReadyPromise]]
 
-    Vector<JS::NonnullGCPtr<FontFace>> m_loading_fonts {}; // [[LoadingFonts]]
-    Vector<JS::NonnullGCPtr<FontFace>> m_loaded_fonts {};  // [[LoadedFonts]]
-    Vector<JS::NonnullGCPtr<FontFace>> m_failed_fonts {};  // [[FailedFonts]]
+    Vector<GC::Ref<FontFace>> m_loading_fonts {}; // [[LoadingFonts]]
+    Vector<GC::Ref<FontFace>> m_loaded_fonts {};  // [[LoadedFonts]]
+    Vector<GC::Ref<FontFace>> m_failed_fonts {};  // [[FailedFonts]]
 
     Bindings::FontFaceSetLoadStatus m_status { Bindings::FontFaceSetLoadStatus::Loading };
 };
diff --git a/Libraries/LibWeb/CSS/MediaList.cpp b/Libraries/LibWeb/CSS/MediaList.cpp
index 440f96a8a46..25c4e8b0b03 100644
--- a/Libraries/LibWeb/CSS/MediaList.cpp
+++ b/Libraries/LibWeb/CSS/MediaList.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(MediaList);
+GC_DEFINE_ALLOCATOR(MediaList);
 
-JS::NonnullGCPtr<MediaList> MediaList::create(JS::Realm& realm, Vector<NonnullRefPtr<MediaQuery>>&& media)
+GC::Ref<MediaList> MediaList::create(JS::Realm& realm, Vector<NonnullRefPtr<MediaQuery>>&& media)
 {
     return realm.create<MediaList>(realm, move(media));
 }
diff --git a/Libraries/LibWeb/CSS/MediaList.h b/Libraries/LibWeb/CSS/MediaList.h
index 3f401847749..48365abc519 100644
--- a/Libraries/LibWeb/CSS/MediaList.h
+++ b/Libraries/LibWeb/CSS/MediaList.h
@@ -18,10 +18,10 @@ namespace Web::CSS {
 // https://www.w3.org/TR/cssom-1/#the-medialist-interface
 class MediaList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MediaList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MediaList);
+    GC_DECLARE_ALLOCATOR(MediaList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MediaList> create(JS::Realm&, Vector<NonnullRefPtr<MediaQuery>>&&);
+    [[nodiscard]] static GC::Ref<MediaList> create(JS::Realm&, Vector<NonnullRefPtr<MediaQuery>>&&);
     virtual ~MediaList() override = default;
 
     String media_text() const;
diff --git a/Libraries/LibWeb/CSS/MediaQueryList.cpp b/Libraries/LibWeb/CSS/MediaQueryList.cpp
index c86b48fd4f7..5236eae49f9 100644
--- a/Libraries/LibWeb/CSS/MediaQueryList.cpp
+++ b/Libraries/LibWeb/CSS/MediaQueryList.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(MediaQueryList);
+GC_DEFINE_ALLOCATOR(MediaQueryList);
 
-JS::NonnullGCPtr<MediaQueryList> MediaQueryList::create(DOM::Document& document, Vector<NonnullRefPtr<MediaQuery>>&& media)
+GC::Ref<MediaQueryList> MediaQueryList::create(DOM::Document& document, Vector<NonnullRefPtr<MediaQuery>>&& media)
 {
     return document.realm().create<MediaQueryList>(document, move(media));
 }
@@ -80,7 +80,7 @@ bool MediaQueryList::evaluate()
 }
 
 // https://www.w3.org/TR/cssom-view/#dom-mediaquerylist-addlistener
-void MediaQueryList::add_listener(JS::GCPtr<DOM::IDLEventListener> listener)
+void MediaQueryList::add_listener(GC::Ptr<DOM::IDLEventListener> listener)
 {
     // 1. If listener is null, terminate these steps.
     if (!listener)
@@ -94,7 +94,7 @@ void MediaQueryList::add_listener(JS::GCPtr<DOM::IDLEventListener> listener)
 }
 
 // https://www.w3.org/TR/cssom-view/#dom-mediaquerylist-removelistener
-void MediaQueryList::remove_listener(JS::GCPtr<DOM::IDLEventListener> listener)
+void MediaQueryList::remove_listener(GC::Ptr<DOM::IDLEventListener> listener)
 {
     // 1. Remove an event listener from the associated list of event listeners, whose type is change, callback is listener, and capture is false.
     // NOTE: While the spec doesn't technically use remove_event_listener and instead manipulates the list directly, every major engine uses remove_event_listener.
diff --git a/Libraries/LibWeb/CSS/MediaQueryList.h b/Libraries/LibWeb/CSS/MediaQueryList.h
index 1a6832612d6..546de78e34e 100644
--- a/Libraries/LibWeb/CSS/MediaQueryList.h
+++ b/Libraries/LibWeb/CSS/MediaQueryList.h
@@ -15,10 +15,10 @@ namespace Web::CSS {
 // 4.2. The MediaQueryList Interface, https://drafts.csswg.org/cssom-view/#the-mediaquerylist-interface
 class MediaQueryList final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(MediaQueryList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(MediaQueryList);
+    GC_DECLARE_ALLOCATOR(MediaQueryList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MediaQueryList> create(DOM::Document&, Vector<NonnullRefPtr<MediaQuery>>&&);
+    [[nodiscard]] static GC::Ref<MediaQueryList> create(DOM::Document&, Vector<NonnullRefPtr<MediaQuery>>&&);
 
     virtual ~MediaQueryList() override = default;
 
@@ -26,8 +26,8 @@ public:
     bool matches() const;
     bool evaluate();
 
-    void add_listener(JS::GCPtr<DOM::IDLEventListener>);
-    void remove_listener(JS::GCPtr<DOM::IDLEventListener>);
+    void add_listener(GC::Ptr<DOM::IDLEventListener>);
+    void remove_listener(GC::Ptr<DOM::IDLEventListener>);
 
     void set_onchange(WebIDL::CallbackType*);
     WebIDL::CallbackType* onchange();
@@ -38,7 +38,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
+    GC::Ref<DOM::Document> m_document;
     Vector<NonnullRefPtr<MediaQuery>> m_media;
 };
 
diff --git a/Libraries/LibWeb/CSS/MediaQueryListEvent.cpp b/Libraries/LibWeb/CSS/MediaQueryListEvent.cpp
index 65fc1b4e595..8ccaea8b482 100644
--- a/Libraries/LibWeb/CSS/MediaQueryListEvent.cpp
+++ b/Libraries/LibWeb/CSS/MediaQueryListEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(MediaQueryListEvent);
+GC_DEFINE_ALLOCATOR(MediaQueryListEvent);
 
-JS::NonnullGCPtr<MediaQueryListEvent> MediaQueryListEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MediaQueryListEventInit const& event_init)
+GC::Ref<MediaQueryListEvent> MediaQueryListEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MediaQueryListEventInit const& event_init)
 {
     return realm.create<MediaQueryListEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/CSS/MediaQueryListEvent.h b/Libraries/LibWeb/CSS/MediaQueryListEvent.h
index 0898a62d2cf..c6931dc9182 100644
--- a/Libraries/LibWeb/CSS/MediaQueryListEvent.h
+++ b/Libraries/LibWeb/CSS/MediaQueryListEvent.h
@@ -18,10 +18,10 @@ struct MediaQueryListEventInit : public DOM::EventInit {
 
 class MediaQueryListEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(MediaQueryListEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(MediaQueryListEvent);
+    GC_DECLARE_ALLOCATOR(MediaQueryListEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MediaQueryListEvent> construct_impl(JS::Realm&, FlyString const& event_name, MediaQueryListEventInit const& = {});
+    [[nodiscard]] static GC::Ref<MediaQueryListEvent> construct_impl(JS::Realm&, FlyString const& event_name, MediaQueryListEventInit const& = {});
 
     virtual ~MediaQueryListEvent() override;
 
diff --git a/Libraries/LibWeb/CSS/Parser/MediaParsing.cpp b/Libraries/LibWeb/CSS/Parser/MediaParsing.cpp
index 8492fba460f..9fe3a1f436d 100644
--- a/Libraries/LibWeb/CSS/Parser/MediaParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/MediaParsing.cpp
@@ -621,13 +621,13 @@ Optional<MediaFeatureValue> Parser::parse_media_feature_value(MediaFeatureID med
     return {};
 }
 
-JS::GCPtr<CSSMediaRule> Parser::convert_to_media_rule(AtRule const& rule, Nested nested)
+GC::Ptr<CSSMediaRule> Parser::convert_to_media_rule(AtRule const& rule, Nested nested)
 {
     auto media_query_tokens = TokenStream { rule.prelude };
     auto media_query_list = parse_a_media_query_list(media_query_tokens);
     auto media_list = MediaList::create(m_context.realm(), move(media_query_list));
 
-    JS::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
+    GC::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
     for (auto const& child : rule.child_rules_and_lists_of_declarations) {
         child.visit(
             [&](Rule const& rule) {
diff --git a/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Libraries/LibWeb/CSS/Parser/Parser.cpp
index 9e34ce28264..a48ff4ba385 100644
--- a/Libraries/LibWeb/CSS/Parser/Parser.cpp
+++ b/Libraries/LibWeb/CSS/Parser/Parser.cpp
@@ -156,7 +156,7 @@ CSSStyleSheet* Parser::parse_as_css_stylesheet(Optional<URL::URL> location)
     auto const& style_sheet = parse_a_stylesheet(m_token_stream, {});
 
     // Interpret all of the resulting top-level qualified rules as style rules, defined below.
-    JS::MarkedVector<CSSRule*> rules(m_context.realm().heap());
+    GC::MarkedVector<CSSRule*> rules(m_context.realm().heap());
     for (auto const& raw_rule : style_sheet.rules) {
         auto rule = convert_to_rule(raw_rule, Nested::No);
         // If any style rule is invalid, or any at-rule is not recognized or is invalid according to its grammar or context, it’s a parse error.
diff --git a/Libraries/LibWeb/CSS/Parser/Parser.h b/Libraries/LibWeb/CSS/Parser/Parser.h
index 6ae11125636..dd8476c68ad 100644
--- a/Libraries/LibWeb/CSS/Parser/Parser.h
+++ b/Libraries/LibWeb/CSS/Parser/Parser.h
@@ -178,16 +178,16 @@ private:
     bool is_valid_in_the_current_context(Declaration const&) const;
     bool is_valid_in_the_current_context(AtRule const&) const;
     bool is_valid_in_the_current_context(QualifiedRule const&) const;
-    JS::GCPtr<CSSRule> convert_to_rule(Rule const&, Nested);
-    JS::GCPtr<CSSStyleRule> convert_to_style_rule(QualifiedRule const&, Nested);
-    JS::GCPtr<CSSFontFaceRule> convert_to_font_face_rule(AtRule const&);
-    JS::GCPtr<CSSKeyframesRule> convert_to_keyframes_rule(AtRule const&);
-    JS::GCPtr<CSSImportRule> convert_to_import_rule(AtRule const&);
-    JS::GCPtr<CSSRule> convert_to_layer_rule(AtRule const&, Nested);
-    JS::GCPtr<CSSMediaRule> convert_to_media_rule(AtRule const&, Nested);
-    JS::GCPtr<CSSNamespaceRule> convert_to_namespace_rule(AtRule const&);
-    JS::GCPtr<CSSSupportsRule> convert_to_supports_rule(AtRule const&, Nested);
-    JS::GCPtr<CSSPropertyRule> convert_to_property_rule(AtRule const& rule);
+    GC::Ptr<CSSRule> convert_to_rule(Rule const&, Nested);
+    GC::Ptr<CSSStyleRule> convert_to_style_rule(QualifiedRule const&, Nested);
+    GC::Ptr<CSSFontFaceRule> convert_to_font_face_rule(AtRule const&);
+    GC::Ptr<CSSKeyframesRule> convert_to_keyframes_rule(AtRule const&);
+    GC::Ptr<CSSImportRule> convert_to_import_rule(AtRule const&);
+    GC::Ptr<CSSRule> convert_to_layer_rule(AtRule const&, Nested);
+    GC::Ptr<CSSMediaRule> convert_to_media_rule(AtRule const&, Nested);
+    GC::Ptr<CSSNamespaceRule> convert_to_namespace_rule(AtRule const&);
+    GC::Ptr<CSSSupportsRule> convert_to_supports_rule(AtRule const&, Nested);
+    GC::Ptr<CSSPropertyRule> convert_to_property_rule(AtRule const& rule);
 
     PropertyOwningCSSStyleDeclaration* convert_to_style_declaration(Vector<Declaration> const&);
     Optional<StyleProperty> convert_to_style_property(Declaration const&);
diff --git a/Libraries/LibWeb/CSS/Parser/ParsingContext.h b/Libraries/LibWeb/CSS/Parser/ParsingContext.h
index d2c6b90c1b6..ea8aeaa2954 100644
--- a/Libraries/LibWeb/CSS/Parser/ParsingContext.h
+++ b/Libraries/LibWeb/CSS/Parser/ParsingContext.h
@@ -39,8 +39,8 @@ public:
     JS::Realm& realm() const { return m_realm; }
 
 private:
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::GCPtr<DOM::Document const> m_document;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ptr<DOM::Document const> m_document;
     PropertyID m_current_property_id { PropertyID::Invalid };
     URL::URL m_url;
     Mode m_mode { Mode::Normal };
diff --git a/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp b/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
index dc9f4dcdfd5..0c96483afab 100644
--- a/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
+++ b/Libraries/LibWeb/CSS/Parser/RuleParsing.cpp
@@ -35,10 +35,10 @@
 
 namespace Web::CSS::Parser {
 
-JS::GCPtr<CSSRule> Parser::convert_to_rule(Rule const& rule, Nested nested)
+GC::Ptr<CSSRule> Parser::convert_to_rule(Rule const& rule, Nested nested)
 {
     return rule.visit(
-        [this, nested](AtRule const& at_rule) -> JS::GCPtr<CSSRule> {
+        [this, nested](AtRule const& at_rule) -> GC::Ptr<CSSRule> {
             if (has_ignored_vendor_prefix(at_rule.name))
                 return {};
 
@@ -70,12 +70,12 @@ JS::GCPtr<CSSRule> Parser::convert_to_rule(Rule const& rule, Nested nested)
             dbgln_if(CSS_PARSER_DEBUG, "Unrecognized CSS at-rule: @{}", at_rule.name);
             return {};
         },
-        [this, nested](QualifiedRule const& qualified_rule) -> JS::GCPtr<CSSRule> {
+        [this, nested](QualifiedRule const& qualified_rule) -> GC::Ptr<CSSRule> {
             return convert_to_style_rule(qualified_rule, nested);
         });
 }
 
-JS::GCPtr<CSSStyleRule> Parser::convert_to_style_rule(QualifiedRule const& qualified_rule, Nested nested)
+GC::Ptr<CSSStyleRule> Parser::convert_to_style_rule(QualifiedRule const& qualified_rule, Nested nested)
 {
     TokenStream prelude_stream { qualified_rule.prelude };
 
@@ -107,7 +107,7 @@ JS::GCPtr<CSSStyleRule> Parser::convert_to_style_rule(QualifiedRule const& quali
         return {};
     }
 
-    JS::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
+    GC::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
     for (auto& child : qualified_rule.child_rules) {
         child.visit(
             [&](Rule const& rule) {
@@ -135,7 +135,7 @@ JS::GCPtr<CSSStyleRule> Parser::convert_to_style_rule(QualifiedRule const& quali
     return CSSStyleRule::create(m_context.realm(), move(selectors), *declaration, *nested_rules);
 }
 
-JS::GCPtr<CSSImportRule> Parser::convert_to_import_rule(AtRule const& rule)
+GC::Ptr<CSSImportRule> Parser::convert_to_import_rule(AtRule const& rule)
 {
     // https://drafts.csswg.org/css-cascade-5/#at-import
     // @import [ <url> | <string> ]
@@ -220,7 +220,7 @@ Optional<FlyString> Parser::parse_layer_name(TokenStream<ComponentValue>& tokens
     return builder.to_fly_string_without_validation();
 }
 
-JS::GCPtr<CSSRule> Parser::convert_to_layer_rule(AtRule const& rule, Nested nested)
+GC::Ptr<CSSRule> Parser::convert_to_layer_rule(AtRule const& rule, Nested nested)
 {
     // https://drafts.csswg.org/css-cascade-5/#at-layer
     if (!rule.child_rules_and_lists_of_declarations.is_empty()) {
@@ -246,7 +246,7 @@ JS::GCPtr<CSSRule> Parser::convert_to_layer_rule(AtRule const& rule, Nested nest
         }
 
         // Then the rules
-        JS::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
+        GC::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
         for (auto const& child : rule.child_rules_and_lists_of_declarations) {
             child.visit(
                 [&](Rule const& rule) {
@@ -298,7 +298,7 @@ JS::GCPtr<CSSRule> Parser::convert_to_layer_rule(AtRule const& rule, Nested nest
     return CSSLayerStatementRule::create(m_context.realm(), move(layer_names));
 }
 
-JS::GCPtr<CSSKeyframesRule> Parser::convert_to_keyframes_rule(AtRule const& rule)
+GC::Ptr<CSSKeyframesRule> Parser::convert_to_keyframes_rule(AtRule const& rule)
 {
     // https://drafts.csswg.org/css-animations/#keyframes
     // @keyframes = @keyframes <keyframes-name> { <qualified-rule-list> }
@@ -341,7 +341,7 @@ JS::GCPtr<CSSKeyframesRule> Parser::convert_to_keyframes_rule(AtRule const& rule
 
     auto name = name_token.to_string();
 
-    JS::MarkedVector<CSSRule*> keyframes(m_context.realm().heap());
+    GC::MarkedVector<CSSRule*> keyframes(m_context.realm().heap());
     rule.for_each_as_qualified_rule_list([&](auto& qualified_rule) {
         if (!qualified_rule.child_rules.is_empty()) {
             dbgln_if(CSS_PARSER_DEBUG, "CSSParser: @keyframes keyframe rule contains at-rules; discarding them.");
@@ -399,7 +399,7 @@ JS::GCPtr<CSSKeyframesRule> Parser::convert_to_keyframes_rule(AtRule const& rule
     return CSSKeyframesRule::create(m_context.realm(), name, CSSRuleList::create(m_context.realm(), move(keyframes)));
 }
 
-JS::GCPtr<CSSNamespaceRule> Parser::convert_to_namespace_rule(AtRule const& rule)
+GC::Ptr<CSSNamespaceRule> Parser::convert_to_namespace_rule(AtRule const& rule)
 {
     // https://drafts.csswg.org/css-namespaces/#syntax
     // @namespace <namespace-prefix>? [ <string> | <url> ] ;
@@ -446,7 +446,7 @@ JS::GCPtr<CSSNamespaceRule> Parser::convert_to_namespace_rule(AtRule const& rule
     return CSSNamespaceRule::create(m_context.realm(), prefix, namespace_uri);
 }
 
-JS::GCPtr<CSSSupportsRule> Parser::convert_to_supports_rule(AtRule const& rule, Nested nested)
+GC::Ptr<CSSSupportsRule> Parser::convert_to_supports_rule(AtRule const& rule, Nested nested)
 {
     // https://drafts.csswg.org/css-conditional-3/#at-supports
     // @supports <supports-condition> {
@@ -468,7 +468,7 @@ JS::GCPtr<CSSSupportsRule> Parser::convert_to_supports_rule(AtRule const& rule,
         return {};
     }
 
-    JS::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
+    GC::MarkedVector<CSSRule*> child_rules { m_context.realm().heap() };
     for (auto const& child : rule.child_rules_and_lists_of_declarations) {
         child.visit(
             [&](Rule const& rule) {
@@ -489,7 +489,7 @@ JS::GCPtr<CSSSupportsRule> Parser::convert_to_supports_rule(AtRule const& rule,
     return CSSSupportsRule::create(m_context.realm(), supports.release_nonnull(), rule_list);
 }
 
-JS::GCPtr<CSSPropertyRule> Parser::convert_to_property_rule(AtRule const& rule)
+GC::Ptr<CSSPropertyRule> Parser::convert_to_property_rule(AtRule const& rule)
 {
     // https://drafts.css-houdini.org/css-properties-values-api-1/#at-ruledef-property
     // @property <custom-property-name> {
@@ -586,7 +586,7 @@ JS::GCPtr<CSSPropertyRule> Parser::convert_to_property_rule(AtRule const& rule)
     return {};
 }
 
-JS::GCPtr<CSSFontFaceRule> Parser::convert_to_font_face_rule(AtRule const& rule)
+GC::Ptr<CSSFontFaceRule> Parser::convert_to_font_face_rule(AtRule const& rule)
 {
     // https://drafts.csswg.org/css-fonts/#font-face-rule
 
diff --git a/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.cpp b/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.cpp
index 0a47b40702d..ac95dc85adf 100644
--- a/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.cpp
+++ b/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.cpp
@@ -43,9 +43,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(ResolvedCSSStyleDeclaration);
+GC_DEFINE_ALLOCATOR(ResolvedCSSStyleDeclaration);
 
-JS::NonnullGCPtr<ResolvedCSSStyleDeclaration> ResolvedCSSStyleDeclaration::create(DOM::Element& element, Optional<Selector::PseudoElement::Type> pseudo_element)
+GC::Ref<ResolvedCSSStyleDeclaration> ResolvedCSSStyleDeclaration::create(DOM::Element& element, Optional<Selector::PseudoElement::Type> pseudo_element)
 {
     return element.realm().create<ResolvedCSSStyleDeclaration>(element, move(pseudo_element));
 }
diff --git a/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.h b/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.h
index 89bba8f05e3..9a663016ed7 100644
--- a/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.h
+++ b/Libraries/LibWeb/CSS/ResolvedCSSStyleDeclaration.h
@@ -13,10 +13,10 @@ namespace Web::CSS {
 
 class ResolvedCSSStyleDeclaration final : public CSSStyleDeclaration {
     WEB_PLATFORM_OBJECT(ResolvedCSSStyleDeclaration, CSSStyleDeclaration);
-    JS_DECLARE_ALLOCATOR(ResolvedCSSStyleDeclaration);
+    GC_DECLARE_ALLOCATOR(ResolvedCSSStyleDeclaration);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ResolvedCSSStyleDeclaration> create(DOM::Element&, Optional<Selector::PseudoElement::Type> = {});
+    [[nodiscard]] static GC::Ref<ResolvedCSSStyleDeclaration> create(DOM::Element&, Optional<Selector::PseudoElement::Type> = {});
 
     virtual ~ResolvedCSSStyleDeclaration() override = default;
 
@@ -39,7 +39,7 @@ private:
 
     RefPtr<CSSStyleValue const> style_value_for_property(Layout::NodeWithStyle const&, PropertyID) const;
 
-    JS::NonnullGCPtr<DOM::Element> m_element;
+    GC::Ref<DOM::Element> m_element;
     Optional<CSS::Selector::PseudoElement::Type> m_pseudo_element;
 };
 
diff --git a/Libraries/LibWeb/CSS/Screen.cpp b/Libraries/LibWeb/CSS/Screen.cpp
index b17955fb312..42407cac48f 100644
--- a/Libraries/LibWeb/CSS/Screen.cpp
+++ b/Libraries/LibWeb/CSS/Screen.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(Screen);
+GC_DEFINE_ALLOCATOR(Screen);
 
-JS::NonnullGCPtr<Screen> Screen::create(HTML::Window& window)
+GC::Ref<Screen> Screen::create(HTML::Window& window)
 {
     return window.realm().create<Screen>(window);
 }
@@ -51,7 +51,7 @@ Gfx::IntRect Screen::screen_rect() const
     };
 }
 
-JS::NonnullGCPtr<ScreenOrientation> Screen::orientation()
+GC::Ref<ScreenOrientation> Screen::orientation()
 {
     if (!m_orientation)
         m_orientation = ScreenOrientation::create(realm());
@@ -66,13 +66,13 @@ bool Screen::is_extended() const
 }
 
 // https://w3c.github.io/window-management/#dom-screen-onchange
-void Screen::set_onchange(JS::GCPtr<WebIDL::CallbackType> event_handler)
+void Screen::set_onchange(GC::Ptr<WebIDL::CallbackType> event_handler)
 {
     set_event_handler_attribute(HTML::EventNames::change, event_handler);
 }
 
 // https://w3c.github.io/window-management/#dom-screen-onchange
-JS::GCPtr<WebIDL::CallbackType> Screen::onchange()
+GC::Ptr<WebIDL::CallbackType> Screen::onchange()
 {
     return event_handler_attribute(HTML::EventNames::change);
 }
diff --git a/Libraries/LibWeb/CSS/Screen.h b/Libraries/LibWeb/CSS/Screen.h
index 67dd0fb0d49..310c8c194cf 100644
--- a/Libraries/LibWeb/CSS/Screen.h
+++ b/Libraries/LibWeb/CSS/Screen.h
@@ -16,10 +16,10 @@ namespace Web::CSS {
 
 class Screen final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(Screen, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Screen);
+    GC_DECLARE_ALLOCATOR(Screen);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Screen> create(HTML::Window&);
+    [[nodiscard]] static GC::Ref<Screen> create(HTML::Window&);
 
     i32 width() const { return screen_rect().width(); }
     i32 height() const { return screen_rect().height(); }
@@ -27,12 +27,12 @@ public:
     i32 avail_height() const { return screen_rect().height(); }
     u32 color_depth() const { return 24; }
     u32 pixel_depth() const { return 24; }
-    JS::NonnullGCPtr<ScreenOrientation> orientation();
+    GC::Ref<ScreenOrientation> orientation();
 
     bool is_extended() const;
 
-    void set_onchange(JS::GCPtr<WebIDL::CallbackType> event_handler);
-    JS::GCPtr<WebIDL::CallbackType> onchange();
+    void set_onchange(GC::Ptr<WebIDL::CallbackType> event_handler);
+    GC::Ptr<WebIDL::CallbackType> onchange();
 
 private:
     explicit Screen(HTML::Window&);
@@ -44,8 +44,8 @@ private:
 
     Gfx::IntRect screen_rect() const;
 
-    JS::NonnullGCPtr<HTML::Window> m_window;
-    JS::GCPtr<ScreenOrientation> m_orientation;
+    GC::Ref<HTML::Window> m_window;
+    GC::Ptr<ScreenOrientation> m_orientation;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/ScreenOrientation.cpp b/Libraries/LibWeb/CSS/ScreenOrientation.cpp
index 8c37fcff355..995e37edd7f 100644
--- a/Libraries/LibWeb/CSS/ScreenOrientation.cpp
+++ b/Libraries/LibWeb/CSS/ScreenOrientation.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(ScreenOrientation);
+GC_DEFINE_ALLOCATOR(ScreenOrientation);
 
 ScreenOrientation::ScreenOrientation(JS::Realm& realm)
     : DOM::EventTarget(realm)
@@ -24,13 +24,13 @@ void ScreenOrientation::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(ScreenOrientation);
 }
 
-JS::NonnullGCPtr<ScreenOrientation> ScreenOrientation::create(JS::Realm& realm)
+GC::Ref<ScreenOrientation> ScreenOrientation::create(JS::Realm& realm)
 {
     return realm.create<ScreenOrientation>(realm);
 }
 
 // https://w3c.github.io/screen-orientation/#lock-method
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> ScreenOrientation::lock(Bindings::OrientationLockType)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> ScreenOrientation::lock(Bindings::OrientationLockType)
 {
     return WebIDL::NotSupportedError::create(realm(), "FIXME: ScreenOrientation::lock() is not implemented"_string);
 }
@@ -56,13 +56,13 @@ WebIDL::UnsignedShort ScreenOrientation::angle() const
 }
 
 // https://w3c.github.io/screen-orientation/#onchange-event-handler-attribute
-void ScreenOrientation::set_onchange(JS::GCPtr<WebIDL::CallbackType> event_handler)
+void ScreenOrientation::set_onchange(GC::Ptr<WebIDL::CallbackType> event_handler)
 {
     set_event_handler_attribute(HTML::EventNames::change, event_handler);
 }
 
 // https://w3c.github.io/screen-orientation/#onchange-event-handler-attribute
-JS::GCPtr<WebIDL::CallbackType> ScreenOrientation::onchange()
+GC::Ptr<WebIDL::CallbackType> ScreenOrientation::onchange()
 {
     return event_handler_attribute(HTML::EventNames::change);
 }
diff --git a/Libraries/LibWeb/CSS/ScreenOrientation.h b/Libraries/LibWeb/CSS/ScreenOrientation.h
index 263dfa0365b..4bddf6b4a07 100644
--- a/Libraries/LibWeb/CSS/ScreenOrientation.h
+++ b/Libraries/LibWeb/CSS/ScreenOrientation.h
@@ -15,18 +15,18 @@ namespace Web::CSS {
 
 class ScreenOrientation final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(ScreenOrientation, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(ScreenOrientation);
+    GC_DECLARE_ALLOCATOR(ScreenOrientation);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ScreenOrientation> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<ScreenOrientation> create(JS::Realm&);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> lock(Bindings::OrientationLockType);
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> lock(Bindings::OrientationLockType);
     void unlock();
     Bindings::OrientationType type() const;
     WebIDL::UnsignedShort angle() const;
 
-    void set_onchange(JS::GCPtr<WebIDL::CallbackType>);
-    JS::GCPtr<WebIDL::CallbackType> onchange();
+    void set_onchange(GC::Ptr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> onchange();
 
 private:
     explicit ScreenOrientation(JS::Realm&);
diff --git a/Libraries/LibWeb/CSS/SelectorEngine.cpp b/Libraries/LibWeb/CSS/SelectorEngine.cpp
index 1a9f3b30849..cda81207f42 100644
--- a/Libraries/LibWeb/CSS/SelectorEngine.cpp
+++ b/Libraries/LibWeb/CSS/SelectorEngine.cpp
@@ -35,12 +35,12 @@
 
 namespace Web::SelectorEngine {
 
-static inline bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, int component_list_index, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, JS::GCPtr<DOM::ParentNode const> scope, SelectorKind selector_kind, JS::GCPtr<DOM::Element const> anchor = nullptr);
+static inline bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, int component_list_index, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, GC::Ptr<DOM::ParentNode const> scope, SelectorKind selector_kind, GC::Ptr<DOM::Element const> anchor = nullptr);
 
 // Upward traversal for descendant (' ') and immediate child combinator ('>')
 // If we're starting inside a shadow tree, traversal stops at the nearest shadow host.
 // This is an implementation detail of the :host selector. Otherwise we would just traverse up to the document root.
-static inline JS::GCPtr<DOM::Node const> traverse_up(JS::GCPtr<DOM::Node const> node, JS::GCPtr<DOM::Element const> shadow_host)
+static inline GC::Ptr<DOM::Node const> traverse_up(GC::Ptr<DOM::Node const> node, GC::Ptr<DOM::Element const> shadow_host)
 {
     if (!node)
         return nullptr;
@@ -80,7 +80,7 @@ static inline bool matches_lang_pseudo_class(DOM::Element const& element, Vector
 }
 
 // https://drafts.csswg.org/selectors-4/#relational
-static inline bool matches_relative_selector(CSS::Selector const& selector, size_t compound_index, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, JS::NonnullGCPtr<DOM::Element const> anchor)
+static inline bool matches_relative_selector(CSS::Selector const& selector, size_t compound_index, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, GC::Ref<DOM::Element const> anchor)
 {
     if (compound_index >= selector.compound_selectors().size())
         return matches(selector, style_sheet_for_rule, element, shadow_host, {}, {}, SelectorKind::Relative, anchor);
@@ -143,7 +143,7 @@ static inline bool matches_relative_selector(CSS::Selector const& selector, size
 }
 
 // https://drafts.csswg.org/selectors-4/#relational
-static inline bool matches_has_pseudo_class(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& anchor, JS::GCPtr<DOM::Element const> shadow_host)
+static inline bool matches_has_pseudo_class(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& anchor, GC::Ptr<DOM::Element const> shadow_host)
 {
     return matches_relative_selector(selector, 0, style_sheet_for_rule, anchor, shadow_host, anchor);
 }
@@ -381,7 +381,7 @@ static bool matches_open_state_pseudo_class(DOM::Element const& element, bool op
 }
 
 // https://drafts.csswg.org/css-scoping/#host-selector
-static inline bool matches_host_pseudo_class(JS::NonnullGCPtr<DOM::Element const> element, JS::GCPtr<DOM::Element const> shadow_host, CSS::SelectorList const& argument_selector_list, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule)
+static inline bool matches_host_pseudo_class(GC::Ref<DOM::Element const> element, GC::Ptr<DOM::Element const> shadow_host, CSS::SelectorList const& argument_selector_list, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule)
 {
     // When evaluated in the context of a shadow tree, it matches the shadow tree’s shadow host if the shadow host,
     // in its normal context, matches the selector argument. In any other context, it matches nothing.
@@ -395,7 +395,7 @@ static inline bool matches_host_pseudo_class(JS::NonnullGCPtr<DOM::Element const
     return true;
 }
 
-static inline bool matches_pseudo_class(CSS::Selector::SimpleSelector::PseudoClassSelector const& pseudo_class, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, JS::GCPtr<DOM::ParentNode const> scope, SelectorKind selector_kind)
+static inline bool matches_pseudo_class(CSS::Selector::SimpleSelector::PseudoClassSelector const& pseudo_class, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, GC::Ptr<DOM::ParentNode const> scope, SelectorKind selector_kind)
 {
     switch (pseudo_class.type) {
     case CSS::PseudoClass::Link:
@@ -724,7 +724,7 @@ static ALWAYS_INLINE bool matches_namespace(
     VERIFY_NOT_REACHED();
 }
 
-static inline bool matches(CSS::Selector::SimpleSelector const& component, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, JS::GCPtr<DOM::ParentNode const> scope, SelectorKind selector_kind, [[maybe_unused]] JS::GCPtr<DOM::Element const> anchor)
+static inline bool matches(CSS::Selector::SimpleSelector const& component, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, GC::Ptr<DOM::ParentNode const> scope, SelectorKind selector_kind, [[maybe_unused]] GC::Ptr<DOM::Element const> anchor)
 {
     switch (component.type) {
     case CSS::Selector::SimpleSelector::Type::Universal:
@@ -771,7 +771,7 @@ static inline bool matches(CSS::Selector::SimpleSelector const& component, Optio
     VERIFY_NOT_REACHED();
 }
 
-bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, int component_list_index, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, JS::GCPtr<DOM::ParentNode const> scope, SelectorKind selector_kind, JS::GCPtr<DOM::Element const> anchor)
+bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, int component_list_index, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, GC::Ptr<DOM::ParentNode const> scope, SelectorKind selector_kind, GC::Ptr<DOM::Element const> anchor)
 {
     auto& compound_selector = selector.compound_selectors()[component_list_index];
     for (auto& simple_selector : compound_selector.simple_selectors) {
@@ -825,7 +825,7 @@ bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&>
     VERIFY_NOT_REACHED();
 }
 
-bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host, Optional<CSS::Selector::PseudoElement::Type> pseudo_element, JS::GCPtr<DOM::ParentNode const> scope, SelectorKind selector_kind, JS::GCPtr<DOM::Element const> anchor)
+bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host, Optional<CSS::Selector::PseudoElement::Type> pseudo_element, GC::Ptr<DOM::ParentNode const> scope, SelectorKind selector_kind, GC::Ptr<DOM::Element const> anchor)
 {
     VERIFY(!selector.compound_selectors().is_empty());
     if (pseudo_element.has_value() && selector.pseudo_element().has_value() && selector.pseudo_element().value().type() != pseudo_element)
@@ -835,7 +835,7 @@ bool matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&>
     return matches(selector, style_sheet_for_rule, selector.compound_selectors().size() - 1, element, shadow_host, scope, selector_kind, anchor);
 }
 
-static bool fast_matches_simple_selector(CSS::Selector::SimpleSelector const& simple_selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host)
+static bool fast_matches_simple_selector(CSS::Selector::SimpleSelector const& simple_selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host)
 {
     switch (simple_selector.type) {
     case CSS::Selector::SimpleSelector::Type::Universal:
@@ -865,7 +865,7 @@ static bool fast_matches_simple_selector(CSS::Selector::SimpleSelector const& si
     }
 }
 
-static bool fast_matches_compound_selector(CSS::Selector::CompoundSelector const& compound_selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, JS::GCPtr<DOM::Element const> shadow_host)
+static bool fast_matches_compound_selector(CSS::Selector::CompoundSelector const& compound_selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element, GC::Ptr<DOM::Element const> shadow_host)
 {
     for (auto const& simple_selector : compound_selector.simple_selectors) {
         if (!fast_matches_simple_selector(simple_selector, style_sheet_for_rule, element, shadow_host))
@@ -874,7 +874,7 @@ static bool fast_matches_compound_selector(CSS::Selector::CompoundSelector const
     return true;
 }
 
-bool fast_matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element_to_match, JS::GCPtr<DOM::Element const> shadow_host)
+bool fast_matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const& element_to_match, GC::Ptr<DOM::Element const> shadow_host)
 {
     DOM::Element const* current = &element_to_match;
 
@@ -886,7 +886,7 @@ bool fast_matches(CSS::Selector const& selector, Optional<CSS::CSSStyleSheet con
     // NOTE: If we fail after following a child combinator, we may need to backtrack
     //       to the last matched descendant. We store the state here.
     struct {
-        JS::GCPtr<DOM::Element const> element;
+        GC::Ptr<DOM::Element const> element;
         ssize_t compound_selector_index = 0;
     } backtrack_state;
 
diff --git a/Libraries/LibWeb/CSS/SelectorEngine.h b/Libraries/LibWeb/CSS/SelectorEngine.h
index a360ee4fdda..8af55792689 100644
--- a/Libraries/LibWeb/CSS/SelectorEngine.h
+++ b/Libraries/LibWeb/CSS/SelectorEngine.h
@@ -16,9 +16,9 @@ enum class SelectorKind {
     Relative,
 };
 
-bool matches(CSS::Selector const&, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const&, JS::GCPtr<DOM::Element const> shadow_host, Optional<CSS::Selector::PseudoElement::Type> = {}, JS::GCPtr<DOM::ParentNode const> scope = {}, SelectorKind selector_kind = SelectorKind::Normal, JS::GCPtr<DOM::Element const> anchor = nullptr);
+bool matches(CSS::Selector const&, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const&, GC::Ptr<DOM::Element const> shadow_host, Optional<CSS::Selector::PseudoElement::Type> = {}, GC::Ptr<DOM::ParentNode const> scope = {}, SelectorKind selector_kind = SelectorKind::Normal, GC::Ptr<DOM::Element const> anchor = nullptr);
 
-[[nodiscard]] bool fast_matches(CSS::Selector const&, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const&, JS::GCPtr<DOM::Element const> shadow_host);
+[[nodiscard]] bool fast_matches(CSS::Selector const&, Optional<CSS::CSSStyleSheet const&> style_sheet_for_rule, DOM::Element const&, GC::Ptr<DOM::Element const> shadow_host);
 [[nodiscard]] bool can_use_fast_matches(CSS::Selector const&);
 
 [[nodiscard]] bool matches_hover_pseudo_class(DOM::Element const&);
diff --git a/Libraries/LibWeb/CSS/StyleComputer.cpp b/Libraries/LibWeb/CSS/StyleComputer.cpp
index 96c18a12d66..68e20e1c2f0 100644
--- a/Libraries/LibWeb/CSS/StyleComputer.cpp
+++ b/Libraries/LibWeb/CSS/StyleComputer.cpp
@@ -257,40 +257,40 @@ struct StyleComputer::MatchingFontCandidate {
 
 static CSSStyleSheet& default_stylesheet(DOM::Document const& document)
 {
-    static JS::Handle<CSSStyleSheet> sheet;
+    static GC::Root<CSSStyleSheet> sheet;
     if (!sheet.cell()) {
         extern String default_stylesheet_source;
-        sheet = JS::make_handle(parse_css_stylesheet(CSS::Parser::ParsingContext(document), default_stylesheet_source));
+        sheet = GC::make_root(parse_css_stylesheet(CSS::Parser::ParsingContext(document), default_stylesheet_source));
     }
     return *sheet;
 }
 
 static CSSStyleSheet& quirks_mode_stylesheet(DOM::Document const& document)
 {
-    static JS::Handle<CSSStyleSheet> sheet;
+    static GC::Root<CSSStyleSheet> sheet;
     if (!sheet.cell()) {
         extern String quirks_mode_stylesheet_source;
-        sheet = JS::make_handle(parse_css_stylesheet(CSS::Parser::ParsingContext(document), quirks_mode_stylesheet_source));
+        sheet = GC::make_root(parse_css_stylesheet(CSS::Parser::ParsingContext(document), quirks_mode_stylesheet_source));
     }
     return *sheet;
 }
 
 static CSSStyleSheet& mathml_stylesheet(DOM::Document const& document)
 {
-    static JS::Handle<CSSStyleSheet> sheet;
+    static GC::Root<CSSStyleSheet> sheet;
     if (!sheet.cell()) {
         extern String mathml_stylesheet_source;
-        sheet = JS::make_handle(parse_css_stylesheet(CSS::Parser::ParsingContext(document), mathml_stylesheet_source));
+        sheet = GC::make_root(parse_css_stylesheet(CSS::Parser::ParsingContext(document), mathml_stylesheet_source));
     }
     return *sheet;
 }
 
 static CSSStyleSheet& svg_stylesheet(DOM::Document const& document)
 {
-    static JS::Handle<CSSStyleSheet> sheet;
+    static GC::Root<CSSStyleSheet> sheet;
     if (!sheet.cell()) {
         extern String svg_stylesheet_source;
-        sheet = JS::make_handle(parse_css_stylesheet(CSS::Parser::ParsingContext(document), svg_stylesheet_source));
+        sheet = GC::make_root(parse_css_stylesheet(CSS::Parser::ParsingContext(document), svg_stylesheet_source));
     }
     return *sheet;
 }
@@ -381,7 +381,7 @@ Vector<MatchingRule> StyleComputer::collect_matching_rules(DOM::Element const& e
     auto const& root_node = element.root();
     auto shadow_root = is<DOM::ShadowRoot>(root_node) ? static_cast<DOM::ShadowRoot const*>(&root_node) : nullptr;
 
-    JS::GCPtr<DOM::Element const> shadow_host;
+    GC::Ptr<DOM::Element const> shadow_host;
     if (element.is_shadow_host())
         shadow_host = element;
     else if (shadow_root)
@@ -979,7 +979,7 @@ static void cascade_custom_properties(DOM::Element& element, Optional<CSS::Selec
     }
 }
 
-void StyleComputer::collect_animation_into(DOM::Element& element, Optional<CSS::Selector::PseudoElement::Type> pseudo_element, JS::NonnullGCPtr<Animations::KeyframeEffect> effect, StyleProperties& style_properties, AnimationRefresh refresh) const
+void StyleComputer::collect_animation_into(DOM::Element& element, Optional<CSS::Selector::PseudoElement::Type> pseudo_element, GC::Ref<Animations::KeyframeEffect> effect, StyleProperties& style_properties, AnimationRefresh refresh) const
 {
     auto animation = effect->associated_animation();
     if (!animation)
@@ -2458,7 +2458,7 @@ NonnullOwnPtr<StyleComputer::RuleCache> StyleComputer::make_rule_cache_for_casca
 
     Vector<MatchingRule> matching_rules;
     size_t style_sheet_index = 0;
-    for_each_stylesheet(cascade_origin, [&](auto& sheet, JS::GCPtr<DOM::ShadowRoot> shadow_root) {
+    for_each_stylesheet(cascade_origin, [&](auto& sheet, GC::Ptr<DOM::ShadowRoot> shadow_root) {
         size_t rule_index = 0;
         sheet.for_each_effective_style_producing_rule([&](auto const& rule) {
             size_t selector_index = 0;
@@ -2688,7 +2688,7 @@ void StyleComputer::build_qualified_layer_names_cache()
 
     // Walk all style sheets, identifying when we first see a @layer name, and add its qualified name to the list.
     // TODO: Separate the light and shadow-dom layers.
-    for_each_stylesheet(CascadeOrigin::Author, [&](auto& sheet, JS::GCPtr<DOM::ShadowRoot>) {
+    for_each_stylesheet(CascadeOrigin::Author, [&](auto& sheet, GC::Ptr<DOM::ShadowRoot>) {
         // NOTE: Postorder so that a @layer block is iterated after its children,
         // because we want those children to occur before it in the list.
         sheet.for_each_effective_rule(TraversalOrder::Postorder, [&](auto& rule) {
@@ -2732,7 +2732,7 @@ void StyleComputer::build_qualified_layer_names_cache()
 void StyleComputer::build_rule_cache()
 {
     if (auto user_style_source = document().page().user_style(); user_style_source.has_value()) {
-        m_user_style_sheet = JS::make_handle(parse_css_stylesheet(CSS::Parser::ParsingContext(document()), user_style_source.value()));
+        m_user_style_sheet = GC::make_root(parse_css_stylesheet(CSS::Parser::ParsingContext(document()), user_style_source.value()));
     }
 
     build_qualified_layer_names_cache();
diff --git a/Libraries/LibWeb/CSS/StyleComputer.h b/Libraries/LibWeb/CSS/StyleComputer.h
index fb6226e2abb..b177fa1b762 100644
--- a/Libraries/LibWeb/CSS/StyleComputer.h
+++ b/Libraries/LibWeb/CSS/StyleComputer.h
@@ -81,9 +81,9 @@ enum class CascadeOrigin : u8 {
 };
 
 struct MatchingRule {
-    JS::GCPtr<DOM::ShadowRoot const> shadow_root;
-    JS::GCPtr<CSSRule const> rule; // Either CSSStyleRule or CSSNestedDeclarations
-    JS::GCPtr<CSSStyleSheet const> sheet;
+    GC::Ptr<DOM::ShadowRoot const> shadow_root;
+    GC::Ptr<CSSRule const> rule; // Either CSSStyleRule or CSSNestedDeclarations
+    GC::Ptr<CSSStyleSheet const> sheet;
     size_t style_sheet_index { 0 };
     size_t rule_index { 0 };
     size_t selector_index { 0 };
@@ -160,7 +160,7 @@ public:
         No,
         Yes,
     };
-    void collect_animation_into(DOM::Element&, Optional<CSS::Selector::PseudoElement::Type>, JS::NonnullGCPtr<Animations::KeyframeEffect> animation, StyleProperties& style_properties, AnimationRefresh = AnimationRefresh::No) const;
+    void collect_animation_into(DOM::Element&, Optional<CSS::Selector::PseudoElement::Type>, GC::Ref<Animations::KeyframeEffect> animation, StyleProperties& style_properties, AnimationRefresh = AnimationRefresh::No) const;
 
     [[nodiscard]] bool has_has_selectors() const { return m_has_has_selectors; }
 
@@ -219,7 +219,7 @@ private:
     void build_rule_cache();
     void build_rule_cache_if_needed() const;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
+    GC::Ref<DOM::Document> m_document;
 
     struct RuleCache {
         HashMap<FlyString, Vector<MatchingRule>> rules_by_id;
@@ -243,7 +243,7 @@ private:
     OwnPtr<RuleCache> m_author_rule_cache;
     OwnPtr<RuleCache> m_user_rule_cache;
     OwnPtr<RuleCache> m_user_agent_rule_cache;
-    JS::Handle<CSSStyleSheet> m_user_style_sheet;
+    GC::Root<CSSStyleSheet> m_user_style_sheet;
 
     using FontLoaderList = Vector<NonnullOwnPtr<FontLoader>>;
     HashMap<FontFaceKey, FontLoaderList> m_loaded_fonts;
diff --git a/Libraries/LibWeb/CSS/StyleProperties.h b/Libraries/LibWeb/CSS/StyleProperties.h
index 5b52ef5ca2b..7551757df5f 100644
--- a/Libraries/LibWeb/CSS/StyleProperties.h
+++ b/Libraries/LibWeb/CSS/StyleProperties.h
@@ -8,10 +8,10 @@
 
 #include <AK/HashMap.h>
 #include <AK/NonnullRefPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibGfx/Font/Font.h>
 #include <LibGfx/FontCascadeList.h>
 #include <LibGfx/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/CSS/ComputedValues.h>
 #include <LibWeb/CSS/LengthBox.h>
 #include <LibWeb/CSS/PropertyID.h>
@@ -30,8 +30,8 @@ private:
         NonnullRefPtr<Data> clone() const;
 
         // FIXME: These need protection from GC!
-        JS::GCPtr<CSS::CSSStyleDeclaration const> m_animation_name_source;
-        JS::GCPtr<CSS::CSSStyleDeclaration const> m_transition_property_source;
+        GC::Ptr<CSS::CSSStyleDeclaration const> m_animation_name_source;
+        GC::Ptr<CSS::CSSStyleDeclaration const> m_transition_property_source;
 
         Array<RefPtr<CSSStyleValue const>, number_of_properties> m_property_values;
         Array<u8, ceil_div(number_of_properties, 8uz)> m_property_important {};
@@ -80,11 +80,11 @@ public:
     CSSStyleValue const* maybe_null_property(CSS::PropertyID) const;
     void revert_property(CSS::PropertyID, StyleProperties const& style_for_revert);
 
-    JS::GCPtr<CSS::CSSStyleDeclaration const> animation_name_source() const { return m_data->m_animation_name_source; }
-    void set_animation_name_source(JS::GCPtr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_animation_name_source = declaration; }
+    GC::Ptr<CSS::CSSStyleDeclaration const> animation_name_source() const { return m_data->m_animation_name_source; }
+    void set_animation_name_source(GC::Ptr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_animation_name_source = declaration; }
 
-    JS::GCPtr<CSS::CSSStyleDeclaration const> transition_property_source() const { return m_data->m_transition_property_source; }
-    void set_transition_property_source(JS::GCPtr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_transition_property_source = declaration; }
+    GC::Ptr<CSS::CSSStyleDeclaration const> transition_property_source() const { return m_data->m_transition_property_source; }
+    void set_transition_property_source(GC::Ptr<CSS::CSSStyleDeclaration const> declaration) { m_data->m_transition_property_source = declaration; }
 
     CSS::Size size_value(CSS::PropertyID) const;
     [[nodiscard]] Variant<LengthPercentage, NormalGap> gap_value(CSS::PropertyID) const;
diff --git a/Libraries/LibWeb/CSS/StyleSheet.h b/Libraries/LibWeb/CSS/StyleSheet.h
index cf4b06418ff..f504a8173fb 100644
--- a/Libraries/LibWeb/CSS/StyleSheet.h
+++ b/Libraries/LibWeb/CSS/StyleSheet.h
@@ -60,11 +60,11 @@ protected:
     explicit StyleSheet(JS::Realm&, MediaList& media);
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<MediaList> m_media;
+    GC::Ref<MediaList> m_media;
 
 private:
-    JS::GCPtr<DOM::Element> m_owner_node;
-    JS::GCPtr<CSSStyleSheet> m_parent_style_sheet;
+    GC::Ptr<DOM::Element> m_owner_node;
+    GC::Ptr<CSSStyleSheet> m_parent_style_sheet;
 
     Optional<String> m_location;
     String m_title;
diff --git a/Libraries/LibWeb/CSS/StyleSheetList.cpp b/Libraries/LibWeb/CSS/StyleSheetList.cpp
index c93cc64c1a2..9d76a8c839d 100644
--- a/Libraries/LibWeb/CSS/StyleSheetList.cpp
+++ b/Libraries/LibWeb/CSS/StyleSheetList.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(StyleSheetList);
+GC_DEFINE_ALLOCATOR(StyleSheetList);
 
 // https://www.w3.org/TR/cssom/#remove-a-css-style-sheet
 void StyleSheetList::remove_a_css_style_sheet(CSS::CSSStyleSheet& sheet)
@@ -128,13 +128,13 @@ void StyleSheetList::remove_sheet(CSSStyleSheet& sheet)
     document_or_shadow_root().invalidate_style(DOM::StyleInvalidationReason::StyleSheetListRemoveSheet);
 }
 
-JS::NonnullGCPtr<StyleSheetList> StyleSheetList::create(JS::NonnullGCPtr<DOM::Node> document_or_shadow_root)
+GC::Ref<StyleSheetList> StyleSheetList::create(GC::Ref<DOM::Node> document_or_shadow_root)
 {
     auto& realm = document_or_shadow_root->realm();
     return realm.create<StyleSheetList>(document_or_shadow_root);
 }
 
-StyleSheetList::StyleSheetList(JS::NonnullGCPtr<DOM::Node> document_or_shadow_root)
+StyleSheetList::StyleSheetList(GC::Ref<DOM::Node> document_or_shadow_root)
     : Bindings::PlatformObject(document_or_shadow_root->realm())
     , m_document_or_shadow_root(document_or_shadow_root)
 {
diff --git a/Libraries/LibWeb/CSS/StyleSheetList.h b/Libraries/LibWeb/CSS/StyleSheetList.h
index 76c72b6674e..317a1865a88 100644
--- a/Libraries/LibWeb/CSS/StyleSheetList.h
+++ b/Libraries/LibWeb/CSS/StyleSheetList.h
@@ -14,17 +14,17 @@ namespace Web::CSS {
 
 class StyleSheetList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(StyleSheetList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(StyleSheetList);
+    GC_DECLARE_ALLOCATOR(StyleSheetList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<StyleSheetList> create(JS::NonnullGCPtr<DOM::Node> document_or_shadow_root);
+    [[nodiscard]] static GC::Ref<StyleSheetList> create(GC::Ref<DOM::Node> document_or_shadow_root);
 
     void add_a_css_style_sheet(CSS::CSSStyleSheet&);
     void remove_a_css_style_sheet(CSS::CSSStyleSheet&);
     void create_a_css_style_sheet(String type, DOM::Element* owner_node, String media, String title, bool alternate, bool origin_clean, Optional<String> location, CSS::CSSStyleSheet* parent_style_sheet, CSS::CSSRule* owner_rule, CSS::CSSStyleSheet&);
 
-    Vector<JS::NonnullGCPtr<CSSStyleSheet>> const& sheets() const { return m_sheets; }
-    Vector<JS::NonnullGCPtr<CSSStyleSheet>>& sheets() { return m_sheets; }
+    Vector<GC::Ref<CSSStyleSheet>> const& sheets() const { return m_sheets; }
+    Vector<GC::Ref<CSSStyleSheet>>& sheets() { return m_sheets; }
 
     CSSStyleSheet* item(size_t index) const
     {
@@ -44,7 +44,7 @@ public:
     [[nodiscard]] DOM::Node const& document_or_shadow_root() const { return m_document_or_shadow_root; }
 
 private:
-    explicit StyleSheetList(JS::NonnullGCPtr<DOM::Node> document_or_shadow_root);
+    explicit StyleSheetList(GC::Ref<DOM::Node> document_or_shadow_root);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -52,8 +52,8 @@ private:
     void add_sheet(CSSStyleSheet&);
     void remove_sheet(CSSStyleSheet&);
 
-    JS::NonnullGCPtr<DOM::Node> m_document_or_shadow_root;
-    Vector<JS::NonnullGCPtr<CSSStyleSheet>> m_sheets;
+    GC::Ref<DOM::Node> m_document_or_shadow_root;
+    Vector<GC::Ref<CSSStyleSheet>> m_sheets;
 
     // https://www.w3.org/TR/cssom/#preferred-css-style-sheet-set-name
     String m_preferred_css_style_sheet_set_name;
diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
index 8deffbce2a5..530c1d20f55 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
+++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
@@ -63,7 +63,7 @@ void ImageStyleValue::load_any_resources(DOM::Document& document)
             if (image_data->is_animated() && image_data->frame_count() > 1) {
                 m_timer = Platform::Timer::create(m_document->heap());
                 m_timer->set_interval(image_data->frame_duration(0));
-                m_timer->on_timeout = JS::create_heap_function(m_document->heap(), [this] { animate(); });
+                m_timer->on_timeout = GC::create_function(m_document->heap(), [this] { animate(); });
                 m_timer->start();
             }
         },
@@ -158,7 +158,7 @@ Gfx::ImmutableBitmap const* ImageStyleValue::current_frame_bitmap(DevicePixelRec
     return bitmap(m_current_frame_index, dest_rect.size().to_type<int>());
 }
 
-JS::GCPtr<HTML::DecodedImageData> ImageStyleValue::image_data() const
+GC::Ptr<HTML::DecodedImageData> ImageStyleValue::image_data() const
 {
     if (!m_resource_request)
         return nullptr;
diff --git a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
index 3cbc15bc7f2..0e109c7975c 100644
--- a/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
+++ b/Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
@@ -9,8 +9,8 @@
 
 #pragma once
 
+#include <LibGC/Root.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibURL/URL.h>
 #include <LibWeb/CSS/Enums.h>
 #include <LibWeb/CSS/StyleValues/AbstractImageStyleValue.h>
@@ -47,12 +47,12 @@ public:
 
     Function<void()> on_animate;
 
-    JS::GCPtr<HTML::DecodedImageData> image_data() const;
+    GC::Ptr<HTML::DecodedImageData> image_data() const;
 
 private:
     ImageStyleValue(URL::URL const&);
 
-    JS::GCPtr<HTML::SharedResourceRequest> m_resource_request;
+    GC::Ptr<HTML::SharedResourceRequest> m_resource_request;
 
     void animate();
     Gfx::ImmutableBitmap const* bitmap(size_t frame_index, Gfx::IntSize = {}) const;
@@ -62,7 +62,7 @@ private:
 
     size_t m_current_frame_index { 0 };
     size_t m_loops_completed { 0 };
-    JS::GCPtr<Platform::Timer> m_timer;
+    GC::Ptr<Platform::Timer> m_timer;
 };
 
 }
diff --git a/Libraries/LibWeb/CSS/VisualViewport.cpp b/Libraries/LibWeb/CSS/VisualViewport.cpp
index 47c8947d54e..90217d881a2 100644
--- a/Libraries/LibWeb/CSS/VisualViewport.cpp
+++ b/Libraries/LibWeb/CSS/VisualViewport.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::CSS {
 
-JS_DEFINE_ALLOCATOR(VisualViewport);
+GC_DEFINE_ALLOCATOR(VisualViewport);
 
-JS::NonnullGCPtr<VisualViewport> VisualViewport::create(DOM::Document& document)
+GC::Ref<VisualViewport> VisualViewport::create(DOM::Document& document)
 {
     return document.realm().create<VisualViewport>(document);
 }
diff --git a/Libraries/LibWeb/CSS/VisualViewport.h b/Libraries/LibWeb/CSS/VisualViewport.h
index 9537d4168f8..e45a654fc1f 100644
--- a/Libraries/LibWeb/CSS/VisualViewport.h
+++ b/Libraries/LibWeb/CSS/VisualViewport.h
@@ -13,10 +13,10 @@ namespace Web::CSS {
 // https://drafts.csswg.org/cssom-view/#visualviewport
 class VisualViewport final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(VisualViewport, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(VisualViewport);
+    GC_DECLARE_ALLOCATOR(VisualViewport);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<VisualViewport> create(DOM::Document&);
+    [[nodiscard]] static GC::Ref<VisualViewport> create(DOM::Document&);
 
     virtual ~VisualViewport() override = default;
 
@@ -44,7 +44,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
+    GC::Ref<DOM::Document> m_document;
 };
 
 }
diff --git a/Libraries/LibWeb/Clipboard/Clipboard.cpp b/Libraries/LibWeb/Clipboard/Clipboard.cpp
index fd36aa744aa..44b12ee5c44 100644
--- a/Libraries/LibWeb/Clipboard/Clipboard.cpp
+++ b/Libraries/LibWeb/Clipboard/Clipboard.cpp
@@ -19,9 +19,9 @@
 
 namespace Web::Clipboard {
 
-JS_DEFINE_ALLOCATOR(Clipboard);
+GC_DEFINE_ALLOCATOR(Clipboard);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Clipboard>> Clipboard::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<Clipboard>> Clipboard::construct_impl(JS::Realm& realm)
 {
     return realm.create<Clipboard>(realm);
 }
@@ -84,7 +84,7 @@ static String os_specific_well_known_format(StringView mime_type_string)
 }
 
 // https://w3c.github.io/clipboard-apis/#write-blobs-and-option-to-the-clipboard
-static void write_blobs_and_option_to_clipboard(JS::Realm& realm, ReadonlySpan<JS::NonnullGCPtr<FileAPI::Blob>> items, String presentation_style)
+static void write_blobs_and_option_to_clipboard(JS::Realm& realm, ReadonlySpan<GC::Ref<FileAPI::Blob>> items, String presentation_style)
 {
     auto& window = verify_cast<HTML::Window>(realm.global_object());
 
@@ -141,7 +141,7 @@ static bool check_clipboard_write_permission(JS::Realm& realm)
 }
 
 // https://w3c.github.io/clipboard-apis/#dom-clipboard-writetext
-JS::NonnullGCPtr<WebIDL::Promise> Clipboard::write_text(String data)
+GC::Ref<WebIDL::Promise> Clipboard::write_text(String data)
 {
     // 1. Let realm be this's relevant realm.
     auto& realm = HTML::relevant_realm(*this);
@@ -150,7 +150,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Clipboard::write_text(String data)
     auto promise = WebIDL::create_promise(realm);
 
     // 3. Run the following steps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, promise, data = move(data)]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, promise, data = move(data)]() mutable {
         // 1. Let r be the result of running check clipboard write permission.
         auto result = check_clipboard_write_permission(realm);
 
@@ -158,7 +158,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Clipboard::write_text(String data)
         if (!result) {
             // 1. Queue a global task on the permission task source, given realm’s global object, to reject p with
             //    "NotAllowedError" DOMException in realm.
-            queue_global_task(HTML::Task::Source::Permissions, realm.global_object(), JS::create_heap_function(realm.heap(), [&realm, promise]() mutable {
+            queue_global_task(HTML::Task::Source::Permissions, realm.global_object(), GC::create_function(realm.heap(), [&realm, promise]() mutable {
                 HTML::TemporaryExecutionContext execution_context { realm };
                 WebIDL::reject_promise(realm, promise, WebIDL::NotAllowedError::create(realm, "Clipboard writing is only allowed through user activation"_string));
             }));
@@ -168,9 +168,9 @@ JS::NonnullGCPtr<WebIDL::Promise> Clipboard::write_text(String data)
         }
 
         // 1. Queue a global task on the clipboard task source, given realm’s global object, to perform the below steps:
-        queue_global_task(HTML::Task::Source::Clipboard, realm.global_object(), JS::create_heap_function(realm.heap(), [&realm, promise, data = move(data)]() mutable {
+        queue_global_task(HTML::Task::Source::Clipboard, realm.global_object(), GC::create_function(realm.heap(), [&realm, promise, data = move(data)]() mutable {
             // 1. Let itemList be an empty sequence<Blob>.
-            Vector<JS::NonnullGCPtr<FileAPI::Blob>> item_list;
+            Vector<GC::Ref<FileAPI::Blob>> item_list;
 
             // 2. Let textBlob be a new Blob created with: type attribute set to "text/plain;charset=utf-8", and its
             //    underlying byte sequence set to the UTF-8 encoding of data.
diff --git a/Libraries/LibWeb/Clipboard/Clipboard.h b/Libraries/LibWeb/Clipboard/Clipboard.h
index 4efa1de3ba0..3a9e15eb669 100644
--- a/Libraries/LibWeb/Clipboard/Clipboard.h
+++ b/Libraries/LibWeb/Clipboard/Clipboard.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/String.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
@@ -17,13 +17,13 @@ namespace Web::Clipboard {
 
 class Clipboard final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(Clipboard, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Clipboard);
+    GC_DECLARE_ALLOCATOR(Clipboard);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Clipboard>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<Clipboard>> construct_impl(JS::Realm&);
     virtual ~Clipboard() override;
 
-    JS::NonnullGCPtr<WebIDL::Promise> write_text(String);
+    GC::Ref<WebIDL::Promise> write_text(String);
 
 private:
     Clipboard(JS::Realm&);
diff --git a/Libraries/LibWeb/Clipboard/ClipboardEvent.cpp b/Libraries/LibWeb/Clipboard/ClipboardEvent.cpp
index 73666e92538..98e4ca3665b 100644
--- a/Libraries/LibWeb/Clipboard/ClipboardEvent.cpp
+++ b/Libraries/LibWeb/Clipboard/ClipboardEvent.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::Clipboard {
 
-JS_DEFINE_ALLOCATOR(ClipboardEvent);
+GC_DEFINE_ALLOCATOR(ClipboardEvent);
 
-JS::NonnullGCPtr<ClipboardEvent> ClipboardEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ClipboardEventInit const& event_init)
+GC::Ref<ClipboardEvent> ClipboardEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ClipboardEventInit const& event_init)
 {
     return realm.create<ClipboardEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/Clipboard/ClipboardEvent.h b/Libraries/LibWeb/Clipboard/ClipboardEvent.h
index ca6abc9b787..536a13023e8 100644
--- a/Libraries/LibWeb/Clipboard/ClipboardEvent.h
+++ b/Libraries/LibWeb/Clipboard/ClipboardEvent.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/DOM/Event.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/DataTransfer.h>
@@ -14,20 +14,20 @@
 namespace Web::Clipboard {
 
 struct ClipboardEventInit : public DOM::EventInit {
-    JS::GCPtr<HTML::DataTransfer> clipboard_data;
+    GC::Ptr<HTML::DataTransfer> clipboard_data;
 };
 
 // https://w3c.github.io/clipboard-apis/#clipboardevent
 class ClipboardEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(ClipboardEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(ClipboardEvent);
+    GC_DECLARE_ALLOCATOR(ClipboardEvent);
 
 public:
-    static JS::NonnullGCPtr<ClipboardEvent> construct_impl(JS::Realm&, FlyString const& event_name, ClipboardEventInit const& event_init);
+    static GC::Ref<ClipboardEvent> construct_impl(JS::Realm&, FlyString const& event_name, ClipboardEventInit const& event_init);
 
     virtual ~ClipboardEvent() override;
 
-    JS::GCPtr<HTML::DataTransfer> clipboard_data() { return m_clipboard_data; }
+    GC::Ptr<HTML::DataTransfer> clipboard_data() { return m_clipboard_data; }
 
 private:
     ClipboardEvent(JS::Realm&, FlyString const& event_name, ClipboardEventInit const& event_init);
@@ -35,7 +35,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::GCPtr<HTML::DataTransfer> m_clipboard_data;
+    GC::Ptr<HTML::DataTransfer> m_clipboard_data;
 };
 
 }
diff --git a/Libraries/LibWeb/Crypto/Crypto.cpp b/Libraries/LibWeb/Crypto/Crypto.cpp
index d7ef9529329..0089b463e9a 100644
--- a/Libraries/LibWeb/Crypto/Crypto.cpp
+++ b/Libraries/LibWeb/Crypto/Crypto.cpp
@@ -17,9 +17,9 @@
 
 namespace Web::Crypto {
 
-JS_DEFINE_ALLOCATOR(Crypto);
+GC_DEFINE_ALLOCATOR(Crypto);
 
-JS::NonnullGCPtr<Crypto> Crypto::create(JS::Realm& realm)
+GC::Ref<Crypto> Crypto::create(JS::Realm& realm)
 {
     return realm.create<Crypto>(realm);
 }
@@ -38,19 +38,19 @@ void Crypto::initialize(JS::Realm& realm)
     m_subtle = SubtleCrypto::create(realm);
 }
 
-JS::NonnullGCPtr<SubtleCrypto> Crypto::subtle() const
+GC::Ref<SubtleCrypto> Crypto::subtle() const
 {
     return *m_subtle;
 }
 
 // https://w3c.github.io/webcrypto/#dfn-Crypto-method-getRandomValues
-WebIDL::ExceptionOr<JS::Handle<WebIDL::ArrayBufferView>> Crypto::get_random_values(JS::Handle<WebIDL::ArrayBufferView> array) const
+WebIDL::ExceptionOr<GC::Root<WebIDL::ArrayBufferView>> Crypto::get_random_values(GC::Root<WebIDL::ArrayBufferView> array) const
 {
     // 1. If array is not an Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array, or BigUint64Array, then throw a TypeMismatchError and terminate the algorithm.
     if (!array->is_typed_array_base())
         return WebIDL::TypeMismatchError::create(realm(), "array must be one of Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array, or BigUint64Array"_string);
 
-    auto const& typed_array = *array->bufferable_object().get<JS::NonnullGCPtr<JS::TypedArrayBase>>();
+    auto const& typed_array = *array->bufferable_object().get<GC::Ref<JS::TypedArrayBase>>();
     if (!typed_array.element_name().is_one_of("Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array", "BigInt64Array", "BigUint64Array"))
         return WebIDL::TypeMismatchError::create(realm(), "array must be one of Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, BigInt64Array, or BigUint64Array"_string);
 
diff --git a/Libraries/LibWeb/Crypto/Crypto.h b/Libraries/LibWeb/Crypto/Crypto.h
index 95e34d95b5e..a400ceae4a2 100644
--- a/Libraries/LibWeb/Crypto/Crypto.h
+++ b/Libraries/LibWeb/Crypto/Crypto.h
@@ -14,16 +14,16 @@ namespace Web::Crypto {
 
 class Crypto : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Crypto, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Crypto);
+    GC_DECLARE_ALLOCATOR(Crypto);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Crypto> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Crypto> create(JS::Realm&);
 
     virtual ~Crypto() override;
 
-    JS::NonnullGCPtr<SubtleCrypto> subtle() const;
+    GC::Ref<SubtleCrypto> subtle() const;
 
-    WebIDL::ExceptionOr<JS::Handle<WebIDL::ArrayBufferView>> get_random_values(JS::Handle<WebIDL::ArrayBufferView>) const;
+    WebIDL::ExceptionOr<GC::Root<WebIDL::ArrayBufferView>> get_random_values(GC::Root<WebIDL::ArrayBufferView>) const;
     WebIDL::ExceptionOr<String> random_uuid() const;
 
 protected:
@@ -33,7 +33,7 @@ protected:
 private:
     explicit Crypto(JS::Realm&);
 
-    JS::GCPtr<SubtleCrypto> m_subtle;
+    GC::Ptr<SubtleCrypto> m_subtle;
 };
 
 ErrorOr<String> generate_random_uuid();
diff --git a/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp b/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp
index 35c8126b7df..12bc64d4991 100644
--- a/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp
+++ b/Libraries/LibWeb/Crypto/CryptoAlgorithms.cpp
@@ -63,7 +63,7 @@ static Vector<Bindings::KeyUsage> usage_intersection(ReadonlySpan<Bindings::KeyU
 AlgorithmMethods::~AlgorithmMethods() = default;
 
 // https://w3c.github.io/webcrypto/#big-integer
-static ::Crypto::UnsignedBigInteger big_integer_from_api_big_integer(JS::GCPtr<JS::Uint8Array> const& big_integer)
+static ::Crypto::UnsignedBigInteger big_integer_from_api_big_integer(GC::Ptr<JS::Uint8Array> const& big_integer)
 {
     // The BigInteger typedef is a Uint8Array that holds an arbitrary magnitude unsigned integer
     // **in big-endian order**. Values read from the API SHALL have minimal typed array length
@@ -453,7 +453,7 @@ JS::ThrowCompletionOr<NonnullOwnPtr<AlgorithmParams>> RsaKeyGenParams::from_valu
     auto modulus_length = TRY(modulus_length_value.to_u32(vm));
 
     auto public_exponent_value = TRY(object.get("publicExponent"));
-    JS::GCPtr<JS::Uint8Array> public_exponent;
+    GC::Ptr<JS::Uint8Array> public_exponent;
 
     if (!public_exponent_value.is_object() || !is<JS::Uint8Array>(public_exponent_value.as_object()))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Uint8Array");
@@ -476,7 +476,7 @@ JS::ThrowCompletionOr<NonnullOwnPtr<AlgorithmParams>> RsaHashedKeyGenParams::fro
     auto modulus_length = TRY(modulus_length_value.to_u32(vm));
 
     auto public_exponent_value = TRY(object.get("publicExponent"));
-    JS::GCPtr<JS::Uint8Array> public_exponent;
+    GC::Ptr<JS::Uint8Array> public_exponent;
 
     if (!public_exponent_value.is_object() || !is<JS::Uint8Array>(public_exponent_value.as_object()))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Uint8Array");
@@ -650,7 +650,7 @@ JS::ThrowCompletionOr<NonnullOwnPtr<AlgorithmParams>> HmacKeyGenParams::from_val
 }
 
 // https://w3c.github.io/webcrypto/#rsa-oaep-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> RSAOAEP::encrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& plaintext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> RSAOAEP::encrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& plaintext)
 {
     auto& realm = *m_realm;
     auto& vm = realm.vm();
@@ -704,7 +704,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> RSAOAEP::encrypt(Algorith
 }
 
 // https://w3c.github.io/webcrypto/#rsa-oaep-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> RSAOAEP::decrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, AK::ByteBuffer const& ciphertext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> RSAOAEP::decrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, AK::ByteBuffer const& ciphertext)
 {
     auto& realm = *m_realm;
     auto& vm = realm.vm();
@@ -758,7 +758,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> RSAOAEP::decrypt(Algorith
 }
 
 // https://w3c.github.io/webcrypto/#rsa-oaep-operations
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> RSAOAEP::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> RSAOAEP::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains an entry which is not "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -822,17 +822,17 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     // 20. Set the publicKey attribute of result to be publicKey.
     // 21. Set the privateKey attribute of result to be privateKey.
     // 22. Return the result of converting result to an ECMAScript Object, as defined by [WebIDL].
-    return Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
+    return Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
 }
 
 // https://w3c.github.io/webcrypto/#rsa-oaep-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> RSAOAEP::import_key(Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> RSAOAEP::import_key(Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
 {
     auto& realm = *m_realm;
 
     // 1. Let keyData be the key data to be imported.
 
-    JS::GCPtr<CryptoKey> key = nullptr;
+    GC::Ptr<CryptoKey> key = nullptr;
     auto const& normalized_algorithm = static_cast<RsaHashedImportParams const&>(params);
 
     // 2. -> If format is "spki":
@@ -1079,11 +1079,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> RSAOAEP::import_key(Web::Crypto
     key->set_algorithm(algorithm);
 
     // 9. Return key.
-    return JS::NonnullGCPtr { *key };
+    return GC::Ref { *key };
 }
 
 // https://w3c.github.io/webcrypto/#rsa-oaep-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> RSAOAEP::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> RSAOAEP::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     auto& realm = *m_realm;
     auto& vm = realm.vm();
@@ -1094,7 +1094,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> RSAOAEP::export_key(Bindings::
     // Note: In our impl this is always accessible
     auto const& handle = key->handle();
 
-    JS::GCPtr<JS::Object> result = nullptr;
+    GC::Ptr<JS::Object> result = nullptr;
 
     // 3. If format is "spki"
     if (format == Bindings::KeyFormat::Spki) {
@@ -1241,11 +1241,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> RSAOAEP::export_key(Bindings::
     }
 
     // 8. Return result
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
 // https://w3c.github.io/webcrypto/#aes-cbc-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCbc::encrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& plaintext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesCbc::encrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& plaintext)
 {
     auto const& normalized_algorithm = static_cast<AesCbcParams const&>(params);
 
@@ -1272,7 +1272,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCbc::encrypt(Algorithm
     return JS::ArrayBuffer::create(m_realm, move(ciphertext));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCbc::decrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& ciphertext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesCbc::decrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& ciphertext)
 {
     auto const& normalized_algorithm = static_cast<AesCbcParams const&>(params);
 
@@ -1312,7 +1312,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCbc::decrypt(Algorithm
 }
 
 // https://w3c.github.io/webcrypto/#aes-cbc-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesCbc::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> AesCbc::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains an entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto& usage : key_usages) {
@@ -1421,7 +1421,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesCbc::import_key(AlgorithmPar
     return key;
 }
 
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> AesCbc::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> AesCbc::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains any entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -1472,13 +1472,13 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     return { key };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesCbc::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> AesCbc::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     // 1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.
     // Note: In our impl this is always accessible
     auto const& handle = key->handle();
 
-    JS::GCPtr<JS::Object> result = nullptr;
+    GC::Ptr<JS::Object> result = nullptr;
 
     // 2. -> If format is "raw":
     if (format == Bindings::KeyFormat::Raw) {
@@ -1537,7 +1537,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesCbc::export_key(Bindings::K
     }
 
     // 3. Return result.
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
 WebIDL::ExceptionOr<JS::Value> AesCbc::get_key_length(AlgorithmParams const& params)
@@ -1552,7 +1552,7 @@ WebIDL::ExceptionOr<JS::Value> AesCbc::get_key_length(AlgorithmParams const& par
     return JS::Value(length);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesCtr::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> AesCtr::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains an entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto& usage : key_usages) {
@@ -1667,12 +1667,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesCtr::import_key(AlgorithmPar
     return key;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesCtr::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> AesCtr::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     // 1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.
     // Note: In our impl this is always accessible
 
-    JS::GCPtr<JS::Object> result = nullptr;
+    GC::Ptr<JS::Object> result = nullptr;
 
     // 2. If format is "raw":
     if (format == Bindings::KeyFormat::Raw) {
@@ -1732,7 +1732,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesCtr::export_key(Bindings::K
     }
 
     // 3. Return result.
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
 WebIDL::ExceptionOr<JS::Value> AesCtr::get_key_length(AlgorithmParams const& params)
@@ -1747,7 +1747,7 @@ WebIDL::ExceptionOr<JS::Value> AesCtr::get_key_length(AlgorithmParams const& par
     return JS::Value(length);
 }
 
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> AesCtr::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> AesCtr::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains any entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -1795,7 +1795,7 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     return { key };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCtr::encrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& plaintext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesCtr::encrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& plaintext)
 {
     // 1. If the counter member of normalizedAlgorithm does not have length 16 bytes, then throw an OperationError.
     auto const& normalized_algorithm = static_cast<AesCtrParams const&>(params);
@@ -1826,7 +1826,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCtr::encrypt(Algorithm
     return JS::ArrayBuffer::create(m_realm, ciphertext);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesCtr::decrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& ciphertext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesCtr::decrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& ciphertext)
 {
     // 1. If the counter member of normalizedAlgorithm does not have length 16 bytes, then throw an OperationError.
     auto const& normalized_algorithm = static_cast<AesCtrParams const&>(params);
@@ -1869,7 +1869,7 @@ WebIDL::ExceptionOr<JS::Value> AesGcm::get_key_length(AlgorithmParams const& par
     return JS::Value(length);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesGcm::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> AesGcm::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains an entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto& usage : key_usages) {
@@ -1984,12 +1984,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> AesGcm::import_key(AlgorithmPar
     return key;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesGcm::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> AesGcm::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     // 1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.
     // Note: In our impl this is always accessible
 
-    JS::GCPtr<JS::Object> result = nullptr;
+    GC::Ptr<JS::Object> result = nullptr;
 
     // 2. If format is "raw":
     if (format == Bindings::KeyFormat::Raw) {
@@ -2049,10 +2049,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> AesGcm::export_key(Bindings::K
     }
 
     // 3. Return result.
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesGcm::encrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& plaintext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesGcm::encrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& plaintext)
 {
     auto const& normalized_algorithm = static_cast<AesGcmParams const&>(params);
 
@@ -2104,7 +2104,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesGcm::encrypt(Algorithm
     return JS::ArrayBuffer::create(m_realm, ciphertext);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesGcm::decrypt(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& ciphertext)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> AesGcm::decrypt(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& ciphertext)
 {
     auto const& normalized_algorithm = static_cast<AesGcmParams const&>(params);
 
@@ -2170,7 +2170,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> AesGcm::decrypt(Algorithm
     return JS::ArrayBuffer::create(m_realm, plaintext);
 }
 
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> AesGcm::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> AesGcm::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains any entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -2219,7 +2219,7 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
 }
 
 // https://w3c.github.io/webcrypto/#hkdf-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> HKDF::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> HKDF::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. Let keyData be the key data to be imported.
 
@@ -2261,7 +2261,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> HKDF::import_key(AlgorithmParam
     return key;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> SHA::digest(AlgorithmParams const& algorithm, ByteBuffer const& data)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> SHA::digest(AlgorithmParams const& algorithm, ByteBuffer const& data)
 {
     auto& algorithm_name = algorithm.name;
 
@@ -2290,7 +2290,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> SHA::digest(AlgorithmPara
 }
 
 // https://w3c.github.io/webcrypto/#ecdsa-operations
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> ECDSA::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> ECDSA::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains a value which is not one of "sign" or "verify", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -2387,11 +2387,11 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     // 21. Set the publicKey attribute of result to be publicKey.
     // 22. Set the privateKey attribute of result to be privateKey.
     // 23. Return the result of converting result to an ECMAScript Object, as defined by [WebIDL].
-    return Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
+    return Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
 }
 
 // https://w3c.github.io/webcrypto/#ecdsa-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> ECDSA::sign(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& message)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> ECDSA::sign(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& message)
 {
     auto& realm = *m_realm;
     auto& vm = realm.vm();
@@ -2429,7 +2429,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> ECDSA::sign(AlgorithmPara
 }
 
 // https://w3c.github.io/webcrypto/#ecdsa-operations
-WebIDL::ExceptionOr<JS::Value> ECDSA::verify(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
+WebIDL::ExceptionOr<JS::Value> ECDSA::verify(AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
 {
     auto& realm = *m_realm;
     auto const& normalized_algorithm = static_cast<EcdsaParams const&>(params);
@@ -2527,7 +2527,7 @@ WebIDL::ExceptionOr<JS::Value> ECDSA::verify(AlgorithmParams const& params, JS::
 }
 
 // https://wicg.github.io/webcrypto-secure-curves/#ed25519-operations
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> ED25519::generate_key([[maybe_unused]] AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> ED25519::generate_key([[maybe_unused]] AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains a value which is not one of "sign" or "verify", then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -2590,10 +2590,10 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     // 16. Set the publicKey attribute of result to be publicKey.
     // 17. Set the privateKey attribute of result to be privateKey.
     // 18. Return the result of converting result to an ECMAScript Object, as defined by [WebIDL].
-    return Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
+    return Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> ED25519::sign([[maybe_unused]] AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& message)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> ED25519::sign([[maybe_unused]] AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& message)
 {
     auto& realm = *m_realm;
     auto& vm = realm.vm();
@@ -2623,7 +2623,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> ED25519::sign([[maybe_unu
     return JS::ArrayBuffer::create(realm, move(result));
 }
 
-WebIDL::ExceptionOr<JS::Value> ED25519::verify([[maybe_unused]] AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
+WebIDL::ExceptionOr<JS::Value> ED25519::verify([[maybe_unused]] AlgorithmParams const& params, GC::Ref<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
 {
     auto& realm = *m_realm;
 
@@ -2650,7 +2650,7 @@ WebIDL::ExceptionOr<JS::Value> ED25519::verify([[maybe_unused]] AlgorithmParams
 }
 
 // https://w3c.github.io/webcrypto/#hkdf-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> HKDF::derive_bits(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, Optional<u32> length_optional)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> HKDF::derive_bits(AlgorithmParams const& params, GC::Ref<CryptoKey> key, Optional<u32> length_optional)
 {
     auto& realm = *m_realm;
     auto const& normalized_algorithm = static_cast<HKDFParams const&>(params);
@@ -2703,7 +2703,7 @@ WebIDL::ExceptionOr<JS::Value> HKDF::get_key_length(AlgorithmParams const&)
 }
 
 // https://w3c.github.io/webcrypto/#pbkdf2-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> PBKDF2::derive_bits(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, Optional<u32> length_optional)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> PBKDF2::derive_bits(AlgorithmParams const& params, GC::Ref<CryptoKey> key, Optional<u32> length_optional)
 {
     auto& realm = *m_realm;
     auto const& normalized_algorithm = static_cast<PBKDF2Params const&>(params);
@@ -2762,7 +2762,7 @@ WebIDL::ExceptionOr<JS::Value> PBKDF2::get_key_length(AlgorithmParams const&)
 }
 
 // https://w3c.github.io/webcrypto/#pbkdf2-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> PBKDF2::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> PBKDF2::import_key(AlgorithmParams const&, Bindings::KeyFormat format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If format is not "raw", throw a NotSupportedError
     if (format != Bindings::KeyFormat::Raw)
@@ -2798,7 +2798,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> PBKDF2::import_key(AlgorithmPar
 }
 
 // https://wicg.github.io/webcrypto-secure-curves/#x25519-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> X25519::derive_bits(AlgorithmParams const& params, JS::NonnullGCPtr<CryptoKey> key, Optional<u32> length_optional)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> X25519::derive_bits(AlgorithmParams const& params, GC::Ref<CryptoKey> key, Optional<u32> length_optional)
 {
     auto& realm = *m_realm;
     auto const& normalized_algorithm = static_cast<EcdhKeyDerivePrams const&>(params);
@@ -2862,7 +2862,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> X25519::derive_bits(Algor
     return JS::ArrayBuffer::create(realm, move(slice));
 }
 
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> X25519::generate_key([[maybe_unused]] AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> X25519::generate_key([[maybe_unused]] AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& key_usages)
 {
     // 1. If usages contains an entry which is not "deriveKey" or "deriveBits" then throw a SyntaxError.
     for (auto const& usage : key_usages) {
@@ -2928,16 +2928,16 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     // 16. Set the publicKey attribute of result to be publicKey.
     // 17. Set the privateKey attribute of result to be privateKey.
     // 18. Return the result of converting result to an ECMAScript Object, as defined by [WebIDL].
-    return Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
+    return Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>> { CryptoKeyPair::create(m_realm, public_key, private_key) };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> X25519::import_key([[maybe_unused]] Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> X25519::import_key([[maybe_unused]] Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
 {
     // NOTE: This is a parameter to the function
     // 1. Let keyData be the key data to be imported.
 
     auto& vm = m_realm->vm();
-    JS::GCPtr<CryptoKey> key = nullptr;
+    GC::Ptr<CryptoKey> key = nullptr;
 
     // 2. If format is "spki":
     if (key_format == Bindings::KeyFormat::Spki) {
@@ -3162,10 +3162,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> X25519::import_key([[maybe_unus
     }
 
     // 3. Return key
-    return JS::NonnullGCPtr { *key };
+    return GC::Ref { *key };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> X25519::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> X25519::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     auto& vm = m_realm->vm();
 
@@ -3176,7 +3176,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> X25519::export_key(Bindings::K
     // Note: In our impl this is always accessible
     auto const& handle = key->handle();
 
-    JS::GCPtr<JS::Object> result = nullptr;
+    GC::Ptr<JS::Object> result = nullptr;
 
     // 3. If format is "spki":
     if (format == Bindings::KeyFormat::Spki) {
@@ -3280,10 +3280,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> X25519::export_key(Bindings::K
     }
 
     // 4. Return result.
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
-static WebIDL::ExceptionOr<ByteBuffer> hmac_calculate_message_digest(JS::Realm& realm, JS::GCPtr<KeyAlgorithm> hash, ReadonlyBytes key, ReadonlyBytes message)
+static WebIDL::ExceptionOr<ByteBuffer> hmac_calculate_message_digest(JS::Realm& realm, GC::Ptr<KeyAlgorithm> hash, ReadonlyBytes key, ReadonlyBytes message)
 {
     auto calculate_digest = [&]<typename T>() -> ByteBuffer {
         ::Crypto::Authentication::HMAC<T> hmac(key);
@@ -3317,7 +3317,7 @@ static WebIDL::ExceptionOr<WebIDL::UnsignedLong> hmac_hash_block_size(JS::Realm&
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> HMAC::sign(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& message)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> HMAC::sign(AlgorithmParams const&, GC::Ref<CryptoKey> key, ByteBuffer const& message)
 {
     // 1. Let mac be the result of performing the MAC Generation operation described in Section 4 of
     //    [FIPS-198-1] using the key represented by [[handle]] internal slot of key, the hash
@@ -3332,7 +3332,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> HMAC::sign(AlgorithmParam
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
-WebIDL::ExceptionOr<JS::Value> HMAC::verify(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
+WebIDL::ExceptionOr<JS::Value> HMAC::verify(AlgorithmParams const&, GC::Ref<CryptoKey> key, ByteBuffer const& signature, ByteBuffer const& message)
 {
     // 1. Let mac be the result of performing the MAC Generation operation described in Section 4 of
     //    [FIPS-198-1] using the key represented by [[handle]] internal slot of key, the hash
@@ -3347,7 +3347,7 @@ WebIDL::ExceptionOr<JS::Value> HMAC::verify(AlgorithmParams const&, JS::NonnullG
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
-WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> HMAC::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& usages)
+WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> HMAC::generate_key(AlgorithmParams const& params, bool extractable, Vector<Bindings::KeyUsage> const& usages)
 {
     // 1. If usages contains any entry which is not "sign" or "verify", then throw a SyntaxError.
     for (auto const& usage : usages) {
@@ -3413,11 +3413,11 @@ WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<Crypto
     key->set_usages(usages);
 
     // 15. Return key.
-    return Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>> { key };
+    return Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>> { key };
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> HMAC::import_key(Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
+WebIDL::ExceptionOr<GC::Ref<CryptoKey>> HMAC::import_key(Web::Crypto::AlgorithmParams const& params, Bindings::KeyFormat key_format, CryptoKey::InternalKeyData key_data, bool extractable, Vector<Bindings::KeyUsage> const& usages)
 {
     auto& vm = m_realm->vm();
     auto const& normalized_algorithm = static_cast<HmacImportParams const&>(params);
@@ -3579,7 +3579,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> HMAC::import_key(Web::Crypto::A
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> HMAC::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+WebIDL::ExceptionOr<GC::Ref<JS::Object>> HMAC::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     // 1. If the underlying cryptographic key material represented by the [[handle]] internal slot
     //    of key cannot be accessed, then throw an OperationError.
@@ -3590,7 +3590,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> HMAC::export_key(Bindings::Key
     auto data = key->handle().get<ByteBuffer>();
 
     // 4. If format is "raw":
-    JS::GCPtr<JS::Object> result;
+    GC::Ptr<JS::Object> result;
     if (format == Bindings::KeyFormat::Raw) {
         // Let result be the result of creating an ArrayBuffer containing data.
         result = JS::ArrayBuffer::create(m_realm, data);
@@ -3667,7 +3667,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> HMAC::export_key(Bindings::Key
     }
 
     // 5. Return result.
-    return JS::NonnullGCPtr { *result };
+    return GC::Ref { *result };
 }
 
 // https://w3c.github.io/webcrypto/#hmac-operations
diff --git a/Libraries/LibWeb/Crypto/CryptoAlgorithms.h b/Libraries/LibWeb/Crypto/CryptoAlgorithms.h
index 9a3de6f3cc2..a7d43508562 100644
--- a/Libraries/LibWeb/Crypto/CryptoAlgorithms.h
+++ b/Libraries/LibWeb/Crypto/CryptoAlgorithms.h
@@ -11,8 +11,8 @@
 #include <AK/EnumBits.h>
 #include <AK/String.h>
 #include <LibCrypto/BigInt/UnsignedBigInteger.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/SubtleCryptoPrototype.h>
 #include <LibWeb/Crypto/CryptoBindings.h>
 #include <LibWeb/Crypto/CryptoKey.h>
@@ -22,9 +22,9 @@
 
 namespace Web::Crypto {
 
-using AlgorithmIdentifier = Variant<JS::Handle<JS::Object>, String>;
+using AlgorithmIdentifier = Variant<GC::Root<JS::Object>, String>;
 using NamedCurve = String;
-using KeyDataType = Variant<JS::Handle<WebIDL::BufferSource>, Bindings::JsonWebKey>;
+using KeyDataType = Variant<GC::Root<WebIDL::BufferSource>, Bindings::JsonWebKey>;
 
 struct HashAlgorithmIdentifier : public AlgorithmIdentifier {
     using AlgorithmIdentifier::AlgorithmIdentifier;
@@ -33,7 +33,7 @@ struct HashAlgorithmIdentifier : public AlgorithmIdentifier {
     {
         auto value = visit(
             [](String const& name) -> JS::ThrowCompletionOr<String> { return name; },
-            [&](JS::Handle<JS::Object> const& obj) -> JS::ThrowCompletionOr<String> {
+            [&](GC::Root<JS::Object> const& obj) -> JS::ThrowCompletionOr<String> {
                 auto name_property = TRY(obj->get("name"));
                 return name_property.to_string(vm);
             });
@@ -300,47 +300,47 @@ class AlgorithmMethods {
 public:
     virtual ~AlgorithmMethods();
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "encrypt is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "decrypt is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> sign(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> sign(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "sign is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&, ByteBuffer const&)
+    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&, ByteBuffer const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "verify is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> digest(AlgorithmParams const&, ByteBuffer const&)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> digest(AlgorithmParams const&, ByteBuffer const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "digest is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, Optional<u32>)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, GC::Ref<CryptoKey>, Optional<u32>)
     {
         return WebIDL::NotSupportedError::create(m_realm, "deriveBits is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&)
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "importKey is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&)
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&)
     {
         return WebIDL::NotSupportedError::create(m_realm, "generateKey is not supported"_string);
     }
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>)
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>)
     {
         return WebIDL::NotSupportedError::create(m_realm, "exportKey is not supported"_string);
     }
@@ -358,18 +358,18 @@ protected:
     {
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    GC::Ref<JS::Realm> m_realm;
 };
 
 class RSAOAEP : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
 
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new RSAOAEP(realm)); }
 
@@ -382,11 +382,11 @@ private:
 
 class AesCbc : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new AesCbc(realm)); }
@@ -400,12 +400,12 @@ private:
 
 class AesCtr : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new AesCtr(realm)); }
 
@@ -419,11 +419,11 @@ private:
 class AesGcm : public AlgorithmMethods {
 public:
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> encrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> decrypt(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new AesGcm(realm)); }
 
@@ -436,8 +436,8 @@ private:
 
 class HKDF : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, Optional<u32>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, GC::Ref<CryptoKey>, Optional<u32>) override;
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new HKDF(realm)); }
@@ -451,8 +451,8 @@ private:
 
 class PBKDF2 : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, Optional<u32>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, GC::Ref<CryptoKey>, Optional<u32>) override;
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new PBKDF2(realm)); }
@@ -466,7 +466,7 @@ private:
 
 class SHA : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> digest(AlgorithmParams const&, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> digest(AlgorithmParams const&, ByteBuffer const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new SHA(realm)); }
 
@@ -479,10 +479,10 @@ private:
 
 class ECDSA : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> sign(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> sign(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
 
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new ECDSA(realm)); }
 
@@ -495,10 +495,10 @@ private:
 
 class ED25519 : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> sign(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> sign(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
 
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new ED25519(realm)); }
 
@@ -511,10 +511,10 @@ private:
 
 class X25519 : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, Optional<u32>) override;
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> derive_bits(AlgorithmParams const&, GC::Ref<CryptoKey>, Optional<u32>) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new X25519(realm)); }
 
@@ -527,11 +527,11 @@ private:
 
 class HMAC : public AlgorithmMethods {
 public:
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> sign(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, JS::NonnullGCPtr<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
-    virtual WebIDL::ExceptionOr<Variant<JS::NonnullGCPtr<CryptoKey>, JS::NonnullGCPtr<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Object>> export_key(Bindings::KeyFormat, JS::NonnullGCPtr<CryptoKey>) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> sign(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<JS::Value> verify(AlgorithmParams const&, GC::Ref<CryptoKey>, ByteBuffer const&, ByteBuffer const&) override;
+    virtual WebIDL::ExceptionOr<Variant<GC::Ref<CryptoKey>, GC::Ref<CryptoKeyPair>>> generate_key(AlgorithmParams const&, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<CryptoKey>> import_key(AlgorithmParams const&, Bindings::KeyFormat, CryptoKey::InternalKeyData, bool, Vector<Bindings::KeyUsage> const&) override;
+    virtual WebIDL::ExceptionOr<GC::Ref<JS::Object>> export_key(Bindings::KeyFormat, GC::Ref<CryptoKey>) override;
     virtual WebIDL::ExceptionOr<JS::Value> get_key_length(AlgorithmParams const&) override;
 
     static NonnullOwnPtr<AlgorithmMethods> create(JS::Realm& realm) { return adopt_own(*new HMAC(realm)); }
@@ -552,7 +552,7 @@ struct EcdhKeyDerivePrams : public AlgorithmParams {
     {
     }
 
-    JS::NonnullGCPtr<CryptoKey> public_key;
+    GC::Ref<CryptoKey> public_key;
 
     static JS::ThrowCompletionOr<NonnullOwnPtr<AlgorithmParams>> from_value(JS::VM&, JS::Value);
 };
diff --git a/Libraries/LibWeb/Crypto/CryptoBindings.cpp b/Libraries/LibWeb/Crypto/CryptoBindings.cpp
index 1e911c262d2..2e7e7bde7fd 100644
--- a/Libraries/LibWeb/Crypto/CryptoBindings.cpp
+++ b/Libraries/LibWeb/Crypto/CryptoBindings.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Bindings {
 
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> JsonWebKey::to_object(JS::Realm& realm)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> JsonWebKey::to_object(JS::Realm& realm)
 {
     auto& vm = realm.vm();
     auto object = JS::Object::create(realm, realm.intrinsics().object_prototype());
diff --git a/Libraries/LibWeb/Crypto/CryptoBindings.h b/Libraries/LibWeb/Crypto/CryptoBindings.h
index 3d8d506dd63..89e98fdff5c 100644
--- a/Libraries/LibWeb/Crypto/CryptoBindings.h
+++ b/Libraries/LibWeb/Crypto/CryptoBindings.h
@@ -43,7 +43,7 @@ struct JsonWebKey {
     Optional<Vector<RsaOtherPrimesInfo>> oth;
     Optional<String> k;
 
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> to_object(JS::Realm&);
+    JS::ThrowCompletionOr<GC::Ref<JS::Object>> to_object(JS::Realm&);
 };
 
 }
diff --git a/Libraries/LibWeb/Crypto/CryptoKey.cpp b/Libraries/LibWeb/Crypto/CryptoKey.cpp
index b7bd43668da..2e636f5ecc9 100644
--- a/Libraries/LibWeb/Crypto/CryptoKey.cpp
+++ b/Libraries/LibWeb/Crypto/CryptoKey.cpp
@@ -13,15 +13,15 @@
 
 namespace Web::Crypto {
 
-JS_DEFINE_ALLOCATOR(CryptoKey);
-JS_DEFINE_ALLOCATOR(CryptoKeyPair);
+GC_DEFINE_ALLOCATOR(CryptoKey);
+GC_DEFINE_ALLOCATOR(CryptoKeyPair);
 
-JS::NonnullGCPtr<CryptoKey> CryptoKey::create(JS::Realm& realm, InternalKeyData key_data)
+GC::Ref<CryptoKey> CryptoKey::create(JS::Realm& realm, InternalKeyData key_data)
 {
     return realm.create<CryptoKey>(realm, move(key_data));
 }
 
-JS::NonnullGCPtr<CryptoKey> CryptoKey::create(JS::Realm& realm)
+GC::Ref<CryptoKey> CryptoKey::create(JS::Realm& realm)
 {
     return realm.create<CryptoKey>(realm);
 }
@@ -80,12 +80,12 @@ String CryptoKey::algorithm_name() const
     return m_algorithm_name;
 }
 
-JS::NonnullGCPtr<CryptoKeyPair> CryptoKeyPair::create(JS::Realm& realm, JS::NonnullGCPtr<CryptoKey> public_key, JS::NonnullGCPtr<CryptoKey> private_key)
+GC::Ref<CryptoKeyPair> CryptoKeyPair::create(JS::Realm& realm, GC::Ref<CryptoKey> public_key, GC::Ref<CryptoKey> private_key)
 {
     return realm.create<CryptoKeyPair>(realm, public_key, private_key);
 }
 
-CryptoKeyPair::CryptoKeyPair(JS::Realm& realm, JS::NonnullGCPtr<CryptoKey> public_key, JS::NonnullGCPtr<CryptoKey> private_key)
+CryptoKeyPair::CryptoKeyPair(JS::Realm& realm, GC::Ref<CryptoKey> public_key, GC::Ref<CryptoKey> private_key)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
     , m_public_key(public_key)
     , m_private_key(private_key)
diff --git a/Libraries/LibWeb/Crypto/CryptoKey.h b/Libraries/LibWeb/Crypto/CryptoKey.h
index ee4e8260cb3..fce2a4a80de 100644
--- a/Libraries/LibWeb/Crypto/CryptoKey.h
+++ b/Libraries/LibWeb/Crypto/CryptoKey.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <LibCrypto/PK/RSA.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/CryptoKeyPrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/PlatformObject.h>
@@ -21,13 +21,13 @@ class CryptoKey final
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(CryptoKey, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CryptoKey);
+    GC_DECLARE_ALLOCATOR(CryptoKey);
 
 public:
     using InternalKeyData = Variant<ByteBuffer, Bindings::JsonWebKey, ::Crypto::PK::RSAPublicKey<>, ::Crypto::PK::RSAPrivateKey<>>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<CryptoKey> create(JS::Realm&, InternalKeyData);
-    [[nodiscard]] static JS::NonnullGCPtr<CryptoKey> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<CryptoKey> create(JS::Realm&, InternalKeyData);
+    [[nodiscard]] static GC::Ref<CryptoKey> create(JS::Realm&);
 
     virtual ~CryptoKey() override;
 
@@ -40,7 +40,7 @@ public:
 
     void set_extractable(bool extractable) { m_extractable = extractable; }
     void set_type(Bindings::KeyType type) { m_type = type; }
-    void set_algorithm(JS::NonnullGCPtr<Object> algorithm) { m_algorithm = move(algorithm); }
+    void set_algorithm(GC::Ref<Object> algorithm) { m_algorithm = move(algorithm); }
     void set_usages(Vector<Bindings::KeyUsage>);
 
     InternalKeyData const& handle() const { return m_key_data; }
@@ -59,8 +59,8 @@ private:
 
     Bindings::KeyType m_type;
     bool m_extractable { false };
-    JS::NonnullGCPtr<Object> m_algorithm;
-    JS::NonnullGCPtr<Object> m_usages;
+    GC::Ref<Object> m_algorithm;
+    GC::Ref<Object> m_usages;
 
     Vector<Bindings::KeyUsage> m_key_usages;
     InternalKeyData m_key_data; // [[handle]]
@@ -70,25 +70,25 @@ private:
 // https://w3c.github.io/webcrypto/#ref-for-dfn-CryptoKeyPair-2
 class CryptoKeyPair : public JS::Object {
     JS_OBJECT(CryptoKeyPair, JS::Object);
-    JS_DECLARE_ALLOCATOR(CryptoKeyPair);
+    GC_DECLARE_ALLOCATOR(CryptoKeyPair);
 
 public:
-    static JS::NonnullGCPtr<CryptoKeyPair> create(JS::Realm&, JS::NonnullGCPtr<CryptoKey> public_key, JS::NonnullGCPtr<CryptoKey> private_key);
+    static GC::Ref<CryptoKeyPair> create(JS::Realm&, GC::Ref<CryptoKey> public_key, GC::Ref<CryptoKey> private_key);
     virtual ~CryptoKeyPair() override = default;
 
-    JS::NonnullGCPtr<CryptoKey> public_key() const { return m_public_key; }
-    JS::NonnullGCPtr<CryptoKey> private_key() const { return m_private_key; }
+    GC::Ref<CryptoKey> public_key() const { return m_public_key; }
+    GC::Ref<CryptoKey> private_key() const { return m_private_key; }
 
 private:
-    CryptoKeyPair(JS::Realm&, JS::NonnullGCPtr<CryptoKey> public_key, JS::NonnullGCPtr<CryptoKey> private_key);
+    CryptoKeyPair(JS::Realm&, GC::Ref<CryptoKey> public_key, GC::Ref<CryptoKey> private_key);
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor&) override;
 
     JS_DECLARE_NATIVE_FUNCTION(public_key_getter);
     JS_DECLARE_NATIVE_FUNCTION(private_key_getter);
 
-    JS::NonnullGCPtr<CryptoKey> m_public_key;
-    JS::NonnullGCPtr<CryptoKey> m_private_key;
+    GC::Ref<CryptoKey> m_public_key;
+    GC::Ref<CryptoKey> m_private_key;
 };
 
 }
diff --git a/Libraries/LibWeb/Crypto/KeyAlgorithms.cpp b/Libraries/LibWeb/Crypto/KeyAlgorithms.cpp
index f07143a0ed9..f62b727b862 100644
--- a/Libraries/LibWeb/Crypto/KeyAlgorithms.cpp
+++ b/Libraries/LibWeb/Crypto/KeyAlgorithms.cpp
@@ -14,12 +14,12 @@
 
 namespace Web::Crypto {
 
-JS_DEFINE_ALLOCATOR(KeyAlgorithm);
-JS_DEFINE_ALLOCATOR(RsaKeyAlgorithm);
-JS_DEFINE_ALLOCATOR(RsaHashedKeyAlgorithm);
-JS_DEFINE_ALLOCATOR(EcKeyAlgorithm);
-JS_DEFINE_ALLOCATOR(AesKeyAlgorithm);
-JS_DEFINE_ALLOCATOR(HmacKeyAlgorithm);
+GC_DEFINE_ALLOCATOR(KeyAlgorithm);
+GC_DEFINE_ALLOCATOR(RsaKeyAlgorithm);
+GC_DEFINE_ALLOCATOR(RsaHashedKeyAlgorithm);
+GC_DEFINE_ALLOCATOR(EcKeyAlgorithm);
+GC_DEFINE_ALLOCATOR(AesKeyAlgorithm);
+GC_DEFINE_ALLOCATOR(HmacKeyAlgorithm);
 
 template<typename T>
 static JS::ThrowCompletionOr<T*> impl_from(JS::VM& vm, StringView Name)
@@ -36,7 +36,7 @@ static JS::ThrowCompletionOr<T*> impl_from(JS::VM& vm, StringView Name)
     return static_cast<T*>(this_object);
 }
 
-JS::NonnullGCPtr<KeyAlgorithm> KeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<KeyAlgorithm> KeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<KeyAlgorithm>(realm);
 }
@@ -66,7 +66,7 @@ void KeyAlgorithm::visit_edges(Visitor& visitor)
     visitor.visit(m_realm);
 }
 
-JS::NonnullGCPtr<RsaKeyAlgorithm> RsaKeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<RsaKeyAlgorithm> RsaKeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<RsaKeyAlgorithm>(realm);
 }
@@ -132,7 +132,7 @@ JS_DEFINE_NATIVE_FUNCTION(RsaKeyAlgorithm::public_exponent_getter)
     return impl->public_exponent();
 }
 
-JS::NonnullGCPtr<EcKeyAlgorithm> EcKeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<EcKeyAlgorithm> EcKeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<EcKeyAlgorithm>(realm);
 }
@@ -155,7 +155,7 @@ JS_DEFINE_NATIVE_FUNCTION(EcKeyAlgorithm::named_curve_getter)
     return JS::PrimitiveString::create(vm, impl->named_curve());
 }
 
-JS::NonnullGCPtr<RsaHashedKeyAlgorithm> RsaHashedKeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<RsaHashedKeyAlgorithm> RsaHashedKeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<RsaHashedKeyAlgorithm>(realm);
 }
@@ -181,12 +181,12 @@ JS_DEFINE_NATIVE_FUNCTION(RsaHashedKeyAlgorithm::hash_getter)
         [&](String const& hash_string) -> JS::Value {
             return JS::PrimitiveString::create(vm, hash_string);
         },
-        [&](JS::Handle<JS::Object> const& hash) -> JS::Value {
+        [&](GC::Root<JS::Object> const& hash) -> JS::Value {
             return hash;
         });
 }
 
-JS::NonnullGCPtr<AesKeyAlgorithm> AesKeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<AesKeyAlgorithm> AesKeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<AesKeyAlgorithm>(realm);
 }
@@ -211,7 +211,7 @@ JS_DEFINE_NATIVE_FUNCTION(AesKeyAlgorithm::length_getter)
     return length;
 }
 
-JS::NonnullGCPtr<HmacKeyAlgorithm> HmacKeyAlgorithm::create(JS::Realm& realm)
+GC::Ref<HmacKeyAlgorithm> HmacKeyAlgorithm::create(JS::Realm& realm)
 {
     return realm.create<HmacKeyAlgorithm>(realm);
 }
diff --git a/Libraries/LibWeb/Crypto/KeyAlgorithms.h b/Libraries/LibWeb/Crypto/KeyAlgorithms.h
index 78fb92be287..184038dcefd 100644
--- a/Libraries/LibWeb/Crypto/KeyAlgorithms.h
+++ b/Libraries/LibWeb/Crypto/KeyAlgorithms.h
@@ -19,10 +19,10 @@ namespace Web::Crypto {
 // https://w3c.github.io/webcrypto/#key-algorithm-dictionary
 class KeyAlgorithm : public JS::Object {
     JS_OBJECT(KeyAlgorithm, JS::Object);
-    JS_DECLARE_ALLOCATOR(KeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(KeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<KeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<KeyAlgorithm> create(JS::Realm&);
     virtual ~KeyAlgorithm() override = default;
 
     String const& name() const { return m_name; }
@@ -40,24 +40,24 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(name_getter);
 
     String m_name;
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    GC::Ref<JS::Realm> m_realm;
 };
 
 // https://w3c.github.io/webcrypto/#RsaKeyAlgorithm-dictionary
 class RsaKeyAlgorithm : public KeyAlgorithm {
     JS_OBJECT(RsaKeyAlgorithm, KeyAlgorithm);
-    JS_DECLARE_ALLOCATOR(RsaKeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(RsaKeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<RsaKeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<RsaKeyAlgorithm> create(JS::Realm&);
 
     virtual ~RsaKeyAlgorithm() override = default;
 
     u32 modulus_length() const { return m_modulus_length; }
     void set_modulus_length(u32 modulus_length) { m_modulus_length = modulus_length; }
 
-    JS::NonnullGCPtr<JS::Uint8Array> public_exponent() const { return m_public_exponent; }
-    void set_public_exponent(JS::NonnullGCPtr<JS::Uint8Array> public_exponent) { m_public_exponent = public_exponent; }
+    GC::Ref<JS::Uint8Array> public_exponent() const { return m_public_exponent; }
+    void set_public_exponent(GC::Ref<JS::Uint8Array> public_exponent) { m_public_exponent = public_exponent; }
     WebIDL::ExceptionOr<void> set_public_exponent(::Crypto::UnsignedBigInteger);
 
 protected:
@@ -71,16 +71,16 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(public_exponent_getter);
 
     u32 m_modulus_length { 0 };
-    JS::NonnullGCPtr<JS::Uint8Array> m_public_exponent;
+    GC::Ref<JS::Uint8Array> m_public_exponent;
 };
 
 // https://w3c.github.io/webcrypto/#RsaHashedKeyAlgorithm-dictionary
 class RsaHashedKeyAlgorithm : public RsaKeyAlgorithm {
     JS_OBJECT(RsaHashedKeyAlgorithm, RsaKeyAlgorithm);
-    JS_DECLARE_ALLOCATOR(RsaHashedKeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(RsaHashedKeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<RsaHashedKeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<RsaHashedKeyAlgorithm> create(JS::Realm&);
 
     virtual ~RsaHashedKeyAlgorithm() override = default;
 
@@ -101,10 +101,10 @@ private:
 // https://w3c.github.io/webcrypto/#EcKeyAlgorithm-dictionary
 class EcKeyAlgorithm : public KeyAlgorithm {
     JS_OBJECT(EcKeyAlgorithm, KeyAlgorithm);
-    JS_DECLARE_ALLOCATOR(EcKeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(EcKeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<EcKeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<EcKeyAlgorithm> create(JS::Realm&);
 
     virtual ~EcKeyAlgorithm() override = default;
 
@@ -125,10 +125,10 @@ private:
 // https://w3c.github.io/webcrypto/#AesKeyAlgorithm-dictionary
 struct AesKeyAlgorithm : public KeyAlgorithm {
     JS_OBJECT(AesKeyAlgorithm, KeyAlgorithm);
-    JS_DECLARE_ALLOCATOR(AesKeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(AesKeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<AesKeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<AesKeyAlgorithm> create(JS::Realm&);
 
     virtual ~AesKeyAlgorithm() override = default;
 
@@ -149,15 +149,15 @@ private:
 // https://w3c.github.io/webcrypto/#HmacKeyAlgorithm-dictionary
 struct HmacKeyAlgorithm : public KeyAlgorithm {
     JS_OBJECT(HmacKeyAlgorithm, KeyAlgorithm);
-    JS_DECLARE_ALLOCATOR(HmacKeyAlgorithm);
+    GC_DECLARE_ALLOCATOR(HmacKeyAlgorithm);
 
 public:
-    static JS::NonnullGCPtr<HmacKeyAlgorithm> create(JS::Realm&);
+    static GC::Ref<HmacKeyAlgorithm> create(JS::Realm&);
 
     virtual ~HmacKeyAlgorithm() override = default;
 
-    JS::GCPtr<KeyAlgorithm> hash() const { return m_hash; }
-    void set_hash(JS::GCPtr<KeyAlgorithm> hash) { m_hash = hash; }
+    GC::Ptr<KeyAlgorithm> hash() const { return m_hash; }
+    void set_hash(GC::Ptr<KeyAlgorithm> hash) { m_hash = hash; }
 
     WebIDL::UnsignedLong length() const { return m_length; }
     void set_length(WebIDL::UnsignedLong length) { m_length = length; }
@@ -172,7 +172,7 @@ private:
     JS_DECLARE_NATIVE_FUNCTION(hash_getter);
     JS_DECLARE_NATIVE_FUNCTION(length_getter);
 
-    JS::GCPtr<KeyAlgorithm> m_hash;
+    GC::Ptr<KeyAlgorithm> m_hash;
     WebIDL::UnsignedLong m_length;
 };
 
diff --git a/Libraries/LibWeb/Crypto/SubtleCrypto.cpp b/Libraries/LibWeb/Crypto/SubtleCrypto.cpp
index e34e572a380..e83bcf44337 100644
--- a/Libraries/LibWeb/Crypto/SubtleCrypto.cpp
+++ b/Libraries/LibWeb/Crypto/SubtleCrypto.cpp
@@ -39,9 +39,9 @@ static SupportedAlgorithmsMap supported_algorithms();
 template<typename Methods, typename Param = AlgorithmParams>
 static void define_an_algorithm(String op, String algorithm);
 
-JS_DEFINE_ALLOCATOR(SubtleCrypto);
+GC_DEFINE_ALLOCATOR(SubtleCrypto);
 
-JS::NonnullGCPtr<SubtleCrypto> SubtleCrypto::create(JS::Realm& realm)
+GC::Ref<SubtleCrypto> SubtleCrypto::create(JS::Realm& realm)
 {
     return realm.create<SubtleCrypto>(realm);
 }
@@ -68,7 +68,7 @@ WebIDL::ExceptionOr<NormalizedAlgorithmAndParameter> normalize_an_algorithm(JS::
     if (algorithm.has<String>()) {
         // Return the result of running the normalize an algorithm algorithm,
         // with the alg set to a new Algorithm dictionary whose name attribute is alg, and with the op set to op.
-        auto dictionary = JS::make_handle(JS::Object::create(realm, realm.intrinsics().object_prototype()));
+        auto dictionary = GC::make_root(JS::Object::create(realm, realm.intrinsics().object_prototype()));
         TRY(dictionary->create_data_property("name", JS::PrimitiveString::create(vm, algorithm.get<String>())));
 
         return normalize_an_algorithm(realm, dictionary, operation);
@@ -86,7 +86,7 @@ WebIDL::ExceptionOr<NormalizedAlgorithmAndParameter> normalize_an_algorithm(JS::
     // 3. If an error occurred, return the error and terminate this algorithm.
     // Note: We're not going to bother creating an Algorithm object, all we want is the name attribute so that we can
     //       fetch the actual algorithm factory from the registeredAlgorithms map.
-    auto initial_algorithm = TRY(algorithm.get<JS::Handle<JS::Object>>()->get("name"));
+    auto initial_algorithm = TRY(algorithm.get<GC::Root<JS::Object>>()->get("name"));
 
     // 4. Let algName be the value of the name attribute of initialAlg.
     auto algorithm_name = TRY(initial_algorithm.to_string(vm));
@@ -113,7 +113,7 @@ WebIDL::ExceptionOr<NormalizedAlgorithmAndParameter> normalize_an_algorithm(JS::
     // 12. For each dictionary dictionary in dictionaries:
     //    Note: All of these steps are handled by the create_methods and parameter_from_value methods.
     auto methods = desired_type.create_methods(realm);
-    auto parameter = TRY(desired_type.parameter_from_value(vm, algorithm.get<JS::Handle<JS::Object>>()));
+    auto parameter = TRY(desired_type.parameter_from_value(vm, algorithm.get<GC::Root<JS::Object>>()));
     auto normalized_algorithm = NormalizedAlgorithmAndParameter { move(methods), move(parameter) };
 
     // 13. Return normalizedAlgorithm.
@@ -121,7 +121,7 @@ WebIDL::ExceptionOr<NormalizedAlgorithmAndParameter> normalize_an_algorithm(JS::
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-encrypt
-JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::encrypt(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter)
+GC::Ref<WebIDL::Promise> SubtleCrypto::encrypt(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -147,7 +147,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::encrypt(AlgorithmIdentifier cons
 
     // 6. Return promise and perform the remaining steps in parallel.
 
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 7. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -178,7 +178,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::encrypt(AlgorithmIdentifier cons
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-decrypt
-JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::decrypt(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter)
+GC::Ref<WebIDL::Promise> SubtleCrypto::decrypt(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -204,7 +204,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::decrypt(AlgorithmIdentifier cons
 
     // 6. Return promise and perform the remaining steps in parallel.
 
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 7. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -235,7 +235,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::decrypt(AlgorithmIdentifier cons
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-digest
-JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::digest(AlgorithmIdentifier const& algorithm, JS::Handle<WebIDL::BufferSource> const& data)
+GC::Ref<WebIDL::Promise> SubtleCrypto::digest(AlgorithmIdentifier const& algorithm, GC::Root<WebIDL::BufferSource> const& data)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -262,7 +262,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::digest(AlgorithmIdentifier const
     auto promise = WebIDL::create_promise(realm);
 
     // 6. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, algorithm_object = normalized_algorithm.release_value(), promise, data_buffer = move(data_buffer)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, algorithm_object = normalized_algorithm.release_value(), promise, data_buffer = move(data_buffer)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 7. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
         // FIXME: Need spec reference to https://webidl.spec.whatwg.org/#reject
@@ -283,7 +283,7 @@ JS::NonnullGCPtr<WebIDL::Promise> SubtleCrypto::digest(AlgorithmIdentifier const
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-generateKey
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::generate_key(AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::generate_key(AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages)
 {
     auto& realm = this->realm();
 
@@ -302,7 +302,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::generate_
     auto promise = WebIDL::create_promise(realm);
 
     // 5. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, extractable, key_usages = move(key_usages)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, extractable, key_usages = move(key_usages)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 6. If the following steps or referenced procedures say to throw an error, reject promise with
         //    the returned error and then terminate the algorithm.
@@ -323,14 +323,14 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::generate_
         //      If the [[usages]] internal slot of the privateKey attribute of result is the empty sequence, then throw a SyntaxError.
         // 9. Resolve promise with result.
         result.visit(
-            [&](JS::NonnullGCPtr<CryptoKey>& key) {
+            [&](GC::Ref<CryptoKey>& key) {
                 if ((key->type() == Bindings::KeyType::Secret || key->type() == Bindings::KeyType::Private) && key_usages.is_empty()) {
                     WebIDL::reject_promise(realm, promise, WebIDL::SyntaxError::create(realm, "usages must not be empty"_string));
                     return;
                 }
                 WebIDL::resolve_promise(realm, promise, key);
             },
-            [&](JS::NonnullGCPtr<CryptoKeyPair>& key_pair) {
+            [&](GC::Ref<CryptoKeyPair>& key_pair) {
                 if (key_pair->private_key()->internal_usages().is_empty()) {
                     WebIDL::reject_promise(realm, promise, WebIDL::SyntaxError::create(realm, "usages must not be empty"_string));
                     return;
@@ -343,7 +343,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::generate_
 }
 
 // https://w3c.github.io/webcrypto/#SubtleCrypto-method-importKey
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::import_key(Bindings::KeyFormat format, KeyDataType key_data, AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::import_key(Bindings::KeyFormat format, KeyDataType key_data, AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages)
 {
     auto& realm = this->realm();
 
@@ -359,7 +359,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::import_ke
         }
 
         // 2. Let keyData be the result of getting a copy of the bytes held by the keyData parameter passed to the importKey() method.
-        real_key_data = MUST(WebIDL::get_buffer_source_copy(*key_data.get<JS::Handle<WebIDL::BufferSource>>()->raw_object()));
+        real_key_data = MUST(WebIDL::get_buffer_source_copy(*key_data.get<GC::Root<WebIDL::BufferSource>>()->raw_object()));
     }
 
     if (format == Bindings::KeyFormat::Jwk) {
@@ -384,7 +384,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::import_ke
     auto promise = WebIDL::create_promise(realm);
 
     // 8. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [&realm, real_key_data = move(real_key_data), normalized_algorithm = normalized_algorithm.release_value(), promise, format, extractable, key_usages = move(key_usages), algorithm = move(algorithm)]() mutable -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [&realm, real_key_data = move(real_key_data), normalized_algorithm = normalized_algorithm.release_value(), promise, format, extractable, key_usages = move(key_usages), algorithm = move(algorithm)]() mutable -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
         // 9. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
@@ -419,7 +419,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::import_ke
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-exportKey
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key)
 {
     auto& realm = this->realm();
     // 1. Let format and key be the format and key parameters passed to the exportKey() method, respectively.
@@ -428,7 +428,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::export_ke
     auto promise = WebIDL::create_promise(realm);
 
     // 3. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [&realm, key, promise, format]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [&realm, key, promise, format]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 4.  If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -465,7 +465,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::export_ke
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-sign
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::sign(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::sign(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -491,7 +491,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::sign(Algo
 
     // 6. Return promise and perform the remaining steps in parallel.
 
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, data = move(data)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 7. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -522,7 +522,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::sign(Algo
 }
 
 // https://w3c.github.io/webcrypto/#dfn-SubtleCrypto-method-verify
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::verify(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& signature_data, JS::Handle<WebIDL::BufferSource> const& data_parameter)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::verify(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& signature_data, GC::Root<WebIDL::BufferSource> const& data_parameter)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -555,7 +555,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::verify(Al
     auto promise = WebIDL::create_promise(realm);
 
     // 7. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, signature = move(signature), data = move(data)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, key, signature = move(signature), data = move(data)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 8. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -586,7 +586,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::verify(Al
 }
 
 // https://w3c.github.io/webcrypto/#SubtleCrypto-method-deriveBits
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::derive_bits(AlgorithmIdentifier algorithm, JS::NonnullGCPtr<CryptoKey> base_key, u32 length)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::derive_bits(AlgorithmIdentifier algorithm, GC::Ref<CryptoKey> base_key, u32 length)
 {
     auto& realm = this->realm();
     // 1. Let algorithm, baseKey and length, be the algorithm, baseKey and length parameters passed to the deriveBits() method, respectively.
@@ -602,7 +602,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::derive_bi
     auto promise = WebIDL::create_promise(realm);
 
     // 5. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, base_key, length]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, normalized_algorithm = normalized_algorithm.release_value(), promise, base_key, length]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 6. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
@@ -633,7 +633,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::derive_bi
 }
 
 // https://w3c.github.io/webcrypto/#SubtleCrypto-method-deriveKey
-JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::derive_key(AlgorithmIdentifier algorithm, JS::NonnullGCPtr<CryptoKey> base_key, AlgorithmIdentifier derived_key_type, bool extractable, Vector<Bindings::KeyUsage> key_usages)
+JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> SubtleCrypto::derive_key(AlgorithmIdentifier algorithm, GC::Ref<CryptoKey> base_key, AlgorithmIdentifier derived_key_type, bool extractable, Vector<Bindings::KeyUsage> key_usages)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -664,7 +664,7 @@ JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> SubtleCrypto::derive_ke
     auto promise = WebIDL::create_promise(realm);
 
     // 9. Return promise and perform the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, &vm, normalized_algorithm = normalized_algorithm.release_value(), promise, normalized_derived_key_algorithm_import = normalized_derived_key_algorithm_import.release_value(), normalized_derived_key_algorithm_length = normalized_derived_key_algorithm_length.release_value(), base_key = move(base_key), extractable, key_usages = move(key_usages)]() -> void {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, &vm, normalized_algorithm = normalized_algorithm.release_value(), promise, normalized_derived_key_algorithm_import = normalized_derived_key_algorithm_import.release_value(), normalized_derived_key_algorithm_length = normalized_derived_key_algorithm_length.release_value(), base_key = move(base_key), extractable, key_usages = move(key_usages)]() -> void {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 10. If the following steps or referenced procedures say to throw an error, reject promise with the returned error and then terminate the algorithm.
 
diff --git a/Libraries/LibWeb/Crypto/SubtleCrypto.h b/Libraries/LibWeb/Crypto/SubtleCrypto.h
index 5c83a1101a9..6cc934a973d 100644
--- a/Libraries/LibWeb/Crypto/SubtleCrypto.h
+++ b/Libraries/LibWeb/Crypto/SubtleCrypto.h
@@ -20,26 +20,26 @@ namespace Web::Crypto {
 
 class SubtleCrypto final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SubtleCrypto, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SubtleCrypto);
+    GC_DECLARE_ALLOCATOR(SubtleCrypto);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SubtleCrypto> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<SubtleCrypto> create(JS::Realm&);
 
     virtual ~SubtleCrypto() override;
 
-    JS::NonnullGCPtr<WebIDL::Promise> encrypt(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter);
-    JS::NonnullGCPtr<WebIDL::Promise> decrypt(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter);
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> sign(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& data_parameter);
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> verify(AlgorithmIdentifier const& algorithm, JS::NonnullGCPtr<CryptoKey> key, JS::Handle<WebIDL::BufferSource> const& signature, JS::Handle<WebIDL::BufferSource> const& data_parameter);
+    GC::Ref<WebIDL::Promise> encrypt(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter);
+    GC::Ref<WebIDL::Promise> decrypt(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> sign(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& data_parameter);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> verify(AlgorithmIdentifier const& algorithm, GC::Ref<CryptoKey> key, GC::Root<WebIDL::BufferSource> const& signature, GC::Root<WebIDL::BufferSource> const& data_parameter);
 
-    JS::NonnullGCPtr<WebIDL::Promise> digest(AlgorithmIdentifier const& algorithm, JS::Handle<WebIDL::BufferSource> const& data);
+    GC::Ref<WebIDL::Promise> digest(AlgorithmIdentifier const& algorithm, GC::Root<WebIDL::BufferSource> const& data);
 
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> generate_key(AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages);
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> derive_bits(AlgorithmIdentifier algorithm, JS::NonnullGCPtr<CryptoKey> base_key, u32 length);
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> derive_key(AlgorithmIdentifier algorithm, JS::NonnullGCPtr<CryptoKey> base_key, AlgorithmIdentifier derived_key_type, bool extractable, Vector<Bindings::KeyUsage> key_usages);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> generate_key(AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> derive_bits(AlgorithmIdentifier algorithm, GC::Ref<CryptoKey> base_key, u32 length);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> derive_key(AlgorithmIdentifier algorithm, GC::Ref<CryptoKey> base_key, AlgorithmIdentifier derived_key_type, bool extractable, Vector<Bindings::KeyUsage> key_usages);
 
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> import_key(Bindings::KeyFormat format, KeyDataType key_data, AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages);
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::Promise>> export_key(Bindings::KeyFormat format, JS::NonnullGCPtr<CryptoKey> key);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> import_key(Bindings::KeyFormat format, KeyDataType key_data, AlgorithmIdentifier algorithm, bool extractable, Vector<Bindings::KeyUsage> key_usages);
+    JS::ThrowCompletionOr<GC::Ref<WebIDL::Promise>> export_key(Bindings::KeyFormat format, GC::Ref<CryptoKey> key);
 
 private:
     explicit SubtleCrypto(JS::Realm&);
diff --git a/Libraries/LibWeb/DOM/AbortController.cpp b/Libraries/LibWeb/DOM/AbortController.cpp
index 232eb38c958..c777002b520 100644
--- a/Libraries/LibWeb/DOM/AbortController.cpp
+++ b/Libraries/LibWeb/DOM/AbortController.cpp
@@ -11,16 +11,16 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(AbortController);
+GC_DEFINE_ALLOCATOR(AbortController);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortController>> AbortController::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<AbortController>> AbortController::construct_impl(JS::Realm& realm)
 {
     auto signal = TRY(AbortSignal::construct_impl(realm));
     return realm.create<AbortController>(realm, move(signal));
 }
 
 // https://dom.spec.whatwg.org/#dom-abortcontroller-abortcontroller
-AbortController::AbortController(JS::Realm& realm, JS::NonnullGCPtr<AbortSignal> signal)
+AbortController::AbortController(JS::Realm& realm, GC::Ref<AbortSignal> signal)
     : PlatformObject(realm)
     , m_signal(move(signal))
 {
diff --git a/Libraries/LibWeb/DOM/AbortController.h b/Libraries/LibWeb/DOM/AbortController.h
index 76ffbadf8a7..049c12322ae 100644
--- a/Libraries/LibWeb/DOM/AbortController.h
+++ b/Libraries/LibWeb/DOM/AbortController.h
@@ -14,26 +14,26 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#abortcontroller
 class AbortController final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AbortController, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AbortController);
+    GC_DECLARE_ALLOCATOR(AbortController);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortController>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<AbortController>> construct_impl(JS::Realm&);
 
     virtual ~AbortController() override;
 
     // https://dom.spec.whatwg.org/#dom-abortcontroller-signal
-    JS::NonnullGCPtr<AbortSignal> signal() const { return *m_signal; }
+    GC::Ref<AbortSignal> signal() const { return *m_signal; }
 
     void abort(JS::Value reason);
 
 private:
-    AbortController(JS::Realm&, JS::NonnullGCPtr<AbortSignal>);
+    AbortController(JS::Realm&, GC::Ref<AbortSignal>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://dom.spec.whatwg.org/#abortcontroller-signal
-    JS::NonnullGCPtr<AbortSignal> m_signal;
+    GC::Ref<AbortSignal> m_signal;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/AbortSignal.cpp b/Libraries/LibWeb/DOM/AbortSignal.cpp
index 1c34ad98bc8..f3f7bfe78d6 100644
--- a/Libraries/LibWeb/DOM/AbortSignal.cpp
+++ b/Libraries/LibWeb/DOM/AbortSignal.cpp
@@ -16,9 +16,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(AbortSignal);
+GC_DEFINE_ALLOCATOR(AbortSignal);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<AbortSignal>> AbortSignal::construct_impl(JS::Realm& realm)
 {
     return realm.create<AbortSignal>(realm);
 }
@@ -42,7 +42,7 @@ void AbortSignal::add_abort_algorithm(Function<void()> abort_algorithm)
         return;
 
     // 2. Append algorithm to signal’s abort algorithms.
-    m_abort_algorithms.append(JS::create_heap_function(vm().heap(), move(abort_algorithm)));
+    m_abort_algorithms.append(GC::create_function(vm().heap(), move(abort_algorithm)));
 }
 
 // https://dom.spec.whatwg.org/#abortsignal-signal-abort
@@ -59,7 +59,7 @@ void AbortSignal::signal_abort(JS::Value reason)
         m_abort_reason = WebIDL::AbortError::create(realm(), "Aborted without reason"_string).ptr();
 
     // 3. Let dependentSignalsToAbort be a new list.
-    Vector<JS::Handle<AbortSignal>> dependent_signals_to_abort;
+    Vector<GC::Root<AbortSignal>> dependent_signals_to_abort;
 
     // 4. For each dependentSignal of signal’s dependent signals:
     for (auto const& dependent_signal : m_dependent_signals) {
@@ -126,7 +126,7 @@ void AbortSignal::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-abortsignal-abort
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::abort(JS::VM& vm, JS::Value reason)
+WebIDL::ExceptionOr<GC::Ref<AbortSignal>> AbortSignal::abort(JS::VM& vm, JS::Value reason)
 {
     // 1. Let signal be a new AbortSignal object.
     auto signal = TRY(construct_impl(*vm.current_realm()));
@@ -142,7 +142,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::abort(JS::VM& vm
 }
 
 // https://dom.spec.whatwg.org/#dom-abortsignal-timeout
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::timeout(JS::VM& vm, WebIDL::UnsignedLongLong milliseconds)
+WebIDL::ExceptionOr<GC::Ref<AbortSignal>> AbortSignal::timeout(JS::VM& vm, WebIDL::UnsignedLongLong milliseconds)
 {
     auto& realm = *vm.current_realm();
 
@@ -157,7 +157,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::timeout(JS::VM&
     // 3. Run steps after a timeout given global, "AbortSignal-timeout", milliseconds, and the following step:
     window_or_worker->run_steps_after_a_timeout(milliseconds, [&realm, &global, signal]() {
         // 1. Queue a global task on the timer task source given global to signal abort given signal and a new "TimeoutError" DOMException.
-        HTML::queue_global_task(HTML::Task::Source::TimerTask, global, JS::create_heap_function(realm.heap(), [&realm, signal]() mutable {
+        HTML::queue_global_task(HTML::Task::Source::TimerTask, global, GC::create_function(realm.heap(), [&realm, signal]() mutable {
             auto reason = WebIDL::TimeoutError::create(realm, "Signal timed out"_string);
             signal->signal_abort(reason);
         }));
@@ -168,14 +168,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::timeout(JS::VM&
 }
 
 // https://dom.spec.whatwg.org/#dom-abortsignal-any
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::any(JS::VM& vm, Vector<JS::Handle<AbortSignal>> const& signals)
+WebIDL::ExceptionOr<GC::Ref<AbortSignal>> AbortSignal::any(JS::VM& vm, Vector<GC::Root<AbortSignal>> const& signals)
 {
     // The static any(signals) method steps are to return the result of creating a dependent abort signal from signals using AbortSignal and the current realm.
     return create_dependent_abort_signal(*vm.current_realm(), signals);
 }
 
 // https://dom.spec.whatwg.org/#create-a-dependent-abort-signal
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> AbortSignal::create_dependent_abort_signal(JS::Realm& realm, Vector<JS::Handle<AbortSignal>> const& signals)
+WebIDL::ExceptionOr<GC::Ref<AbortSignal>> AbortSignal::create_dependent_abort_signal(JS::Realm& realm, Vector<GC::Root<AbortSignal>> const& signals)
 {
     // 1. Let resultSignal be a new object implementing signalInterface using realm.
     auto result_signal = TRY(construct_impl(realm));
diff --git a/Libraries/LibWeb/DOM/AbortSignal.h b/Libraries/LibWeb/DOM/AbortSignal.h
index 1c60eef1ed2..ac5f518218c 100644
--- a/Libraries/LibWeb/DOM/AbortSignal.h
+++ b/Libraries/LibWeb/DOM/AbortSignal.h
@@ -9,7 +9,7 @@
 
 #include <AK/RefCounted.h>
 #include <AK/Weakable.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/WebIDL/Types.h>
@@ -19,10 +19,10 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#abortsignal
 class AbortSignal final : public EventTarget {
     WEB_PLATFORM_OBJECT(AbortSignal, EventTarget);
-    JS_DECLARE_ALLOCATOR(AbortSignal);
+    GC_DECLARE_ALLOCATOR(AbortSignal);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<AbortSignal>> construct_impl(JS::Realm&);
 
     virtual ~AbortSignal() override = default;
 
@@ -43,11 +43,11 @@ public:
 
     JS::ThrowCompletionOr<void> throw_if_aborted() const;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> abort(JS::VM&, JS::Value reason);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> timeout(JS::VM&, Web::WebIDL::UnsignedLongLong milliseconds);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> any(JS::VM&, Vector<JS::Handle<AbortSignal>> const&);
+    static WebIDL::ExceptionOr<GC::Ref<AbortSignal>> abort(JS::VM&, JS::Value reason);
+    static WebIDL::ExceptionOr<GC::Ref<AbortSignal>> timeout(JS::VM&, Web::WebIDL::UnsignedLongLong milliseconds);
+    static WebIDL::ExceptionOr<GC::Ref<AbortSignal>> any(JS::VM&, Vector<GC::Root<AbortSignal>> const&);
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AbortSignal>> create_dependent_abort_signal(JS::Realm&, Vector<JS::Handle<AbortSignal>> const&);
+    static WebIDL::ExceptionOr<GC::Ref<AbortSignal>> create_dependent_abort_signal(JS::Realm&, Vector<GC::Root<AbortSignal>> const&);
 
 private:
     explicit AbortSignal(JS::Realm&);
@@ -58,10 +58,10 @@ private:
     bool dependent() const { return m_dependent; }
     void set_dependent(bool dependent) { m_dependent = dependent; }
 
-    Vector<JS::GCPtr<AbortSignal>> source_signals() const { return m_source_signals; }
+    Vector<GC::Ptr<AbortSignal>> source_signals() const { return m_source_signals; }
 
-    void append_source_signal(JS::GCPtr<AbortSignal> source_signal) { m_source_signals.append(source_signal); }
-    void append_dependent_signal(JS::GCPtr<AbortSignal> dependent_signal) { m_dependent_signals.append(dependent_signal); }
+    void append_source_signal(GC::Ptr<AbortSignal> source_signal) { m_source_signals.append(source_signal); }
+    void append_dependent_signal(GC::Ptr<AbortSignal> dependent_signal) { m_dependent_signals.append(dependent_signal); }
 
     // https://dom.spec.whatwg.org/#abortsignal-abort-reason
     // An AbortSignal object has an associated abort reason, which is a JavaScript value. It is undefined unless specified otherwise.
@@ -69,15 +69,15 @@ private:
 
     // https://dom.spec.whatwg.org/#abortsignal-abort-algorithms
     // FIXME: This should be a set.
-    Vector<JS::NonnullGCPtr<JS::HeapFunction<void()>>> m_abort_algorithms;
+    Vector<GC::Ref<GC::Function<void()>>> m_abort_algorithms;
 
     // https://dom.spec.whatwg.org/#abortsignal-source-signals
     // An AbortSignal object has associated source signals (a weak set of AbortSignal objects that the object is dependent on for its aborted state), which is initially empty.
-    Vector<JS::GCPtr<AbortSignal>> m_source_signals;
+    Vector<GC::Ptr<AbortSignal>> m_source_signals;
 
     // https://dom.spec.whatwg.org/#abortsignal-dependent-signals
     // An AbortSignal object has associated dependent signals (a weak set of AbortSignal objects that are dependent on the object for their aborted state), which is initially empty.
-    Vector<JS::GCPtr<AbortSignal>> m_dependent_signals;
+    Vector<GC::Ptr<AbortSignal>> m_dependent_signals;
 
     // https://dom.spec.whatwg.org/#abortsignal-dependent
     // An AbortSignal object has a dependent (a boolean), which is initially false.
diff --git a/Libraries/LibWeb/DOM/AbstractRange.h b/Libraries/LibWeb/DOM/AbstractRange.h
index b7390d8eadf..28eb6f17a15 100644
--- a/Libraries/LibWeb/DOM/AbstractRange.h
+++ b/Libraries/LibWeb/DOM/AbstractRange.h
@@ -41,10 +41,10 @@ protected:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<Node> m_start_container;
+    GC::Ref<Node> m_start_container;
     WebIDL::UnsignedLong m_start_offset;
 
-    JS::NonnullGCPtr<Node> m_end_container;
+    GC::Ref<Node> m_end_container;
     WebIDL::UnsignedLong m_end_offset;
 };
 
diff --git a/Libraries/LibWeb/DOM/AccessibilityTreeNode.cpp b/Libraries/LibWeb/DOM/AccessibilityTreeNode.cpp
index 8a0c173e71d..d6b9fd035a9 100644
--- a/Libraries/LibWeb/DOM/AccessibilityTreeNode.cpp
+++ b/Libraries/LibWeb/DOM/AccessibilityTreeNode.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(AccessibilityTreeNode);
+GC_DEFINE_ALLOCATOR(AccessibilityTreeNode);
 
-JS::NonnullGCPtr<AccessibilityTreeNode> AccessibilityTreeNode::create(Document* document, DOM::Node const* value)
+GC::Ref<AccessibilityTreeNode> AccessibilityTreeNode::create(Document* document, DOM::Node const* value)
 {
     return document->realm().create<AccessibilityTreeNode>(value);
 }
 
-AccessibilityTreeNode::AccessibilityTreeNode(JS::GCPtr<DOM::Node const> value)
+AccessibilityTreeNode::AccessibilityTreeNode(GC::Ptr<DOM::Node const> value)
     : m_value(value)
 {
     m_children = {};
diff --git a/Libraries/LibWeb/DOM/AccessibilityTreeNode.h b/Libraries/LibWeb/DOM/AccessibilityTreeNode.h
index 123eadfbc88..70ff7a09287 100644
--- a/Libraries/LibWeb/DOM/AccessibilityTreeNode.h
+++ b/Libraries/LibWeb/DOM/AccessibilityTreeNode.h
@@ -8,24 +8,24 @@
 
 #include <AK/JsonObjectSerializer.h>
 #include <AK/Vector.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibWeb/DOM/Node.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::DOM {
 
 class AccessibilityTreeNode final : public JS::Cell {
-    JS_CELL(AccessibilityTreeNode, JS::Cell);
-    JS_DECLARE_ALLOCATOR(AccessibilityTreeNode);
+    GC_CELL(AccessibilityTreeNode, JS::Cell);
+    GC_DECLARE_ALLOCATOR(AccessibilityTreeNode);
 
 public:
-    static JS::NonnullGCPtr<AccessibilityTreeNode> create(Document*, DOM::Node const*);
+    static GC::Ref<AccessibilityTreeNode> create(Document*, DOM::Node const*);
     virtual ~AccessibilityTreeNode() override = default;
 
-    JS::GCPtr<DOM::Node const> value() const { return m_value; }
-    void set_value(JS::GCPtr<DOM::Node const> value) { m_value = value; }
-    Vector<JS::GCPtr<AccessibilityTreeNode>> children() const { return m_children; }
+    GC::Ptr<DOM::Node const> value() const { return m_value; }
+    void set_value(GC::Ptr<DOM::Node const> value) { m_value = value; }
+    Vector<GC::Ptr<AccessibilityTreeNode>> children() const { return m_children; }
     void append_child(AccessibilityTreeNode* child) { m_children.append(child); }
 
     void serialize_tree_as_json(JsonObjectSerializer<StringBuilder>& object, Document const&) const;
@@ -34,10 +34,10 @@ protected:
     virtual void visit_edges(Visitor&) override;
 
 private:
-    explicit AccessibilityTreeNode(JS::GCPtr<DOM::Node const>);
+    explicit AccessibilityTreeNode(GC::Ptr<DOM::Node const>);
 
-    JS::GCPtr<DOM::Node const> m_value;
-    Vector<JS::GCPtr<AccessibilityTreeNode>> m_children;
+    GC::Ptr<DOM::Node const> m_value;
+    Vector<GC::Ptr<AccessibilityTreeNode>> m_children;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/AdoptedStyleSheets.cpp b/Libraries/LibWeb/DOM/AdoptedStyleSheets.cpp
index a35146e2906..7e1e611f1ce 100644
--- a/Libraries/LibWeb/DOM/AdoptedStyleSheets.cpp
+++ b/Libraries/LibWeb/DOM/AdoptedStyleSheets.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::DOM {
 
-JS::NonnullGCPtr<WebIDL::ObservableArray> create_adopted_style_sheets_list(Document& document)
+GC::Ref<WebIDL::ObservableArray> create_adopted_style_sheets_list(Document& document)
 {
     auto adopted_style_sheets = WebIDL::ObservableArray::create(document.realm());
     adopted_style_sheets->set_on_set_an_indexed_value_callback([&document](JS::Value& value) -> WebIDL::ExceptionOr<void> {
diff --git a/Libraries/LibWeb/DOM/AdoptedStyleSheets.h b/Libraries/LibWeb/DOM/AdoptedStyleSheets.h
index dbb21ab76cb..3973041a2a9 100644
--- a/Libraries/LibWeb/DOM/AdoptedStyleSheets.h
+++ b/Libraries/LibWeb/DOM/AdoptedStyleSheets.h
@@ -11,6 +11,6 @@
 
 namespace Web::DOM {
 
-JS::NonnullGCPtr<WebIDL::ObservableArray> create_adopted_style_sheets_list(Document& document);
+GC::Ref<WebIDL::ObservableArray> create_adopted_style_sheets_list(Document& document);
 
 }
diff --git a/Libraries/LibWeb/DOM/Attr.cpp b/Libraries/LibWeb/DOM/Attr.cpp
index e0971f27d14..8ce937757ec 100644
--- a/Libraries/LibWeb/DOM/Attr.cpp
+++ b/Libraries/LibWeb/DOM/Attr.cpp
@@ -16,19 +16,19 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Attr);
+GC_DEFINE_ALLOCATOR(Attr);
 
-JS::NonnullGCPtr<Attr> Attr::create(Document& document, FlyString local_name, String value, Element* owner_element)
+GC::Ref<Attr> Attr::create(Document& document, FlyString local_name, String value, Element* owner_element)
 {
     return document.realm().create<Attr>(document, QualifiedName(move(local_name), Optional<FlyString> {}, Optional<FlyString> {}), move(value), owner_element);
 }
 
-JS::NonnullGCPtr<Attr> Attr::create(Document& document, QualifiedName qualified_name, String value, Element* owner_element)
+GC::Ref<Attr> Attr::create(Document& document, QualifiedName qualified_name, String value, Element* owner_element)
 {
     return document.realm().create<Attr>(document, move(qualified_name), move(value), owner_element);
 }
 
-JS::NonnullGCPtr<Attr> Attr::clone(Document& document)
+GC::Ref<Attr> Attr::clone(Document& document)
 {
     return realm().create<Attr>(document, m_qualified_name, m_value, nullptr);
 }
@@ -105,7 +105,7 @@ void Attr::handle_attribute_changes(Element& element, Optional<String> const& ol
     if (element.is_custom()) {
         auto& vm = this->vm();
 
-        JS::MarkedVector<JS::Value> arguments { vm.heap() };
+        GC::MarkedVector<JS::Value> arguments { vm.heap() };
         arguments.append(JS::PrimitiveString::create(vm, local_name()));
         arguments.append(!old_value.has_value() ? JS::js_null() : JS::PrimitiveString::create(vm, old_value.value()));
         arguments.append(!new_value.has_value() ? JS::js_null() : JS::PrimitiveString::create(vm, new_value.value()));
diff --git a/Libraries/LibWeb/DOM/Attr.h b/Libraries/LibWeb/DOM/Attr.h
index 43a418a7dc1..3b2791e80f8 100644
--- a/Libraries/LibWeb/DOM/Attr.h
+++ b/Libraries/LibWeb/DOM/Attr.h
@@ -15,12 +15,12 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#attr
 class Attr final : public Node {
     WEB_PLATFORM_OBJECT(Attr, Node);
-    JS_DECLARE_ALLOCATOR(Attr);
+    GC_DECLARE_ALLOCATOR(Attr);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Attr> create(Document&, QualifiedName, String value = {}, Element* = nullptr);
-    [[nodiscard]] static JS::NonnullGCPtr<Attr> create(Document&, FlyString local_name, String value = {}, Element* = nullptr);
-    JS::NonnullGCPtr<Attr> clone(Document&);
+    [[nodiscard]] static GC::Ref<Attr> create(Document&, QualifiedName, String value = {}, Element* = nullptr);
+    [[nodiscard]] static GC::Ref<Attr> create(Document&, FlyString local_name, String value = {}, Element* = nullptr);
+    GC::Ref<Attr> clone(Document&);
 
     virtual ~Attr() override = default;
 
@@ -54,7 +54,7 @@ private:
     QualifiedName m_qualified_name;
     FlyString m_lowercase_name;
     String m_value;
-    JS::GCPtr<Element> m_owner_element;
+    GC::Ptr<Element> m_owner_element;
 };
 
 template<>
diff --git a/Libraries/LibWeb/DOM/CDATASection.cpp b/Libraries/LibWeb/DOM/CDATASection.cpp
index 304aa1ad755..69e2f636fb7 100644
--- a/Libraries/LibWeb/DOM/CDATASection.cpp
+++ b/Libraries/LibWeb/DOM/CDATASection.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(CDATASection);
+GC_DEFINE_ALLOCATOR(CDATASection);
 
 CDATASection::CDATASection(Document& document, String const& data)
     : Text(document, NodeType::CDATA_SECTION_NODE, data)
diff --git a/Libraries/LibWeb/DOM/CDATASection.h b/Libraries/LibWeb/DOM/CDATASection.h
index 4279570f17e..f0f2099bee6 100644
--- a/Libraries/LibWeb/DOM/CDATASection.h
+++ b/Libraries/LibWeb/DOM/CDATASection.h
@@ -13,7 +13,7 @@ namespace Web::DOM {
 
 class CDATASection final : public Text {
     WEB_PLATFORM_OBJECT(CDATASection, Text);
-    JS_DECLARE_ALLOCATOR(CDATASection);
+    GC_DECLARE_ALLOCATOR(CDATASection);
 
 public:
     virtual ~CDATASection() override;
diff --git a/Libraries/LibWeb/DOM/CharacterData.cpp b/Libraries/LibWeb/DOM/CharacterData.cpp
index 7dd4c71e02a..7fd76e43fe0 100644
--- a/Libraries/LibWeb/DOM/CharacterData.cpp
+++ b/Libraries/LibWeb/DOM/CharacterData.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(CharacterData);
+GC_DEFINE_ALLOCATOR(CharacterData);
 
 CharacterData::CharacterData(Document& document, NodeType type, String const& data)
     : Node(document, type)
diff --git a/Libraries/LibWeb/DOM/CharacterData.h b/Libraries/LibWeb/DOM/CharacterData.h
index 6e011b86af4..630f82abe84 100644
--- a/Libraries/LibWeb/DOM/CharacterData.h
+++ b/Libraries/LibWeb/DOM/CharacterData.h
@@ -21,7 +21,7 @@ class CharacterData
     , public ChildNode<CharacterData>
     , public NonDocumentTypeChildNode<CharacterData> {
     WEB_PLATFORM_OBJECT(CharacterData, Node);
-    JS_DECLARE_ALLOCATOR(CharacterData);
+    GC_DECLARE_ALLOCATOR(CharacterData);
 
 public:
     virtual ~CharacterData() override;
diff --git a/Libraries/LibWeb/DOM/ChildNode.h b/Libraries/LibWeb/DOM/ChildNode.h
index a8f97ecaf72..2440c88c211 100644
--- a/Libraries/LibWeb/DOM/ChildNode.h
+++ b/Libraries/LibWeb/DOM/ChildNode.h
@@ -16,7 +16,7 @@ template<typename NodeType>
 class ChildNode {
 public:
     // https://dom.spec.whatwg.org/#dom-childnode-before
-    WebIDL::ExceptionOr<void> before(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+    WebIDL::ExceptionOr<void> before(Vector<Variant<GC::Root<Node>, String>> const& nodes)
     {
         auto* node = static_cast<NodeType*>(this);
 
@@ -46,7 +46,7 @@ public:
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-after
-    WebIDL::ExceptionOr<void> after(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+    WebIDL::ExceptionOr<void> after(Vector<Variant<GC::Root<Node>, String>> const& nodes)
     {
         auto* node = static_cast<NodeType*>(this);
 
@@ -70,7 +70,7 @@ public:
     }
 
     // https://dom.spec.whatwg.org/#dom-childnode-replacewith
-    WebIDL::ExceptionOr<void> replace_with(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+    WebIDL::ExceptionOr<void> replace_with(Vector<Variant<GC::Root<Node>, String>> const& nodes)
     {
         auto* node = static_cast<NodeType*>(this);
 
@@ -117,7 +117,7 @@ protected:
     ChildNode() = default;
 
 private:
-    JS::GCPtr<Node> viable_previous_sibling_for_insertion(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+    GC::Ptr<Node> viable_previous_sibling_for_insertion(Vector<Variant<GC::Root<Node>, String>> const& nodes)
     {
         auto* node = static_cast<NodeType*>(this);
 
@@ -125,10 +125,10 @@ private:
             bool contained_in_nodes = false;
 
             for (auto const& node_or_string : nodes) {
-                if (!node_or_string.template has<JS::Handle<Node>>())
+                if (!node_or_string.template has<GC::Root<Node>>())
                     continue;
 
-                auto const& node_in_vector = node_or_string.template get<JS::Handle<Node>>();
+                auto const& node_in_vector = node_or_string.template get<GC::Root<Node>>();
                 if (node_in_vector.cell() == sibling) {
                     contained_in_nodes = true;
                     break;
@@ -142,7 +142,7 @@ private:
         return nullptr;
     }
 
-    JS::GCPtr<Node> viable_next_sibling_for_insertion(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+    GC::Ptr<Node> viable_next_sibling_for_insertion(Vector<Variant<GC::Root<Node>, String>> const& nodes)
     {
         auto* node = static_cast<NodeType*>(this);
 
@@ -150,10 +150,10 @@ private:
             bool contained_in_nodes = false;
 
             for (auto const& node_or_string : nodes) {
-                if (!node_or_string.template has<JS::Handle<Node>>())
+                if (!node_or_string.template has<GC::Root<Node>>())
                     continue;
 
-                auto const& node_in_vector = node_or_string.template get<JS::Handle<Node>>();
+                auto const& node_in_vector = node_or_string.template get<GC::Root<Node>>();
                 if (node_in_vector.cell() == sibling) {
                     contained_in_nodes = true;
                     break;
diff --git a/Libraries/LibWeb/DOM/Comment.cpp b/Libraries/LibWeb/DOM/Comment.cpp
index 6025b79d026..85f299f4bd3 100644
--- a/Libraries/LibWeb/DOM/Comment.cpp
+++ b/Libraries/LibWeb/DOM/Comment.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Comment);
+GC_DEFINE_ALLOCATOR(Comment);
 
 Comment::Comment(Document& document, String const& data)
     : CharacterData(document, NodeType::COMMENT_NODE, data)
@@ -19,7 +19,7 @@ Comment::Comment(Document& document, String const& data)
 }
 
 // https://dom.spec.whatwg.org/#dom-comment-comment
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Comment>> Comment::construct_impl(JS::Realm& realm, String const& data)
+WebIDL::ExceptionOr<GC::Ref<Comment>> Comment::construct_impl(JS::Realm& realm, String const& data)
 {
     auto& window = verify_cast<HTML::Window>(realm.global_object());
     return realm.create<Comment>(window.associated_document(), data);
diff --git a/Libraries/LibWeb/DOM/Comment.h b/Libraries/LibWeb/DOM/Comment.h
index 2ab91bb68b2..0dfe6a04a4a 100644
--- a/Libraries/LibWeb/DOM/Comment.h
+++ b/Libraries/LibWeb/DOM/Comment.h
@@ -12,10 +12,10 @@ namespace Web::DOM {
 
 class Comment final : public CharacterData {
     WEB_PLATFORM_OBJECT(Comment, CharacterData);
-    JS_DECLARE_ALLOCATOR(Comment);
+    GC_DECLARE_ALLOCATOR(Comment);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Comment>> construct_impl(JS::Realm&, String const& data);
+    static WebIDL::ExceptionOr<GC::Ref<Comment>> construct_impl(JS::Realm&, String const& data);
     virtual ~Comment() override = default;
 
     virtual FlyString node_name() const override { return "#comment"_fly_string; }
diff --git a/Libraries/LibWeb/DOM/CustomEvent.cpp b/Libraries/LibWeb/DOM/CustomEvent.cpp
index 63a2cfd41a0..eeac13ea947 100644
--- a/Libraries/LibWeb/DOM/CustomEvent.cpp
+++ b/Libraries/LibWeb/DOM/CustomEvent.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(CustomEvent);
+GC_DEFINE_ALLOCATOR(CustomEvent);
 
-JS::NonnullGCPtr<CustomEvent> CustomEvent::create(JS::Realm& realm, FlyString const& event_name, CustomEventInit const& event_init)
+GC::Ref<CustomEvent> CustomEvent::create(JS::Realm& realm, FlyString const& event_name, CustomEventInit const& event_init)
 {
     return realm.create<CustomEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CustomEvent>> CustomEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CustomEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<CustomEvent>> CustomEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CustomEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/DOM/CustomEvent.h b/Libraries/LibWeb/DOM/CustomEvent.h
index 94fa007f187..b6be322f6ad 100644
--- a/Libraries/LibWeb/DOM/CustomEvent.h
+++ b/Libraries/LibWeb/DOM/CustomEvent.h
@@ -19,11 +19,11 @@ struct CustomEventInit : public EventInit {
 // https://dom.spec.whatwg.org/#customevent
 class CustomEvent : public Event {
     WEB_PLATFORM_OBJECT(CustomEvent, Event);
-    JS_DECLARE_ALLOCATOR(CustomEvent);
+    GC_DECLARE_ALLOCATOR(CustomEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CustomEvent> create(JS::Realm&, FlyString const& event_name, CustomEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CustomEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CustomEventInit const&);
+    [[nodiscard]] static GC::Ref<CustomEvent> create(JS::Realm&, FlyString const& event_name, CustomEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<CustomEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CustomEventInit const&);
 
     virtual ~CustomEvent() override;
 
diff --git a/Libraries/LibWeb/DOM/DOMEventListener.cpp b/Libraries/LibWeb/DOM/DOMEventListener.cpp
index f38451143b9..ee1d701f349 100644
--- a/Libraries/LibWeb/DOM/DOMEventListener.cpp
+++ b/Libraries/LibWeb/DOM/DOMEventListener.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DOMEventListener);
+GC_DEFINE_ALLOCATOR(DOMEventListener);
 
 DOMEventListener::DOMEventListener() = default;
 DOMEventListener::~DOMEventListener() = default;
diff --git a/Libraries/LibWeb/DOM/DOMEventListener.h b/Libraries/LibWeb/DOM/DOMEventListener.h
index 5257936eac3..6231ee047ea 100644
--- a/Libraries/LibWeb/DOM/DOMEventListener.h
+++ b/Libraries/LibWeb/DOM/DOMEventListener.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/FlyString.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Runtime/Object.h>
 #include <LibWeb/Forward.h>
 
@@ -16,8 +16,8 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#concept-event-listener
 // NOTE: The spec calls this "event listener", and it's *importantly* not the same as "EventListener"
 class DOMEventListener : public JS::Cell {
-    JS_CELL(DOMEventListener, JS::Cell);
-    JS_DECLARE_ALLOCATOR(DOMEventListener);
+    GC_CELL(DOMEventListener, JS::Cell);
+    GC_DECLARE_ALLOCATOR(DOMEventListener);
 
 public:
     DOMEventListener();
@@ -27,10 +27,10 @@ public:
     FlyString type;
 
     // callback (null or an EventListener object)
-    JS::GCPtr<IDLEventListener> callback;
+    GC::Ptr<IDLEventListener> callback;
 
     // signal (null or an AbortSignal object)
-    JS::GCPtr<DOM::AbortSignal> signal;
+    GC::Ptr<DOM::AbortSignal> signal;
 
     // capture (a boolean, initially false)
     bool capture { false };
diff --git a/Libraries/LibWeb/DOM/DOMImplementation.cpp b/Libraries/LibWeb/DOM/DOMImplementation.cpp
index bddb4b5d417..d5cad4ff318 100644
--- a/Libraries/LibWeb/DOM/DOMImplementation.cpp
+++ b/Libraries/LibWeb/DOM/DOMImplementation.cpp
@@ -19,9 +19,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DOMImplementation);
+GC_DEFINE_ALLOCATOR(DOMImplementation);
 
-JS::NonnullGCPtr<DOMImplementation> DOMImplementation::create(Document& document)
+GC::Ref<DOMImplementation> DOMImplementation::create(Document& document)
 {
     auto& realm = document.realm();
     return realm.create<DOMImplementation>(document);
@@ -48,7 +48,7 @@ void DOMImplementation::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-domimplementation-createdocument
-WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLDocument>> DOMImplementation::create_document(Optional<FlyString> const& namespace_, String const& qualified_name, JS::GCPtr<DocumentType> doctype) const
+WebIDL::ExceptionOr<GC::Ref<XMLDocument>> DOMImplementation::create_document(Optional<FlyString> const& namespace_, String const& qualified_name, GC::Ptr<DocumentType> doctype) const
 {
     // 1. Let document be a new XMLDocument
     auto xml_document = XMLDocument::create(realm());
@@ -56,7 +56,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLDocument>> DOMImplementation::create_doc
     xml_document->set_ready_for_post_load_tasks(true);
 
     // 2. Let element be null.
-    JS::GCPtr<Element> element;
+    GC::Ptr<Element> element;
 
     // 3. If qualifiedName is not the empty string, then set element to the result of running the internal createElementNS steps, given document, namespace, qualifiedName, and an empty dictionary.
     if (!qualified_name.is_empty())
@@ -90,7 +90,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLDocument>> DOMImplementation::create_doc
 }
 
 // https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
-JS::NonnullGCPtr<Document> DOMImplementation::create_html_document(Optional<String> const& title) const
+GC::Ref<Document> DOMImplementation::create_html_document(Optional<String> const& title) const
 {
     // 1. Let doc be a new document that is an HTML document.
     auto html_document = HTML::HTMLDocument::create(realm());
@@ -137,7 +137,7 @@ JS::NonnullGCPtr<Document> DOMImplementation::create_html_document(Optional<Stri
 }
 
 // https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentType>> DOMImplementation::create_document_type(String const& qualified_name, String const& public_id, String const& system_id)
+WebIDL::ExceptionOr<GC::Ref<DocumentType>> DOMImplementation::create_document_type(String const& qualified_name, String const& public_id, String const& system_id)
 {
     // 1. Validate qualifiedName.
     TRY(Document::validate_qualified_name(realm(), qualified_name));
diff --git a/Libraries/LibWeb/DOM/DOMImplementation.h b/Libraries/LibWeb/DOM/DOMImplementation.h
index 829c92971ca..d131ef2f798 100644
--- a/Libraries/LibWeb/DOM/DOMImplementation.h
+++ b/Libraries/LibWeb/DOM/DOMImplementation.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/DOM/Document.h>
 
@@ -15,15 +15,15 @@ namespace Web::DOM {
 
 class DOMImplementation final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMImplementation, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMImplementation);
+    GC_DECLARE_ALLOCATOR(DOMImplementation);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DOMImplementation> create(Document&);
+    [[nodiscard]] static GC::Ref<DOMImplementation> create(Document&);
     virtual ~DOMImplementation();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLDocument>> create_document(Optional<FlyString> const&, String const&, JS::GCPtr<DocumentType>) const;
-    JS::NonnullGCPtr<Document> create_html_document(Optional<String> const& title) const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentType>> create_document_type(String const& qualified_name, String const& public_id, String const& system_id);
+    WebIDL::ExceptionOr<GC::Ref<XMLDocument>> create_document(Optional<FlyString> const&, String const&, GC::Ptr<DocumentType>) const;
+    GC::Ref<Document> create_html_document(Optional<String> const& title) const;
+    WebIDL::ExceptionOr<GC::Ref<DocumentType>> create_document_type(String const& qualified_name, String const& public_id, String const& system_id);
 
     // https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
     bool has_feature() const
@@ -41,7 +41,7 @@ private:
     Document& document() { return m_document; }
     Document const& document() const { return m_document; }
 
-    JS::NonnullGCPtr<Document> m_document;
+    GC::Ref<Document> m_document;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/DOMTokenList.cpp b/Libraries/LibWeb/DOM/DOMTokenList.cpp
index 0e0920833c7..9ea2d4c012a 100644
--- a/Libraries/LibWeb/DOM/DOMTokenList.cpp
+++ b/Libraries/LibWeb/DOM/DOMTokenList.cpp
@@ -54,9 +54,9 @@ inline void replace_in_ordered_set(Vector<String>& set, String const& item, Stri
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DOMTokenList);
+GC_DEFINE_ALLOCATOR(DOMTokenList);
 
-JS::NonnullGCPtr<DOMTokenList> DOMTokenList::create(Element& associated_element, FlyString associated_attribute)
+GC::Ref<DOMTokenList> DOMTokenList::create(Element& associated_element, FlyString associated_attribute)
 {
     auto& realm = associated_element.realm();
     return realm.create<DOMTokenList>(associated_element, move(associated_attribute));
@@ -253,7 +253,7 @@ String DOMTokenList::value() const
 // https://dom.spec.whatwg.org/#ref-for-concept-element-attributes-set-value%E2%91%A2
 void DOMTokenList::set_value(String const& value)
 {
-    JS::GCPtr<DOM::Element> associated_element = m_associated_element.ptr();
+    GC::Ptr<DOM::Element> associated_element = m_associated_element.ptr();
     if (!associated_element)
         return;
 
@@ -284,7 +284,7 @@ WebIDL::ExceptionOr<void> DOMTokenList::validate_token_not_whitespace(StringView
 // https://dom.spec.whatwg.org/#concept-dtl-update
 void DOMTokenList::run_update_steps()
 {
-    JS::GCPtr<DOM::Element> associated_element = m_associated_element.ptr();
+    GC::Ptr<DOM::Element> associated_element = m_associated_element.ptr();
     if (!associated_element)
         return;
 
diff --git a/Libraries/LibWeb/DOM/DOMTokenList.h b/Libraries/LibWeb/DOM/DOMTokenList.h
index 5ccdcb4733a..6e171ea2488 100644
--- a/Libraries/LibWeb/DOM/DOMTokenList.h
+++ b/Libraries/LibWeb/DOM/DOMTokenList.h
@@ -22,10 +22,10 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#domtokenlist
 class DOMTokenList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMTokenList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMTokenList);
+    GC_DECLARE_ALLOCATOR(DOMTokenList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DOMTokenList> create(Element& associated_element, FlyString associated_attribute);
+    [[nodiscard]] static GC::Ref<DOMTokenList> create(Element& associated_element, FlyString associated_attribute);
     ~DOMTokenList() = default;
 
     void associated_attribute_changed(StringView value);
@@ -56,7 +56,7 @@ private:
 
     String serialize_ordered_set() const;
 
-    JS::NonnullGCPtr<Element> m_associated_element;
+    GC::Ref<Element> m_associated_element;
     FlyString m_associated_attribute;
     Vector<String> m_token_set;
 };
diff --git a/Libraries/LibWeb/DOM/Document.cpp b/Libraries/LibWeb/DOM/Document.cpp
index d90d2817e04..eefd4d6ab00 100644
--- a/Libraries/LibWeb/DOM/Document.cpp
+++ b/Libraries/LibWeb/DOM/Document.cpp
@@ -147,10 +147,10 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Document);
+GC_DEFINE_ALLOCATOR(Document);
 
 // https://html.spec.whatwg.org/multipage/origin.html#obtain-browsing-context-navigation
-static JS::NonnullGCPtr<HTML::BrowsingContext> obtain_a_browsing_context_to_use_for_a_navigation_response(
+static GC::Ref<HTML::BrowsingContext> obtain_a_browsing_context_to_use_for_a_navigation_response(
     HTML::BrowsingContext& browsing_context,
     HTML::SandboxingFlagSet sandbox_flags,
     HTML::OpenerPolicy navigation_coop,
@@ -191,7 +191,7 @@ static JS::NonnullGCPtr<HTML::BrowsingContext> obtain_a_browsing_context_to_use_
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#initialise-the-document-object
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> Document::create_and_initialize(Type type, String content_type, HTML::NavigationParams const& navigation_params)
+WebIDL::ExceptionOr<GC::Ref<Document>> Document::create_and_initialize(Type type, String content_type, HTML::NavigationParams const& navigation_params)
 {
     // 1. Let browsingContext be navigationParams's navigable's active browsing context.
     auto browsing_context = navigation_params.navigable->active_browsing_context();
@@ -216,7 +216,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> Document::create_and_initialize(
     }
 
     // 6. Let window be null.
-    JS::GCPtr<HTML::Window> window;
+    GC::Ptr<HTML::Window> window;
 
     // 7. If browsingContext's active document's is initial about:blank is true,
     //    and browsingContext's active document's origin is same origin-domain with navigationParams's origin,
@@ -367,17 +367,17 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> Document::create_and_initialize(
     return document;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> Document::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<Document>> Document::construct_impl(JS::Realm& realm)
 {
     return Document::create(realm);
 }
 
-JS::NonnullGCPtr<Document> Document::create(JS::Realm& realm, URL::URL const& url)
+GC::Ref<Document> Document::create(JS::Realm& realm, URL::URL const& url)
 {
     return realm.create<Document>(realm, url);
 }
 
-JS::NonnullGCPtr<Document> Document::create_for_fragment_parsing(JS::Realm& realm)
+GC::Ref<Document> Document::create_for_fragment_parsing(JS::Realm& realm)
 {
     return realm.create<Document>(realm, "about:blank"sv, TemporaryDocumentForFragmentParsing::Yes);
 }
@@ -533,7 +533,7 @@ void Document::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://w3c.github.io/selection-api/#dom-document-getselection
-JS::GCPtr<Selection::Selection> Document::get_selection() const
+GC::Ptr<Selection::Selection> Document::get_selection() const
 {
     // The method must return the selection associated with this if this has an associated browsing context,
     // and it must return null otherwise.
@@ -606,7 +606,7 @@ WebIDL::ExceptionOr<Document*> Document::open(Optional<String> const&, Optional<
     // because subsequent steps will modify "initial about:blank" to false, which would cause
     // initial navigation to fail in case it was "about:blank".
     if (auto navigable = this->navigable(); navigable && navigable->container() && !navigable->container()->content_navigable_initialized()) {
-        HTML::main_thread_event_loop().spin_processing_tasks_with_source_until(HTML::Task::Source::NavigationAndTraversal, JS::create_heap_function(heap(), [navigable_container = navigable->container()] {
+        HTML::main_thread_event_loop().spin_processing_tasks_with_source_until(HTML::Task::Source::NavigationAndTraversal, GC::create_function(heap(), [navigable_container = navigable->container()] {
             return navigable_container->content_navigable_initialized();
         }));
     }
@@ -680,7 +680,7 @@ WebIDL::ExceptionOr<Document*> Document::open(Optional<String> const&, Optional<
 }
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-document-open-window
-WebIDL::ExceptionOr<JS::GCPtr<HTML::WindowProxy>> Document::open(StringView url, StringView name, StringView features)
+WebIDL::ExceptionOr<GC::Ptr<HTML::WindowProxy>> Document::open(StringView url, StringView name, StringView features)
 {
     // 1. If this is not fully active, then throw an "InvalidAccessError" DOMException exception.
     if (!is_fully_active())
@@ -722,7 +722,7 @@ WebIDL::ExceptionOr<void> Document::close()
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-document-defaultview
-JS::GCPtr<HTML::WindowProxy> Document::default_view()
+GC::Ptr<HTML::WindowProxy> Document::default_view()
 {
     // If this's browsing context is null, then return null.
     if (!browsing_context())
@@ -732,7 +732,7 @@ JS::GCPtr<HTML::WindowProxy> Document::default_view()
     return browsing_context()->window_proxy();
 }
 
-JS::GCPtr<HTML::WindowProxy const> Document::default_view() const
+GC::Ptr<HTML::WindowProxy const> Document::default_view() const
 {
     return const_cast<Document*>(this)->default_view();
 }
@@ -814,11 +814,11 @@ HTML::HTMLHeadElement* Document::head()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#the-title-element-2
-JS::GCPtr<HTML::HTMLTitleElement> Document::title_element()
+GC::Ptr<HTML::HTMLTitleElement> Document::title_element()
 {
     // The title element of a document is the first title element in the document (in tree order), if there is one, or
     // null otherwise.
-    JS::GCPtr<HTML::HTMLTitleElement> title_element = nullptr;
+    GC::Ptr<HTML::HTMLTitleElement> title_element = nullptr;
 
     for_each_in_subtree_of_type<HTML::HTMLTitleElement>([&](auto& title_element_in_tree) {
         title_element = title_element_in_tree;
@@ -917,7 +917,7 @@ WebIDL::ExceptionOr<void> Document::set_title(String const& title)
 
     // -> If the document element is an SVG svg element
     if (is<SVG::SVGElement>(document_element)) {
-        JS::GCPtr<Element> element;
+        GC::Ptr<Element> element;
 
         // 1. If there is an SVG title element that is a child of the document element, let element be the first such
         //    element.
@@ -947,7 +947,7 @@ WebIDL::ExceptionOr<void> Document::set_title(String const& title)
         if (title_element == nullptr && head_element == nullptr)
             return {};
 
-        JS::GCPtr<Element> element;
+        GC::Ptr<Element> element;
 
         // 2. If the title element is non-null, let element be the title element.
         if (title_element) {
@@ -1020,7 +1020,7 @@ Vector<CSS::BackgroundLayerData> const* Document::background_layers() const
 
 void Document::update_base_element(Badge<HTML::HTMLBaseElement>)
 {
-    JS::GCPtr<HTML::HTMLBaseElement const> base_element;
+    GC::Ptr<HTML::HTMLBaseElement const> base_element;
 
     for_each_in_subtree_of_type<HTML::HTMLBaseElement>([&base_element](HTML::HTMLBaseElement const& base_element_in_tree) {
         if (base_element_in_tree.has_attribute(HTML::AttributeNames::href)) {
@@ -1034,7 +1034,7 @@ void Document::update_base_element(Badge<HTML::HTMLBaseElement>)
     m_first_base_element_with_href_in_tree_order = base_element;
 }
 
-JS::GCPtr<HTML::HTMLBaseElement const> Document::first_base_element_with_href_in_tree_order() const
+GC::Ptr<HTML::HTMLBaseElement const> Document::first_base_element_with_href_in_tree_order() const
 {
     return m_first_base_element_with_href_in_tree_order;
 }
@@ -1446,7 +1446,7 @@ void Document::set_hovered_node(Node* node)
     if (m_hovered_node.ptr() == node)
         return;
 
-    JS::GCPtr<Node> old_hovered_node = move(m_hovered_node);
+    GC::Ptr<Node> old_hovered_node = move(m_hovered_node);
     m_hovered_node = node;
 
     auto* common_ancestor = find_common_ancestor(old_hovered_node, m_hovered_node);
@@ -1501,7 +1501,7 @@ void Document::set_hovered_node(Node* node)
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-getelementsbyname
-JS::NonnullGCPtr<NodeList> Document::get_elements_by_name(FlyString const& name)
+GC::Ref<NodeList> Document::get_elements_by_name(FlyString const& name)
 {
     return LiveNodeList::create(realm(), *this, LiveNodeList::Scope::Descendants, [name](auto const& node) {
         if (!is<HTML::HTMLElement>(node))
@@ -1511,7 +1511,7 @@ JS::NonnullGCPtr<NodeList> Document::get_elements_by_name(FlyString const& name)
 }
 
 // https://html.spec.whatwg.org/multipage/obsolete.html#dom-document-applets
-JS::NonnullGCPtr<HTMLCollection> Document::applets()
+GC::Ref<HTMLCollection> Document::applets()
 {
     if (!m_applets)
         m_applets = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](auto&) { return false; });
@@ -1519,7 +1519,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::applets()
 }
 
 // https://html.spec.whatwg.org/multipage/obsolete.html#dom-document-anchors
-JS::NonnullGCPtr<HTMLCollection> Document::anchors()
+GC::Ref<HTMLCollection> Document::anchors()
 {
     if (!m_anchors) {
         m_anchors = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1530,7 +1530,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::anchors()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-images
-JS::NonnullGCPtr<HTMLCollection> Document::images()
+GC::Ref<HTMLCollection> Document::images()
 {
     if (!m_images) {
         m_images = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1541,7 +1541,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::images()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-embeds
-JS::NonnullGCPtr<HTMLCollection> Document::embeds()
+GC::Ref<HTMLCollection> Document::embeds()
 {
     if (!m_embeds) {
         m_embeds = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1552,13 +1552,13 @@ JS::NonnullGCPtr<HTMLCollection> Document::embeds()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-plugins
-JS::NonnullGCPtr<HTMLCollection> Document::plugins()
+GC::Ref<HTMLCollection> Document::plugins()
 {
     return embeds();
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-links
-JS::NonnullGCPtr<HTMLCollection> Document::links()
+GC::Ref<HTMLCollection> Document::links()
 {
     if (!m_links) {
         m_links = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1569,7 +1569,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::links()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-forms
-JS::NonnullGCPtr<HTMLCollection> Document::forms()
+GC::Ref<HTMLCollection> Document::forms()
 {
     if (!m_forms) {
         m_forms = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1580,7 +1580,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::forms()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-scripts
-JS::NonnullGCPtr<HTMLCollection> Document::scripts()
+GC::Ref<HTMLCollection> Document::scripts()
 {
     if (!m_scripts) {
         m_scripts = HTMLCollection::create(*this, HTMLCollection::Scope::Descendants, [](Element const& element) {
@@ -1591,7 +1591,7 @@ JS::NonnullGCPtr<HTMLCollection> Document::scripts()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-document-all
-JS::NonnullGCPtr<HTML::HTMLAllCollection> Document::all()
+GC::Ref<HTML::HTMLAllCollection> Document::all()
 {
     if (!m_all) {
         // The all attribute must return an HTMLAllCollection rooted at the Document node, whose filter matches all elements.
@@ -1603,7 +1603,7 @@ JS::NonnullGCPtr<HTML::HTMLAllCollection> Document::all()
 }
 
 // https://drafts.csswg.org/css-font-loading/#font-source
-JS::NonnullGCPtr<CSS::FontFaceSet> Document::fonts()
+GC::Ref<CSS::FontFaceSet> Document::fonts()
 {
     if (!m_fonts)
         m_fonts = CSS::FontFaceSet::create(realm());
@@ -1657,7 +1657,7 @@ HTML::EnvironmentSettingsObject& Document::relevant_settings_object() const
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createelement
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> Document::create_element(String const& a_local_name, Variant<String, ElementCreationOptions> const& options)
+WebIDL::ExceptionOr<GC::Ref<Element>> Document::create_element(String const& a_local_name, Variant<String, ElementCreationOptions> const& options)
 {
     auto local_name = a_local_name.to_byte_string();
 
@@ -1690,7 +1690,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> Document::create_element(String c
 
 // https://dom.spec.whatwg.org/#dom-document-createelementns
 // https://dom.spec.whatwg.org/#internal-createelementns-steps
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> Document::create_element_ns(Optional<FlyString> const& namespace_, String const& qualified_name, Variant<String, ElementCreationOptions> const& options)
+WebIDL::ExceptionOr<GC::Ref<Element>> Document::create_element_ns(Optional<FlyString> const& namespace_, String const& qualified_name, Variant<String, ElementCreationOptions> const& options)
 {
     // 1. Let namespace, prefix, and localName be the result of passing namespace and qualifiedName to validate and extract.
     auto extracted_qualified_name = TRY(validate_and_extract(realm(), namespace_, qualified_name));
@@ -1709,18 +1709,18 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> Document::create_element_ns(Optio
     return TRY(DOM::create_element(*this, extracted_qualified_name.local_name(), extracted_qualified_name.namespace_(), extracted_qualified_name.prefix(), move(is_value), true));
 }
 
-JS::NonnullGCPtr<DocumentFragment> Document::create_document_fragment()
+GC::Ref<DocumentFragment> Document::create_document_fragment()
 {
     return realm().create<DocumentFragment>(*this);
 }
 
-JS::NonnullGCPtr<Text> Document::create_text_node(String const& data)
+GC::Ref<Text> Document::create_text_node(String const& data)
 {
     return realm().create<Text>(*this, data);
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createcdatasection
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CDATASection>> Document::create_cdata_section(String const& data)
+WebIDL::ExceptionOr<GC::Ref<CDATASection>> Document::create_cdata_section(String const& data)
 {
     // 1. If this is an HTML document, then throw a "NotSupportedError" DOMException.
     if (is_html_document())
@@ -1734,13 +1734,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CDATASection>> Document::create_cdata_secti
     return realm().create<CDATASection>(*this, data);
 }
 
-JS::NonnullGCPtr<Comment> Document::create_comment(String const& data)
+GC::Ref<Comment> Document::create_comment(String const& data)
 {
     return realm().create<Comment>(*this, data);
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ProcessingInstruction>> Document::create_processing_instruction(String const& target, String const& data)
+WebIDL::ExceptionOr<GC::Ref<ProcessingInstruction>> Document::create_processing_instruction(String const& target, String const& data)
 {
     // 1. If target does not match the Name production, then throw an "InvalidCharacterError" DOMException.
     if (!is_valid_name(target))
@@ -1754,19 +1754,19 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ProcessingInstruction>> Document::create_pr
     return realm().create<ProcessingInstruction>(*this, data, target);
 }
 
-JS::NonnullGCPtr<Range> Document::create_range()
+GC::Ref<Range> Document::create_range()
 {
     return Range::create(*this);
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createevent
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> Document::create_event(StringView interface)
+WebIDL::ExceptionOr<GC::Ref<Event>> Document::create_event(StringView interface)
 {
     auto& realm = this->realm();
 
     // NOTE: This is named event here, since we do step 5 and 6 as soon as possible for each case.
     // 1. Let constructor be null.
-    JS::GCPtr<Event> event;
+    GC::Ptr<Event> event;
 
     // 2. If interface is an ASCII case-insensitive match for any of the strings in the first column in the following table,
     //      then set constructor to the interface in the second column on the same row as the matching string:
@@ -1831,7 +1831,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> Document::create_event(StringView i
     event->set_initialized(false);
 
     // 10. Return event.
-    return JS::NonnullGCPtr(*event);
+    return GC::Ref(*event);
 }
 
 void Document::set_pending_parsing_blocking_script(HTML::HTMLScriptElement* script)
@@ -1839,7 +1839,7 @@ void Document::set_pending_parsing_blocking_script(HTML::HTMLScriptElement* scri
     m_pending_parsing_blocking_script = script;
 }
 
-JS::NonnullGCPtr<HTML::HTMLScriptElement> Document::take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>)
+GC::Ref<HTML::HTMLScriptElement> Document::take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>)
 {
     VERIFY(m_pending_parsing_blocking_script);
     auto script = m_pending_parsing_blocking_script;
@@ -1852,11 +1852,11 @@ void Document::add_script_to_execute_when_parsing_has_finished(Badge<HTML::HTMLS
     m_scripts_to_execute_when_parsing_has_finished.append(script);
 }
 
-Vector<JS::Handle<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>)
+Vector<GC::Root<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>)
 {
-    Vector<JS::Handle<HTML::HTMLScriptElement>> handles;
+    Vector<GC::Root<HTML::HTMLScriptElement>> handles;
     for (auto script : m_scripts_to_execute_when_parsing_has_finished)
-        handles.append(JS::make_handle(script));
+        handles.append(GC::make_root(script));
     m_scripts_to_execute_when_parsing_has_finished.clear();
     return handles;
 }
@@ -1866,11 +1866,11 @@ void Document::add_script_to_execute_as_soon_as_possible(Badge<HTML::HTMLScriptE
     m_scripts_to_execute_as_soon_as_possible.append(script);
 }
 
-Vector<JS::Handle<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>)
+Vector<GC::Root<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>)
 {
-    Vector<JS::Handle<HTML::HTMLScriptElement>> handles;
+    Vector<GC::Root<HTML::HTMLScriptElement>> handles;
     for (auto script : m_scripts_to_execute_as_soon_as_possible)
-        handles.append(JS::make_handle(script));
+        handles.append(GC::make_root(script));
     m_scripts_to_execute_as_soon_as_possible.clear();
     return handles;
 }
@@ -1880,17 +1880,17 @@ void Document::add_script_to_execute_in_order_as_soon_as_possible(Badge<HTML::HT
     m_scripts_to_execute_in_order_as_soon_as_possible.append(script);
 }
 
-Vector<JS::Handle<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>)
+Vector<GC::Root<HTML::HTMLScriptElement>> Document::take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>)
 {
-    Vector<JS::Handle<HTML::HTMLScriptElement>> handles;
+    Vector<GC::Root<HTML::HTMLScriptElement>> handles;
     for (auto script : m_scripts_to_execute_in_order_as_soon_as_possible)
-        handles.append(JS::make_handle(script));
+        handles.append(GC::make_root(script));
     m_scripts_to_execute_in_order_as_soon_as_possible.clear();
     return handles;
 }
 
 // https://dom.spec.whatwg.org/#dom-document-importnode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Document::import_node(JS::NonnullGCPtr<Node> node, bool deep)
+WebIDL::ExceptionOr<GC::Ref<Node>> Document::import_node(GC::Ref<Node> node, bool deep)
 {
     // 1. If node is a document or shadow root, then throw a "NotSupportedError" DOMException.
     if (is<Document>(*node) || is<ShadowRoot>(*node))
@@ -1933,7 +1933,7 @@ void Document::adopt_node(Node& node)
             if (element.is_custom()) {
                 auto& vm = this->vm();
 
-                JS::MarkedVector<JS::Value> arguments { vm.heap() };
+                GC::MarkedVector<JS::Value> arguments { vm.heap() };
                 arguments.append(&old_document);
                 arguments.append(this);
 
@@ -1965,7 +1965,7 @@ void Document::adopt_node(Node& node)
 }
 
 // https://dom.spec.whatwg.org/#dom-document-adoptnode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Document::adopt_node_binding(JS::NonnullGCPtr<Node> node)
+WebIDL::ExceptionOr<GC::Ref<Node>> Document::adopt_node_binding(GC::Ref<Node> node)
 {
     if (is<Document>(*node))
         return WebIDL::NotSupportedError::create(realm(), "Cannot adopt a document into a document"_string);
@@ -2047,7 +2047,7 @@ void Document::set_focused_element(Element* element)
     if (m_focused_element.ptr() == element)
         return;
 
-    JS::GCPtr<Element> old_focused_element = move(m_focused_element);
+    GC::Ptr<Element> old_focused_element = move(m_focused_element);
 
     if (old_focused_element)
         old_focused_element->did_lose_focus();
@@ -2082,7 +2082,7 @@ void Document::set_active_element(Element* element)
     if (m_active_element.ptr() == element)
         return;
 
-    JS::GCPtr<Node> old_active_element = move(m_active_element);
+    GC::Ptr<Node> old_active_element = move(m_active_element);
     m_active_element = element;
 
     if (auto* invalidation_target = find_common_ancestor(old_active_element, m_active_element) ?: this)
@@ -2097,7 +2097,7 @@ void Document::set_target_element(Element* element)
     if (m_target_element.ptr() == element)
         return;
 
-    JS::GCPtr<Element> old_target_element = move(m_target_element);
+    GC::Ptr<Element> old_target_element = move(m_target_element);
     m_target_element = element;
 
     if (auto* invalidation_target = find_common_ancestor(old_target_element, m_target_element) ?: this)
@@ -2173,7 +2173,7 @@ Element* Document::find_a_potential_indicated_element(FlyString const& fragment)
 }
 
 // https://www.w3.org/TR/css-animations-2/#event-dispatch
-void Document::dispatch_events_for_animation_if_necessary(JS::NonnullGCPtr<Animations::Animation> animation)
+void Document::dispatch_events_for_animation_if_necessary(GC::Ref<Animations::Animation> animation)
 {
     // Each time a new animation frame is established and the animation does not have a pending play task or pending
     // pause task, the events to dispatch are determined by comparing the animation’s phase before and after
@@ -2184,7 +2184,7 @@ void Document::dispatch_events_for_animation_if_necessary(JS::NonnullGCPtr<Anima
 
     auto& css_animation = verify_cast<CSS::CSSAnimation>(*animation);
 
-    JS::GCPtr<Element> target = effect->target();
+    GC::Ptr<Element> target = effect->target();
     if (!target)
         return;
 
@@ -2500,7 +2500,7 @@ void Document::completely_finish_loading()
     if (!navigable()->container())
         return;
 
-    auto container = JS::make_handle(navigable()->container());
+    auto container = GC::make_root(navigable()->container());
 
     // 4. If container is an iframe element, then queue an element task on the DOM manipulation task source given container to run the iframe load event steps given container.
     if (container && is<HTML::HTMLIFrameElement>(*container)) {
@@ -2704,7 +2704,7 @@ bool Document::is_active() const
 }
 
 // https://html.spec.whatwg.org/multipage/history.html#dom-document-location
-JS::GCPtr<HTML::Location> Document::location()
+GC::Ptr<HTML::Location> Document::location()
 {
     // The Document object's location attribute's getter must return this Document object's relevant global object's Location object,
     // if this Document object is fully active, and null otherwise.
@@ -2804,7 +2804,7 @@ void Document::run_the_scroll_steps()
     m_pending_scroll_event_targets.clear();
 }
 
-void Document::add_media_query_list(JS::NonnullGCPtr<CSS::MediaQueryList> media_query_list)
+void Document::add_media_query_list(GC::Ref<CSS::MediaQueryList> media_query_list)
 {
     m_media_query_lists.append(*media_query_list);
 }
@@ -2827,7 +2827,7 @@ void Document::evaluate_media_queries_and_report_changes()
         //    and its matches attribute initialized to target’s matches state.
         if (media_query_list_ptr.is_null())
             continue;
-        JS::GCPtr<CSS::MediaQueryList> media_query_list = media_query_list_ptr.ptr();
+        GC::Ptr<CSS::MediaQueryList> media_query_list = media_query_list_ptr.ptr();
         bool did_match = media_query_list->matches();
         bool now_matches = media_query_list->evaluate();
 
@@ -2990,13 +2990,13 @@ WebIDL::ExceptionOr<Document::PrefixAndTagName> Document::validate_qualified_nam
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createnodeiterator
-JS::NonnullGCPtr<NodeIterator> Document::create_node_iterator(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter> filter)
+GC::Ref<NodeIterator> Document::create_node_iterator(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter> filter)
 {
     return NodeIterator::create(root, what_to_show, filter).release_value_but_fixme_should_propagate_errors();
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createtreewalker
-JS::NonnullGCPtr<TreeWalker> Document::create_tree_walker(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter> filter)
+GC::Ref<TreeWalker> Document::create_tree_walker(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter> filter)
 {
     return TreeWalker::create(root, what_to_show, filter);
 }
@@ -3127,7 +3127,7 @@ void Document::set_window(HTML::Window& window)
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#look-up-a-custom-element-definition
-JS::GCPtr<HTML::CustomElementDefinition> Document::lookup_custom_element_definition(Optional<FlyString> const& namespace_, FlyString const& local_name, Optional<String> const& is) const
+GC::Ptr<HTML::CustomElementDefinition> Document::lookup_custom_element_definition(Optional<FlyString> const& namespace_, FlyString const& local_name, Optional<String> const& is) const
 {
     // 1. If namespace is not the HTML namespace, return null.
     if (namespace_ != Namespace::HTML)
@@ -3168,14 +3168,14 @@ CSS::StyleSheetList const& Document::style_sheets() const
     return const_cast<Document*>(this)->style_sheets();
 }
 
-JS::NonnullGCPtr<HTML::History> Document::history()
+GC::Ref<HTML::History> Document::history()
 {
     if (!m_history)
         m_history = HTML::History::create(realm(), *this);
     return *m_history;
 }
 
-JS::NonnullGCPtr<HTML::History> Document::history() const
+GC::Ref<HTML::History> Document::history() const
 {
     return const_cast<Document*>(this)->history();
 }
@@ -3250,10 +3250,10 @@ HTML::SourceSnapshotParams Document::snapshot_source_snapshot_params() const
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#descendant-navigables
-Vector<JS::Handle<HTML::Navigable>> Document::descendant_navigables()
+Vector<GC::Root<HTML::Navigable>> Document::descendant_navigables()
 {
     // 1. Let navigables be new list.
-    Vector<JS::Handle<HTML::Navigable>> navigables;
+    Vector<GC::Root<HTML::Navigable>> navigables;
 
     // 2. Let navigableContainers be a list of all shadow-including descendants of document that are navigable containers, in shadow-including tree order.
     // 3. For each navigableContainer of navigableContainers:
@@ -3278,16 +3278,16 @@ Vector<JS::Handle<HTML::Navigable>> Document::descendant_navigables()
     return navigables;
 }
 
-Vector<JS::Handle<HTML::Navigable>> const Document::descendant_navigables() const
+Vector<GC::Root<HTML::Navigable>> const Document::descendant_navigables() const
 {
     return const_cast<Document&>(*this).descendant_navigables();
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#inclusive-descendant-navigables
-Vector<JS::Handle<HTML::Navigable>> Document::inclusive_descendant_navigables()
+Vector<GC::Root<HTML::Navigable>> Document::inclusive_descendant_navigables()
 {
     // 1. Let navigables be « document's node navigable ».
-    Vector<JS::Handle<HTML::Navigable>> navigables;
+    Vector<GC::Root<HTML::Navigable>> navigables;
     navigables.append(*navigable());
 
     // 2. Extend navigables with document's descendant navigables.
@@ -3298,7 +3298,7 @@ Vector<JS::Handle<HTML::Navigable>> Document::inclusive_descendant_navigables()
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#ancestor-navigables
-Vector<JS::Handle<HTML::Navigable>> Document::ancestor_navigables()
+Vector<GC::Root<HTML::Navigable>> Document::ancestor_navigables()
 {
     // NOTE: This isn't in the spec, but if we don't have a navigable, we can't have ancestors either.
     auto document_node_navigable = this->navigable();
@@ -3309,7 +3309,7 @@ Vector<JS::Handle<HTML::Navigable>> Document::ancestor_navigables()
     auto navigable = document_node_navigable->parent();
 
     // 2. Let ancestors be an empty list.
-    Vector<JS::Handle<HTML::Navigable>> ancestors;
+    Vector<GC::Root<HTML::Navigable>> ancestors;
 
     // 3. While navigable is not null:
     while (navigable) {
@@ -3324,13 +3324,13 @@ Vector<JS::Handle<HTML::Navigable>> Document::ancestor_navigables()
     return ancestors;
 }
 
-Vector<JS::Handle<HTML::Navigable>> const Document::ancestor_navigables() const
+Vector<GC::Root<HTML::Navigable>> const Document::ancestor_navigables() const
 {
     return const_cast<Document&>(*this).ancestor_navigables();
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#inclusive-ancestor-navigables
-Vector<JS::Handle<HTML::Navigable>> Document::inclusive_ancestor_navigables()
+Vector<GC::Root<HTML::Navigable>> Document::inclusive_ancestor_navigables()
 {
     // 1. Let navigables be document's ancestor navigables.
     auto navigables = ancestor_navigables();
@@ -3343,14 +3343,14 @@ Vector<JS::Handle<HTML::Navigable>> Document::inclusive_ancestor_navigables()
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#document-tree-child-navigables
-Vector<JS::Handle<HTML::Navigable>> Document::document_tree_child_navigables()
+Vector<GC::Root<HTML::Navigable>> Document::document_tree_child_navigables()
 {
     // 1. If document's node navigable is null, then return the empty list.
     if (!navigable())
         return {};
 
     // 2. Let navigables be new list.
-    Vector<JS::Handle<HTML::Navigable>> navigables;
+    Vector<GC::Root<HTML::Navigable>> navigables;
 
     // 3. Let navigableContainers be a list of all descendants of document that are navigable containers, in tree order.
     // 4. For each navigableContainer of navigableContainers:
@@ -3450,7 +3450,7 @@ void Document::make_unsalvageable([[maybe_unused]] String reason)
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document-and-its-descendants
-void Document::destroy_a_document_and_its_descendants(JS::GCPtr<JS::HeapFunction<void()>> after_all_destruction)
+void Document::destroy_a_document_and_its_descendants(GC::Ptr<GC::Function<void()>> after_all_destruction)
 {
     // 1. If document is not fully active, then:
     if (!is_fully_active()) {
@@ -3470,9 +3470,9 @@ void Document::destroy_a_document_and_its_descendants(JS::GCPtr<JS::HeapFunction
     // 4. For each childNavigable of childNavigable's, queue a global task on the navigation and traversal task source
     //    given childNavigable's active window to perform the following steps:
     for (auto& child_navigable : child_navigables) {
-        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *child_navigable->active_window(), JS::create_heap_function(heap(), [&heap = heap(), &number_destroyed, child_navigable = child_navigable.ptr()] {
+        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *child_navigable->active_window(), GC::create_function(heap(), [&heap = heap(), &number_destroyed, child_navigable = child_navigable.ptr()] {
             // 1. Let incrementDestroyed be an algorithm step which increments numberDestroyed.
-            auto increment_destroyed = JS::create_heap_function(heap, [&number_destroyed] { ++number_destroyed; });
+            auto increment_destroyed = GC::create_function(heap, [&number_destroyed] { ++number_destroyed; });
 
             // 2. Destroy a document and its descendants given childNavigable's active document and incrementDestroyed.
             child_navigable->active_document()->destroy_a_document_and_its_descendants(move(increment_destroyed));
@@ -3480,12 +3480,12 @@ void Document::destroy_a_document_and_its_descendants(JS::GCPtr<JS::HeapFunction
     }
 
     // 5. Wait until numberDestroyed equals childNavigable's size.
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&] {
         return number_destroyed == child_navigables.size();
     }));
 
     // 6. Queue a global task on the navigation and traversal task source given document's relevant global object to perform the following steps:
-    HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, relevant_global_object(*this), JS::create_heap_function(heap(), [after_all_destruction = move(after_all_destruction), this] {
+    HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, relevant_global_object(*this), GC::create_function(heap(), [after_all_destruction = move(after_all_destruction), this] {
         // 1. Destroy document.
         destroy();
 
@@ -3539,7 +3539,7 @@ void Document::abort_a_document_and_its_descendants()
 
     // 3. For each descendantNavigable of descendantNavigables, queue a global task on the navigation and traversal task source given descendantNavigable's active window to perform the following steps:
     for (auto& descendant_navigable : descendant_navigables) {
-        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *descendant_navigable->active_window(), JS::create_heap_function(heap(), [this, descendant_navigable = descendant_navigable.ptr()] {
+        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *descendant_navigable->active_window(), GC::create_function(heap(), [this, descendant_navigable = descendant_navigable.ptr()] {
             // NOTE: This is not in the spec but we need to abort ongoing navigations in all descendant navigables.
             //       See https://github.com/whatwg/html/issues/9711
             descendant_navigable->set_ongoing_navigation({});
@@ -3558,7 +3558,7 @@ void Document::abort_a_document_and_its_descendants()
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#active-parser
-JS::GCPtr<HTML::HTMLParser> Document::active_parser()
+GC::Ptr<HTML::HTMLParser> Document::active_parser()
 {
     if (!m_parser)
         return nullptr;
@@ -3575,7 +3575,7 @@ void Document::set_browsing_context(HTML::BrowsingContext* browsing_context)
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#unload-a-document
-void Document::unload(JS::GCPtr<Document>)
+void Document::unload(GC::Ptr<Document>)
 {
     // FIXME: 1. Assert: this is running as part of a task queued on oldDocument's event loop.
 
@@ -3656,7 +3656,7 @@ void Document::unload(JS::GCPtr<Document>)
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#unload-a-document-and-its-descendants
-void Document::unload_a_document_and_its_descendants(JS::GCPtr<Document> new_document, JS::GCPtr<JS::HeapFunction<void()>> after_all_unloads)
+void Document::unload_a_document_and_its_descendants(GC::Ptr<Document> new_document, GC::Ptr<GC::Function<void()>> after_all_unloads)
 {
     // Specification defines this algorithm in the following steps:
     // 1. Recursively unload (and destroy) documents in descendant navigables
@@ -3684,7 +3684,7 @@ void Document::unload_a_document_and_its_descendants(JS::GCPtr<Document> new_doc
 
     auto navigable = this->navigable();
 
-    Vector<JS::Handle<HTML::Navigable>> descendant_navigables;
+    Vector<GC::Root<HTML::Navigable>> descendant_navigables;
     for (auto& other_navigable : HTML::all_navigables()) {
         if (navigable->is_ancestor_of(*other_navigable))
             descendant_navigables.append(other_navigable);
@@ -3692,19 +3692,19 @@ void Document::unload_a_document_and_its_descendants(JS::GCPtr<Document> new_doc
 
     auto unloaded_documents_count = descendant_navigables.size() + 1;
 
-    HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, HTML::relevant_global_object(*this), JS::create_heap_function(heap(), [&number_unloaded, this, new_document] {
+    HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, HTML::relevant_global_object(*this), GC::create_function(heap(), [&number_unloaded, this, new_document] {
         unload(new_document);
         ++number_unloaded;
     }));
 
     for (auto& descendant_navigable : descendant_navigables) {
-        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *descendant_navigable->active_window(), JS::create_heap_function(heap(), [&number_unloaded, descendant_navigable = descendant_navigable.ptr()] {
+        HTML::queue_global_task(HTML::Task::Source::NavigationAndTraversal, *descendant_navigable->active_window(), GC::create_function(heap(), [&number_unloaded, descendant_navigable = descendant_navigable.ptr()] {
             descendant_navigable->active_document()->unload();
             ++number_unloaded;
         }));
     }
 
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&] {
         return number_unloaded == unloaded_documents_count;
     }));
 
@@ -3762,7 +3762,7 @@ void Document::decrement_throw_on_dynamic_markup_insertion_counter(Badge<HTML::H
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#appropriate-template-contents-owner-document
-JS::NonnullGCPtr<DOM::Document> Document::appropriate_template_contents_owner_document()
+GC::Ref<DOM::Document> Document::appropriate_template_contents_owner_document()
 {
     // 1. If doc is not a Document created by this algorithm, then:
     if (!created_for_appropriate_template_contents()) {
@@ -3806,7 +3806,7 @@ String Document::dump_accessibility_tree_as_json()
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createattribute
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> Document::create_attribute(String const& local_name)
+WebIDL::ExceptionOr<GC::Ref<Attr>> Document::create_attribute(String const& local_name)
 {
     // 1. If localName does not match the Name production in XML, then throw an "InvalidCharacterError" DOMException.
     if (!is_valid_name(local_name))
@@ -3818,7 +3818,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> Document::create_attribute(String co
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createattributens
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> Document::create_attribute_ns(Optional<FlyString> const& namespace_, String const& qualified_name)
+WebIDL::ExceptionOr<GC::Ref<Attr>> Document::create_attribute_ns(Optional<FlyString> const& namespace_, String const& qualified_name)
 {
     // 1. Let namespace, prefix, and localName be the result of passing namespace and qualifiedName to validate and extract.
     auto extracted_qualified_name = TRY(validate_and_extract(realm(), namespace_, qualified_name));
@@ -3876,7 +3876,7 @@ CSSPixelRect Document::viewport_rect() const
     return CSSPixelRect {};
 }
 
-JS::NonnullGCPtr<CSS::VisualViewport> Document::visual_viewport()
+GC::Ref<CSS::VisualViewport> Document::visual_viewport()
 {
     if (!m_visual_viewport)
         m_visual_viewport = CSS::VisualViewport::create(*this);
@@ -3940,7 +3940,7 @@ void Document::queue_intersection_observer_task()
     m_intersection_observer_task_queued = true;
 
     // 3. Queue a task on the IntersectionObserver task source associated with the document's event loop to notify intersection observers.
-    HTML::queue_global_task(HTML::Task::Source::IntersectionObserver, *window, JS::create_heap_function(heap(), [this]() {
+    HTML::queue_global_task(HTML::Task::Source::IntersectionObserver, *window, GC::create_function(heap(), [this]() {
         auto& realm = this->realm();
 
         // https://www.w3.org/TR/intersection-observer/#notify-intersection-observers
@@ -3948,10 +3948,10 @@ void Document::queue_intersection_observer_task()
         m_intersection_observer_task_queued = false;
 
         // 2. Let notify list be a list of all IntersectionObservers whose root is in the DOM tree of document.
-        Vector<JS::Handle<IntersectionObserver::IntersectionObserver>> notify_list;
+        Vector<GC::Root<IntersectionObserver::IntersectionObserver>> notify_list;
         notify_list.try_ensure_capacity(m_intersection_observers.size()).release_value_but_fixme_should_propagate_errors();
         for (auto& observer : m_intersection_observers) {
-            notify_list.append(JS::make_handle(observer));
+            notify_list.append(GC::make_root(observer));
         }
 
         // 3. For each IntersectionObserver object observer in notify list, run these steps:
@@ -3983,7 +3983,7 @@ void Document::queue_intersection_observer_task()
 }
 
 // https://www.w3.org/TR/intersection-observer/#queue-an-intersectionobserverentry
-void Document::queue_an_intersection_observer_entry(IntersectionObserver::IntersectionObserver& observer, HighResolutionTime::DOMHighResTimeStamp time, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> root_bounds, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, JS::NonnullGCPtr<Element> target)
+void Document::queue_an_intersection_observer_entry(IntersectionObserver::IntersectionObserver& observer, HighResolutionTime::DOMHighResTimeStamp time, GC::Ref<Geometry::DOMRectReadOnly> root_bounds, GC::Ref<Geometry::DOMRectReadOnly> bounding_client_rect, GC::Ref<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, GC::Ref<Element> target)
 {
     auto& realm = this->realm();
 
@@ -3998,7 +3998,7 @@ void Document::queue_an_intersection_observer_entry(IntersectionObserver::Inters
 }
 
 // https://www.w3.org/TR/intersection-observer/#compute-the-intersection
-static JS::NonnullGCPtr<Geometry::DOMRectReadOnly> compute_intersection(JS::NonnullGCPtr<Element> target, IntersectionObserver::IntersectionObserver const& observer)
+static GC::Ref<Geometry::DOMRectReadOnly> compute_intersection(GC::Ref<Element> target, IntersectionObserver::IntersectionObserver const& observer)
 {
     // 1. Let intersectionRect be the result of getting the bounding box for target.
     auto intersection_rect = target->get_bounding_client_rect();
@@ -4040,7 +4040,7 @@ void Document::run_the_update_intersection_observations_steps(HighResolutionTime
     // 2. For each observer in observer list:
 
     // NOTE: We make a copy of the intersection observers list to avoid modifying it while iterating.
-    JS::MarkedVector<JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver>> intersection_observers(heap());
+    GC::MarkedVector<GC::Ref<IntersectionObserver::IntersectionObserver>> intersection_observers(heap());
     intersection_observers.ensure_capacity(m_intersection_observers.size());
     for (auto& observer : m_intersection_observers)
         intersection_observers.append(observer);
@@ -4073,11 +4073,11 @@ void Document::run_the_update_intersection_observations_steps(HighResolutionTime
             // 3. If the intersection root is an Element, and target is not a descendant of the intersection root in the containing block chain, skip to step 11.
             // FIXME: Actually use the containing block chain.
             auto intersection_root = observer->intersection_root();
-            auto intersection_root_document = intersection_root.visit([](auto& node) -> JS::NonnullGCPtr<Document> {
+            auto intersection_root_document = intersection_root.visit([](auto& node) -> GC::Ref<Document> {
                 return node->document();
             });
             if (!(observer->root().has<Empty>() && &target->document() == intersection_root_document.ptr())
-                || !(intersection_root.has<JS::Handle<DOM::Element>>() && !target->is_descendant_of(*intersection_root.get<JS::Handle<DOM::Element>>()))) {
+                || !(intersection_root.has<GC::Root<DOM::Element>>() && !target->is_descendant_of(*intersection_root.get<GC::Root<DOM::Element>>()))) {
                 // 4. Set targetRect to the DOMRectReadOnly obtained by getting the bounding box for target.
                 target_rect = target->get_bounding_client_rect();
 
@@ -4164,7 +4164,7 @@ void Document::start_intersection_observing_a_lazy_loading_element(Element& elem
                 auto& entry = verify_cast<IntersectionObserver::IntersectionObserverEntry>(entries.get_without_side_effects(property_key).as_object());
 
                 // 1. Let resumptionSteps be null.
-                JS::GCPtr<JS::HeapFunction<void()>> resumption_steps;
+                GC::Ptr<GC::Function<void()>> resumption_steps;
 
                 // 2. If entry.isIntersecting is true, then set resumptionSteps to entry.target's lazy load resumption steps.
                 if (entry.is_intersecting()) {
@@ -4213,7 +4213,7 @@ void Document::start_intersection_observing_a_lazy_loading_element(Element& elem
 }
 
 // https://html.spec.whatwg.org/multipage/semantics.html#shared-declarative-refresh-steps
-void Document::shared_declarative_refresh_steps(StringView input, JS::GCPtr<HTML::HTMLMetaElement const> meta_element)
+void Document::shared_declarative_refresh_steps(StringView input, GC::Ptr<HTML::HTMLMetaElement const> meta_element)
 {
     // 1. If document's will declaratively refresh is true, then return.
     if (m_will_declaratively_refresh)
@@ -4380,7 +4380,7 @@ Painting::ViewportPaintable* Document::paintable()
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#restore-the-history-object-state
-void Document::restore_the_history_object_state(JS::NonnullGCPtr<HTML::SessionHistoryEntry> entry)
+void Document::restore_the_history_object_state(GC::Ref<HTML::SessionHistoryEntry> entry)
 {
     // 1. Let targetRealm be document's relevant realm.
     auto& target_realm = HTML::relevant_realm(*this);
@@ -4395,7 +4395,7 @@ void Document::restore_the_history_object_state(JS::NonnullGCPtr<HTML::SessionHi
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#update-document-for-history-step-application
-void Document::update_for_history_step_application(JS::NonnullGCPtr<HTML::SessionHistoryEntry> entry, bool do_not_reactivate, size_t script_history_length, size_t script_history_index, Optional<Bindings::NavigationType> navigation_type, Optional<Vector<JS::NonnullGCPtr<HTML::SessionHistoryEntry>>> entries_for_navigation_api, JS::GCPtr<HTML::SessionHistoryEntry> previous_entry_for_activation, bool update_navigation_api)
+void Document::update_for_history_step_application(GC::Ref<HTML::SessionHistoryEntry> entry, bool do_not_reactivate, size_t script_history_length, size_t script_history_index, Optional<Bindings::NavigationType> navigation_type, Optional<Vector<GC::Ref<HTML::SessionHistoryEntry>>> entries_for_navigation_api, GC::Ptr<HTML::SessionHistoryEntry> previous_entry_for_activation, bool update_navigation_api)
 {
     (void)previous_entry_for_activation;
 
@@ -4463,7 +4463,7 @@ void Document::update_for_history_step_application(JS::NonnullGCPtr<HTML::Sessio
                 hashchange_event_init.old_url = MUST(String::from_byte_string(old_url.serialize()));
                 hashchange_event_init.new_url = MUST(String::from_byte_string(entry->url().serialize()));
                 auto hashchange_event = HTML::HashChangeEvent::create(realm(), "hashchange"_fly_string, hashchange_event_init);
-                HTML::queue_global_task(HTML::Task::Source::DOMManipulation, relevant_global_object, JS::create_heap_function(heap(), [hashchange_event, &relevant_global_object]() {
+                HTML::queue_global_task(HTML::Task::Source::DOMManipulation, relevant_global_object, GC::create_function(heap(), [hashchange_event, &relevant_global_object]() {
                     relevant_global_object.dispatch_event(hashchange_event);
                 }));
             }
@@ -4516,13 +4516,13 @@ void Document::update_for_history_step_application(JS::NonnullGCPtr<HTML::Sessio
     }
 }
 
-HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>>& Document::shared_resource_requests()
+HashMap<URL::URL, GC::Ptr<HTML::SharedResourceRequest>>& Document::shared_resource_requests()
 {
     return m_shared_resource_requests;
 }
 
 // https://www.w3.org/TR/web-animations-1/#dom-document-timeline
-JS::NonnullGCPtr<Animations::DocumentTimeline> Document::timeline()
+GC::Ref<Animations::DocumentTimeline> Document::timeline()
 {
     // The DocumentTimeline object representing the default document timeline. The default document timeline has an
     // origin time of zero.
@@ -4531,12 +4531,12 @@ JS::NonnullGCPtr<Animations::DocumentTimeline> Document::timeline()
     return *m_default_timeline;
 }
 
-void Document::associate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline> timeline)
+void Document::associate_with_timeline(GC::Ref<Animations::AnimationTimeline> timeline)
 {
     m_associated_animation_timelines.set(timeline);
 }
 
-void Document::disassociate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline> timeline)
+void Document::disassociate_with_timeline(GC::Ref<Animations::AnimationTimeline> timeline)
 {
     m_associated_animation_timelines.remove(timeline);
 }
@@ -4623,7 +4623,7 @@ void Document::remove_replaced_animations()
     //   animation effect associated with a replaceable animation with a higher composite order than animation that
     //   includes the same target property
 
-    Vector<JS::NonnullGCPtr<Animations::Animation>> replaceable_animations;
+    Vector<GC::Ref<Animations::Animation>> replaceable_animations;
     for (auto const& timeline : m_associated_animation_timelines) {
         for (auto const& animation : timeline->associated_animations()) {
             if (!animation->effect() || !animation->effect()->target() || &animation->effect()->target()->document() != this)
@@ -4643,7 +4643,7 @@ void Document::remove_replaced_animations()
         }
     }
 
-    quick_sort(replaceable_animations, [](JS::NonnullGCPtr<Animations::Animation>& a, JS::NonnullGCPtr<Animations::Animation>& b) {
+    quick_sort(replaceable_animations, [](GC::Ref<Animations::Animation>& a, GC::Ref<Animations::Animation>& b) {
         VERIFY(a->effect()->is_keyframe_effect());
         VERIFY(b->effect()->is_keyframe_effect());
         auto& a_effect = *static_cast<Animations::KeyframeEffect*>(a->effect().ptr());
@@ -4696,7 +4696,7 @@ void Document::remove_replaced_animations()
             //   Otherwise, queue a task to dispatch removeEvent at animation. The task source for this task is the DOM
             //   manipulation task source.
             else {
-                HTML::queue_global_task(HTML::Task::Source::DOMManipulation, realm().global_object(), JS::create_heap_function(heap(), [animation, remove_event]() {
+                HTML::queue_global_task(HTML::Task::Source::DOMManipulation, realm().global_object(), GC::create_function(heap(), [animation, remove_event]() {
                     animation->dispatch_event(remove_event);
                 }));
             }
@@ -4704,9 +4704,9 @@ void Document::remove_replaced_animations()
     }
 }
 
-WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animations::Animation>>> Document::get_animations()
+WebIDL::ExceptionOr<Vector<GC::Ref<Animations::Animation>>> Document::get_animations()
 {
-    Vector<JS::NonnullGCPtr<Animations::Animation>> relevant_animations;
+    Vector<GC::Ref<Animations::Animation>> relevant_animations;
     TRY(for_each_child_of_type_fallible<Element>([&](auto& child) -> WebIDL::ExceptionOr<IterationDecision> {
         relevant_animations.extend(TRY(child.get_animations(Animations::GetAnimationsOptions { .subtree = true })));
         return IterationDecision::Continue;
@@ -4726,7 +4726,7 @@ static bool is_potentially_named_element_by_id(DOM::Element const& element)
     return is<HTML::HTMLObjectElement>(element) || is<HTML::HTMLImageElement>(element);
 }
 
-static void insert_in_tree_order(Vector<JS::NonnullGCPtr<DOM::Element>>& elements, DOM::Element& element)
+static void insert_in_tree_order(Vector<GC::Ref<DOM::Element>>& elements, DOM::Element& element)
 {
     for (auto& el : elements) {
         if (el == &element)
@@ -4742,7 +4742,7 @@ static void insert_in_tree_order(Vector<JS::NonnullGCPtr<DOM::Element>>& element
         elements.append(element);
 }
 
-void Document::element_id_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_id_changed(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     for (auto* form_associated_element : m_form_associated_elements_with_form_attribute)
         form_associated_element->element_id_changed({});
@@ -4753,7 +4753,7 @@ void Document::element_id_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Ele
         (void)m_potentially_named_elements.remove_first_matching([element](auto& e) { return e == element; });
 }
 
-void Document::element_with_id_was_added(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_with_id_was_added(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     for (auto* form_associated_element : m_form_associated_elements_with_form_attribute)
         form_associated_element->element_with_id_was_added_or_removed({});
@@ -4762,7 +4762,7 @@ void Document::element_with_id_was_added(Badge<DOM::Element>, JS::NonnullGCPtr<D
         insert_in_tree_order(m_potentially_named_elements, element);
 }
 
-void Document::element_with_id_was_removed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_with_id_was_removed(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     for (auto* form_associated_element : m_form_associated_elements_with_form_attribute)
         form_associated_element->element_with_id_was_added_or_removed({});
@@ -4771,7 +4771,7 @@ void Document::element_with_id_was_removed(Badge<DOM::Element>, JS::NonnullGCPtr
         (void)m_potentially_named_elements.remove_first_matching([element](auto& e) { return e == element; });
 }
 
-void Document::element_name_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_name_changed(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     if (element->name().has_value()) {
         insert_in_tree_order(m_potentially_named_elements, element);
@@ -4782,13 +4782,13 @@ void Document::element_name_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::E
     }
 }
 
-void Document::element_with_name_was_added(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_with_name_was_added(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     if (is_potentially_named_element(element))
         insert_in_tree_order(m_potentially_named_elements, element);
 }
 
-void Document::element_with_name_was_removed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element)
+void Document::element_with_name_was_removed(Badge<DOM::Element>, GC::Ref<DOM::Element> element)
 {
     if (is_potentially_named_element(element)) {
         if (is_potentially_named_element_by_id(element) && element->id().has_value())
@@ -4890,10 +4890,10 @@ Element const* Document::element_from_point(double x, double y)
 }
 
 // https://drafts.csswg.org/cssom-view/#dom-document-elementsfrompoint
-JS::MarkedVector<JS::NonnullGCPtr<Element>> Document::elements_from_point(double x, double y)
+GC::MarkedVector<GC::Ref<Element>> Document::elements_from_point(double x, double y)
 {
     // 1. Let sequence be a new empty sequence.
-    JS::MarkedVector<JS::NonnullGCPtr<Element>> sequence(heap());
+    GC::MarkedVector<GC::Ref<Element>> sequence(heap());
 
     // 2. If either argument is negative, x is greater than the viewport width excluding the size of a rendered scroll bar (if any),
     //    or y is greater than the viewport height excluding the size of a rendered scroll bar (if any),
@@ -4929,7 +4929,7 @@ JS::MarkedVector<JS::NonnullGCPtr<Element>> Document::elements_from_point(double
 }
 
 // https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement
-JS::GCPtr<Element const> Document::scrolling_element() const
+GC::Ptr<Element const> Document::scrolling_element() const
 {
     // 1. If the Document is in quirks mode, follow these substeps:
     if (in_quirks_mode()) {
@@ -5032,9 +5032,9 @@ static bool is_named_element_with_name(Element const& element, FlyString const&
     return false;
 }
 
-static Vector<JS::NonnullGCPtr<DOM::Element>> named_elements_with_name(Document const& document, FlyString const& name)
+static Vector<GC::Ref<DOM::Element>> named_elements_with_name(Document const& document, FlyString const& name)
 {
-    Vector<JS::NonnullGCPtr<DOM::Element>> named_elements;
+    Vector<GC::Ref<DOM::Element>> named_elements;
 
     for (auto const& element : document.potentially_named_elements()) {
         if (is_named_element_with_name(element, name))
@@ -5167,7 +5167,7 @@ size_t Document::broadcast_active_resize_observations()
         }
 
         // 2. Let entries be an empty list of ResizeObserverEntryies.
-        JS::MarkedVector<JS::NonnullGCPtr<ResizeObserver::ResizeObserverEntry>> entries(heap());
+        GC::MarkedVector<GC::Ref<ResizeObserver::ResizeObserverEntry>> entries(heap());
 
         // 3. For each observation in [[activeTargets]] perform these steps:
         for (auto const& observation : observer->active_targets()) {
@@ -5241,7 +5241,7 @@ bool Document::has_skipped_resize_observations()
     return false;
 }
 
-JS::NonnullGCPtr<WebIDL::ObservableArray> Document::adopted_style_sheets() const
+GC::Ref<WebIDL::ObservableArray> Document::adopted_style_sheets() const
 {
     if (!m_adopted_style_sheets)
         m_adopted_style_sheets = create_adopted_style_sheets_list(const_cast<Document&>(*this));
@@ -5265,7 +5265,7 @@ WebIDL::ExceptionOr<void> Document::set_adopted_style_sheets(JS::Value new_value
     return {};
 }
 
-void Document::for_each_active_css_style_sheet(Function<void(CSS::CSSStyleSheet&, JS::GCPtr<DOM::ShadowRoot>)>&& callback) const
+void Document::for_each_active_css_style_sheet(Function<void(CSS::CSSStyleSheet&, GC::Ptr<DOM::ShadowRoot>)>&& callback) const
 {
     if (m_style_sheets) {
         for (auto& style_sheet : m_style_sheets->sheets()) {
@@ -5388,7 +5388,7 @@ bool Document::is_decoded_svg() const
 }
 
 // https://drafts.csswg.org/css-position-4/#add-an-element-to-the-top-layer
-void Document::add_an_element_to_the_top_layer(JS::NonnullGCPtr<Element> element)
+void Document::add_an_element_to_the_top_layer(GC::Ref<Element> element)
 {
     // 1. Let doc be el’s node document.
 
@@ -5411,7 +5411,7 @@ void Document::add_an_element_to_the_top_layer(JS::NonnullGCPtr<Element> element
 }
 
 // https://drafts.csswg.org/css-position-4/#request-an-element-to-be-removed-from-the-top-layer
-void Document::request_an_element_to_be_remove_from_the_top_layer(JS::NonnullGCPtr<Element> element)
+void Document::request_an_element_to_be_remove_from_the_top_layer(GC::Ref<Element> element)
 {
     // 1. Let doc be el’s node document.
 
@@ -5426,7 +5426,7 @@ void Document::request_an_element_to_be_remove_from_the_top_layer(JS::NonnullGCP
 }
 
 // https://drafts.csswg.org/css-position-4/#remove-an-element-from-the-top-layer-immediately
-void Document::remove_an_element_from_the_top_layer_immediately(JS::NonnullGCPtr<Element> element)
+void Document::remove_an_element_from_the_top_layer_immediately(GC::Ref<Element> element)
 {
     // 1. Let doc be el’s node document.
 
@@ -5459,7 +5459,7 @@ void Document::set_needs_to_refresh_scroll_state(bool b)
         paintable->set_needs_to_refresh_scroll_state(b);
 }
 
-Vector<JS::Handle<DOM::Range>> Document::find_matching_text(String const& query, CaseSensitivity case_sensitivity)
+Vector<GC::Root<DOM::Range>> Document::find_matching_text(String const& query, CaseSensitivity case_sensitivity)
 {
     // Ensure the layout tree exists before searching for text matches.
     update_layout();
@@ -5471,7 +5471,7 @@ Vector<JS::Handle<DOM::Range>> Document::find_matching_text(String const& query,
     if (text_blocks.is_empty())
         return {};
 
-    Vector<JS::Handle<DOM::Range>> matches;
+    Vector<GC::Root<DOM::Range>> matches;
     for (auto const& text_block : text_blocks) {
         size_t offset = 0;
         size_t i = 0;
@@ -5536,7 +5536,7 @@ void Document::parse_html_from_a_string(StringView html)
 }
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsehtmlunsafe
-JS::NonnullGCPtr<Document> Document::parse_html_unsafe(JS::VM& vm, StringView html)
+GC::Ref<Document> Document::parse_html_unsafe(JS::VM& vm, StringView html)
 {
     auto& realm = *vm.current_realm();
     // FIXME: 1. Let compliantHTML to the result of invoking the Get Trusted Type compliant string algorithm with TrustedHTML, this's relevant global object, html, "Document parseHTMLUnsafe", and "script".
@@ -5570,7 +5570,7 @@ InputEventsTarget* Document::active_input_events_target()
     return nullptr;
 }
 
-JS::GCPtr<DOM::Position> Document::cursor_position() const
+GC::Ptr<DOM::Position> Document::cursor_position() const
 {
     auto const* focused_element = this->focused_element();
     if (!focused_element) {
@@ -5600,12 +5600,12 @@ void Document::reset_cursor_blink_cycle()
     m_cursor_blink_timer->restart();
 }
 
-JS::GCPtr<HTML::Navigable> Document::cached_navigable()
+GC::Ptr<HTML::Navigable> Document::cached_navigable()
 {
     return m_cached_navigable.ptr();
 }
 
-void Document::set_cached_navigable(JS::GCPtr<HTML::Navigable> navigable)
+void Document::set_cached_navigable(GC::Ptr<HTML::Navigable> navigable)
 {
     m_cached_navigable = navigable.ptr();
 }
diff --git a/Libraries/LibWeb/DOM/Document.h b/Libraries/LibWeb/DOM/Document.h
index 74cd011e886..c8a882e1003 100644
--- a/Libraries/LibWeb/DOM/Document.h
+++ b/Libraries/LibWeb/DOM/Document.h
@@ -87,7 +87,7 @@ class Document
     , public NonElementParentNode<Document>
     , public HTML::GlobalEventHandlers {
     WEB_PLATFORM_OBJECT(Document, ParentNode);
-    JS_DECLARE_ALLOCATOR(Document);
+    GC_DECLARE_ALLOCATOR(Document);
 
 public:
     enum class Type {
@@ -100,11 +100,11 @@ public:
         Yes,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> create_and_initialize(Type, String content_type, HTML::NavigationParams const&);
+    static WebIDL::ExceptionOr<GC::Ref<Document>> create_and_initialize(Type, String content_type, HTML::NavigationParams const&);
 
-    [[nodiscard]] static JS::NonnullGCPtr<Document> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
-    [[nodiscard]] static JS::NonnullGCPtr<Document> create_for_fragment_parsing(JS::Realm&);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Document>> construct_impl(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Document> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
+    [[nodiscard]] static GC::Ref<Document> create_for_fragment_parsing(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<Document>> construct_impl(JS::Realm&);
     virtual ~Document() override;
 
     // AD-HOC: This number increments whenever a node is added or removed from the document, or an element attribute changes.
@@ -114,7 +114,7 @@ public:
 
     WebIDL::ExceptionOr<void> populate_with_html_head_and_body();
 
-    JS::GCPtr<Selection::Selection> get_selection() const;
+    GC::Ptr<Selection::Selection> get_selection() const;
 
     WebIDL::ExceptionOr<String> cookie(Cookie::Source = Cookie::Source::NonHttp);
     WebIDL::ExceptionOr<void> set_cookie(StringView, Cookie::Source = Cookie::Source::NonHttp);
@@ -145,7 +145,7 @@ public:
     URL::URL base_url() const;
 
     void update_base_element(Badge<HTML::HTMLBaseElement>);
-    JS::GCPtr<HTML::HTMLBaseElement const> first_base_element_with_href_in_tree_order() const;
+    GC::Ptr<HTML::HTMLBaseElement const> first_base_element_with_href_in_tree_order() const;
 
     String url_string() const { return MUST(m_url.to_string()); }
     String document_uri() const { return url_string(); }
@@ -164,7 +164,7 @@ public:
     CSS::StyleSheetList& style_sheets();
     CSS::StyleSheetList const& style_sheets() const;
 
-    void for_each_active_css_style_sheet(Function<void(CSS::CSSStyleSheet&, JS::GCPtr<DOM::ShadowRoot>)>&& callback) const;
+    void for_each_active_css_style_sheet(Function<void(CSS::CSSStyleSheet&, GC::Ptr<DOM::ShadowRoot>)>&& callback) const;
 
     CSS::StyleSheetList* style_sheets_for_bindings() { return &style_sheets(); }
 
@@ -187,7 +187,7 @@ public:
 
     HTML::HTMLHtmlElement* html_element();
     HTML::HTMLHeadElement* head();
-    JS::GCPtr<HTML::HTMLTitleElement> title_element();
+    GC::Ptr<HTML::HTMLTitleElement> title_element();
 
     StringView dir() const;
     void set_dir(String const&);
@@ -204,7 +204,7 @@ public:
         return const_cast<Document*>(this)->head();
     }
 
-    JS::GCPtr<HTML::HTMLTitleElement const> title_element() const
+    GC::Ptr<HTML::HTMLTitleElement const> title_element() const
     {
         return const_cast<Document*>(this)->title_element();
     }
@@ -260,20 +260,20 @@ public:
     void schedule_style_update();
     void schedule_layout_update();
 
-    JS::NonnullGCPtr<NodeList> get_elements_by_name(FlyString const&);
+    GC::Ref<NodeList> get_elements_by_name(FlyString const&);
 
-    JS::NonnullGCPtr<HTMLCollection> applets();
-    JS::NonnullGCPtr<HTMLCollection> anchors();
-    JS::NonnullGCPtr<HTMLCollection> images();
-    JS::NonnullGCPtr<HTMLCollection> embeds();
-    JS::NonnullGCPtr<HTMLCollection> plugins();
-    JS::NonnullGCPtr<HTMLCollection> links();
-    JS::NonnullGCPtr<HTMLCollection> forms();
-    JS::NonnullGCPtr<HTMLCollection> scripts();
-    JS::NonnullGCPtr<HTML::HTMLAllCollection> all();
+    GC::Ref<HTMLCollection> applets();
+    GC::Ref<HTMLCollection> anchors();
+    GC::Ref<HTMLCollection> images();
+    GC::Ref<HTMLCollection> embeds();
+    GC::Ref<HTMLCollection> plugins();
+    GC::Ref<HTMLCollection> links();
+    GC::Ref<HTMLCollection> forms();
+    GC::Ref<HTMLCollection> scripts();
+    GC::Ref<HTML::HTMLAllCollection> all();
 
     // https://drafts.csswg.org/css-font-loading/#font-source
-    JS::NonnullGCPtr<CSS::FontFaceSet> fonts();
+    GC::Ref<CSS::FontFaceSet> fonts();
 
     void clear();
     void capture_events();
@@ -284,35 +284,35 @@ public:
 
     HTML::EnvironmentSettingsObject& relevant_settings_object() const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(String const& local_name, Variant<String, ElementCreationOptions> const& options);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element_ns(Optional<FlyString> const& namespace_, String const& qualified_name, Variant<String, ElementCreationOptions> const& options);
-    JS::NonnullGCPtr<DocumentFragment> create_document_fragment();
-    JS::NonnullGCPtr<Text> create_text_node(String const& data);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<CDATASection>> create_cdata_section(String const& data);
-    JS::NonnullGCPtr<Comment> create_comment(String const& data);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<ProcessingInstruction>> create_processing_instruction(String const& target, String const& data);
+    WebIDL::ExceptionOr<GC::Ref<Element>> create_element(String const& local_name, Variant<String, ElementCreationOptions> const& options);
+    WebIDL::ExceptionOr<GC::Ref<Element>> create_element_ns(Optional<FlyString> const& namespace_, String const& qualified_name, Variant<String, ElementCreationOptions> const& options);
+    GC::Ref<DocumentFragment> create_document_fragment();
+    GC::Ref<Text> create_text_node(String const& data);
+    WebIDL::ExceptionOr<GC::Ref<CDATASection>> create_cdata_section(String const& data);
+    GC::Ref<Comment> create_comment(String const& data);
+    WebIDL::ExceptionOr<GC::Ref<ProcessingInstruction>> create_processing_instruction(String const& target, String const& data);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> create_attribute(String const& local_name);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> create_attribute_ns(Optional<FlyString> const& namespace_, String const& qualified_name);
+    WebIDL::ExceptionOr<GC::Ref<Attr>> create_attribute(String const& local_name);
+    WebIDL::ExceptionOr<GC::Ref<Attr>> create_attribute_ns(Optional<FlyString> const& namespace_, String const& qualified_name);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> create_event(StringView interface);
-    JS::NonnullGCPtr<Range> create_range();
+    WebIDL::ExceptionOr<GC::Ref<Event>> create_event(StringView interface);
+    GC::Ref<Range> create_range();
 
     void set_pending_parsing_blocking_script(HTML::HTMLScriptElement*);
     HTML::HTMLScriptElement* pending_parsing_blocking_script() { return m_pending_parsing_blocking_script.ptr(); }
-    JS::NonnullGCPtr<HTML::HTMLScriptElement> take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>);
+    GC::Ref<HTML::HTMLScriptElement> take_pending_parsing_blocking_script(Badge<HTML::HTMLParser>);
 
     void add_script_to_execute_when_parsing_has_finished(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
-    Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>);
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_when_parsing_has_finished() { return m_scripts_to_execute_when_parsing_has_finished; }
+    Vector<GC::Root<HTML::HTMLScriptElement>> take_scripts_to_execute_when_parsing_has_finished(Badge<HTML::HTMLParser>);
+    Vector<GC::Ref<HTML::HTMLScriptElement>>& scripts_to_execute_when_parsing_has_finished() { return m_scripts_to_execute_when_parsing_has_finished; }
 
     void add_script_to_execute_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
-    Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>);
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_as_soon_as_possible() { return m_scripts_to_execute_as_soon_as_possible; }
+    Vector<GC::Root<HTML::HTMLScriptElement>> take_scripts_to_execute_as_soon_as_possible(Badge<HTML::HTMLParser>);
+    Vector<GC::Ref<HTML::HTMLScriptElement>>& scripts_to_execute_as_soon_as_possible() { return m_scripts_to_execute_as_soon_as_possible; }
 
     void add_script_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLScriptElement>, HTML::HTMLScriptElement&);
-    Vector<JS::Handle<HTML::HTMLScriptElement>> take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>);
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>>& scripts_to_execute_in_order_as_soon_as_possible() { return m_scripts_to_execute_in_order_as_soon_as_possible; }
+    Vector<GC::Root<HTML::HTMLScriptElement>> take_scripts_to_execute_in_order_as_soon_as_possible(Badge<HTML::HTMLParser>);
+    Vector<GC::Ref<HTML::HTMLScriptElement>>& scripts_to_execute_in_order_as_soon_as_possible() { return m_scripts_to_execute_in_order_as_soon_as_possible; }
 
     QuirksMode mode() const { return m_quirks_mode; }
     bool in_quirks_mode() const { return m_quirks_mode == QuirksMode::Yes; }
@@ -327,9 +327,9 @@ public:
     // https://dom.spec.whatwg.org/#xml-document
     bool is_xml_document() const { return m_type == Type::XML; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> import_node(JS::NonnullGCPtr<Node> node, bool deep);
+    WebIDL::ExceptionOr<GC::Ref<Node>> import_node(GC::Ref<Node> node, bool deep);
     void adopt_node(Node&);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> adopt_node_binding(JS::NonnullGCPtr<Node>);
+    WebIDL::ExceptionOr<GC::Ref<Node>> adopt_node_binding(GC::Ref<Node>);
 
     DocumentType const* doctype() const;
     String const& compat_mode() const;
@@ -355,7 +355,7 @@ public:
 
     bool created_for_appropriate_template_contents() const { return m_created_for_appropriate_template_contents; }
 
-    JS::NonnullGCPtr<Document> appropriate_template_contents_owner_document();
+    GC::Ref<Document> appropriate_template_contents_owner_document();
 
     StringView ready_state() const;
     HTML::DocumentReadyState readiness() const { return m_readiness; }
@@ -363,7 +363,7 @@ public:
 
     String last_modified() const;
 
-    [[nodiscard]] JS::GCPtr<HTML::Window> window() const { return m_window; }
+    [[nodiscard]] GC::Ptr<HTML::Window> window() const { return m_window; }
 
     void set_window(HTML::Window&);
 
@@ -371,11 +371,11 @@ public:
     WebIDL::ExceptionOr<void> writeln(Vector<String> const& strings);
 
     WebIDL::ExceptionOr<Document*> open(Optional<String> const& = {}, Optional<String> const& = {});
-    WebIDL::ExceptionOr<JS::GCPtr<HTML::WindowProxy>> open(StringView url, StringView name, StringView features);
+    WebIDL::ExceptionOr<GC::Ptr<HTML::WindowProxy>> open(StringView url, StringView name, StringView features);
     WebIDL::ExceptionOr<void> close();
 
-    JS::GCPtr<HTML::WindowProxy const> default_view() const;
-    JS::GCPtr<HTML::WindowProxy> default_view();
+    GC::Ptr<HTML::WindowProxy const> default_view() const;
+    GC::Ptr<HTML::WindowProxy> default_view();
 
     String const& content_type() const { return m_content_type; }
     void set_content_type(String content_type) { m_content_type = move(content_type); }
@@ -400,8 +400,8 @@ public:
 
     DOMImplementation* implementation();
 
-    JS::GCPtr<HTML::HTMLScriptElement> current_script() const { return m_current_script.ptr(); }
-    void set_current_script(Badge<HTML::HTMLScriptElement>, JS::GCPtr<HTML::HTMLScriptElement> script) { m_current_script = move(script); }
+    GC::Ptr<HTML::HTMLScriptElement> current_script() const { return m_current_script.ptr(); }
+    void set_current_script(Badge<HTML::HTMLScriptElement>, GC::Ptr<HTML::HTMLScriptElement> script) { m_current_script = move(script); }
 
     u32 ignore_destructive_writes_counter() const { return m_ignore_destructive_writes_counter; }
     void increment_ignore_destructive_writes_counter() { m_ignore_destructive_writes_counter++; }
@@ -419,10 +419,10 @@ public:
     [[nodiscard]] bool allow_declarative_shadow_roots() const;
     void set_allow_declarative_shadow_roots(bool);
 
-    JS::NonnullGCPtr<HTML::History> history();
-    JS::NonnullGCPtr<HTML::History> history() const;
+    GC::Ref<HTML::History> history();
+    GC::Ref<HTML::History> history() const;
 
-    [[nodiscard]] JS::GCPtr<HTML::Location> location();
+    [[nodiscard]] GC::Ptr<HTML::Location> location();
 
     bool anything_is_delaying_the_load_event() const;
     void increment_number_of_things_delaying_the_load_event(Badge<DocumentLoadEventDelayer>);
@@ -445,9 +445,9 @@ public:
     void run_the_scroll_steps();
 
     void evaluate_media_queries_and_report_changes();
-    void add_media_query_list(JS::NonnullGCPtr<CSS::MediaQueryList>);
+    void add_media_query_list(GC::Ref<CSS::MediaQueryList>);
 
-    JS::NonnullGCPtr<CSS::VisualViewport> visual_viewport();
+    GC::Ref<CSS::VisualViewport> visual_viewport();
     [[nodiscard]] CSSPixelRect viewport_rect() const;
 
     class ViewportClient {
@@ -474,8 +474,8 @@ public:
     };
     static WebIDL::ExceptionOr<PrefixAndTagName> validate_qualified_name(JS::Realm&, FlyString const& qualified_name);
 
-    JS::NonnullGCPtr<NodeIterator> create_node_iterator(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
-    JS::NonnullGCPtr<TreeWalker> create_tree_walker(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
+    GC::Ref<NodeIterator> create_node_iterator(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter>);
+    GC::Ref<TreeWalker> create_tree_walker(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter>);
 
     void register_node_iterator(Badge<NodeIterator>, NodeIterator&);
     void unregister_node_iterator(Badge<NodeIterator>, NodeIterator&);
@@ -498,7 +498,7 @@ public:
     bool has_active_favicon() const { return m_active_favicon; }
     void check_favicon_after_loading_link_resource();
 
-    JS::GCPtr<HTML::CustomElementDefinition> lookup_custom_element_definition(Optional<FlyString> const& namespace_, FlyString const& local_name, Optional<String> const& is) const;
+    GC::Ptr<HTML::CustomElementDefinition> lookup_custom_element_definition(Optional<FlyString> const& namespace_, FlyString const& local_name, Optional<String> const& is) const;
 
     void increment_throw_on_dynamic_markup_insertion_counter(Badge<HTML::HTMLParser>);
     void decrement_throw_on_dynamic_markup_insertion_counter(Badge<HTML::HTMLParser>);
@@ -531,18 +531,18 @@ public:
     HTML::PolicyContainer policy_container() const;
     void set_policy_container(HTML::PolicyContainer);
 
-    Vector<JS::Handle<HTML::Navigable>> descendant_navigables();
-    Vector<JS::Handle<HTML::Navigable>> const descendant_navigables() const;
-    Vector<JS::Handle<HTML::Navigable>> inclusive_descendant_navigables();
-    Vector<JS::Handle<HTML::Navigable>> ancestor_navigables();
-    Vector<JS::Handle<HTML::Navigable>> const ancestor_navigables() const;
-    Vector<JS::Handle<HTML::Navigable>> inclusive_ancestor_navigables();
-    Vector<JS::Handle<HTML::Navigable>> document_tree_child_navigables();
+    Vector<GC::Root<HTML::Navigable>> descendant_navigables();
+    Vector<GC::Root<HTML::Navigable>> const descendant_navigables() const;
+    Vector<GC::Root<HTML::Navigable>> inclusive_descendant_navigables();
+    Vector<GC::Root<HTML::Navigable>> ancestor_navigables();
+    Vector<GC::Root<HTML::Navigable>> const ancestor_navigables() const;
+    Vector<GC::Root<HTML::Navigable>> inclusive_ancestor_navigables();
+    Vector<GC::Root<HTML::Navigable>> document_tree_child_navigables();
 
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document
     void destroy();
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#destroy-a-document-and-its-descendants
-    void destroy_a_document_and_its_descendants(JS::GCPtr<JS::HeapFunction<void()>> after_all_destruction = {});
+    void destroy_a_document_and_its_descendants(GC::Ptr<GC::Function<void()>> after_all_destruction = {});
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#abort-a-document
     void abort();
@@ -550,12 +550,12 @@ public:
     void abort_a_document_and_its_descendants();
 
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#unload-a-document
-    void unload(JS::GCPtr<Document> new_document = nullptr);
+    void unload(GC::Ptr<Document> new_document = nullptr);
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#unload-a-document-and-its-descendants
-    void unload_a_document_and_its_descendants(JS::GCPtr<Document> new_document, JS::GCPtr<JS::HeapFunction<void()>> after_all_unloads = {});
+    void unload_a_document_and_its_descendants(GC::Ptr<Document> new_document, GC::Ptr<GC::Function<void()>> after_all_unloads = {});
 
     // https://html.spec.whatwg.org/multipage/dom.html#active-parser
-    JS::GCPtr<HTML::HTMLParser> active_parser();
+    GC::Ptr<HTML::HTMLParser> active_parser();
 
     // https://html.spec.whatwg.org/multipage/dom.html#load-timing-info
     DocumentLoadTimingInfo& load_timing_info() { return m_load_timing_info; }
@@ -604,7 +604,7 @@ public:
 
     void start_intersection_observing_a_lazy_loading_element(Element&);
 
-    void shared_declarative_refresh_steps(StringView input, JS::GCPtr<HTML::HTMLMetaElement const> meta_element = nullptr);
+    void shared_declarative_refresh_steps(StringView input, GC::Ptr<HTML::HTMLMetaElement const> meta_element = nullptr);
 
     struct TopOfTheDocument { };
     using IndicatedPart = Variant<Element*, TopOfTheDocument>;
@@ -614,42 +614,42 @@ public:
 
     HTML::SourceSnapshotParams snapshot_source_snapshot_params() const;
 
-    void update_for_history_step_application(JS::NonnullGCPtr<HTML::SessionHistoryEntry>, bool do_not_reactivate, size_t script_history_length, size_t script_history_index, Optional<Bindings::NavigationType> navigation_type, Optional<Vector<JS::NonnullGCPtr<HTML::SessionHistoryEntry>>> entries_for_navigation_api = {}, JS::GCPtr<HTML::SessionHistoryEntry> previous_entry_for_activation = {}, bool update_navigation_api = true);
+    void update_for_history_step_application(GC::Ref<HTML::SessionHistoryEntry>, bool do_not_reactivate, size_t script_history_length, size_t script_history_index, Optional<Bindings::NavigationType> navigation_type, Optional<Vector<GC::Ref<HTML::SessionHistoryEntry>>> entries_for_navigation_api = {}, GC::Ptr<HTML::SessionHistoryEntry> previous_entry_for_activation = {}, bool update_navigation_api = true);
 
-    HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>>& shared_resource_requests();
+    HashMap<URL::URL, GC::Ptr<HTML::SharedResourceRequest>>& shared_resource_requests();
 
-    void restore_the_history_object_state(JS::NonnullGCPtr<HTML::SessionHistoryEntry> entry);
+    void restore_the_history_object_state(GC::Ref<HTML::SessionHistoryEntry> entry);
 
-    JS::NonnullGCPtr<Animations::DocumentTimeline> timeline();
+    GC::Ref<Animations::DocumentTimeline> timeline();
     auto const& last_animation_frame_timestamp() const { return m_last_animation_frame_timestamp; }
 
-    void associate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline>);
-    void disassociate_with_timeline(JS::NonnullGCPtr<Animations::AnimationTimeline>);
+    void associate_with_timeline(GC::Ref<Animations::AnimationTimeline>);
+    void disassociate_with_timeline(GC::Ref<Animations::AnimationTimeline>);
 
     struct PendingAnimationEvent {
-        JS::NonnullGCPtr<DOM::Event> event;
-        JS::NonnullGCPtr<Animations::Animation> animation;
-        JS::NonnullGCPtr<DOM::EventTarget> target;
+        GC::Ref<DOM::Event> event;
+        GC::Ref<Animations::Animation> animation;
+        GC::Ref<DOM::EventTarget> target;
         Optional<double> scheduled_event_time;
     };
     void append_pending_animation_event(PendingAnimationEvent const&);
     void update_animations_and_send_events(Optional<double> const& timestamp);
     void remove_replaced_animations();
 
-    WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animations::Animation>>> get_animations();
+    WebIDL::ExceptionOr<Vector<GC::Ref<Animations::Animation>>> get_animations();
 
     bool ready_to_run_scripts() const { return m_ready_to_run_scripts; }
     void set_ready_to_run_scripts() { m_ready_to_run_scripts = true; }
 
-    JS::GCPtr<HTML::SessionHistoryEntry> latest_entry() const { return m_latest_entry; }
-    void set_latest_entry(JS::GCPtr<HTML::SessionHistoryEntry> e) { m_latest_entry = e; }
+    GC::Ptr<HTML::SessionHistoryEntry> latest_entry() const { return m_latest_entry; }
+    void set_latest_entry(GC::Ptr<HTML::SessionHistoryEntry> e) { m_latest_entry = e; }
 
-    void element_id_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
-    void element_with_id_was_added(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
-    void element_with_id_was_removed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
-    void element_name_changed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
-    void element_with_name_was_added(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
-    void element_with_name_was_removed(Badge<DOM::Element>, JS::NonnullGCPtr<DOM::Element> element);
+    void element_id_changed(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
+    void element_with_id_was_added(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
+    void element_with_id_was_removed(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
+    void element_name_changed(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
+    void element_with_name_was_added(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
+    void element_with_name_was_removed(Badge<DOM::Element>, GC::Ref<DOM::Element> element);
 
     void add_form_associated_element_with_form_attribute(HTML::FormAssociatedElement&);
     void remove_form_associated_element_with_form_attribute(HTML::FormAssociatedElement&);
@@ -660,22 +660,22 @@ public:
     WebIDL::ExceptionOr<void> set_design_mode(String const&);
 
     Element const* element_from_point(double x, double y);
-    JS::MarkedVector<JS::NonnullGCPtr<Element>> elements_from_point(double x, double y);
-    JS::GCPtr<Element const> scrolling_element() const;
+    GC::MarkedVector<GC::Ref<Element>> elements_from_point(double x, double y);
+    GC::Ptr<Element const> scrolling_element() const;
 
     void set_needs_to_resolve_paint_only_properties() { m_needs_to_resolve_paint_only_properties = true; }
     void set_needs_animated_style_update() { m_needs_animated_style_update = true; }
 
     virtual JS::Value named_item_value(FlyString const& name) const override;
     virtual Vector<FlyString> supported_property_names() const override;
-    Vector<JS::NonnullGCPtr<DOM::Element>> const& potentially_named_elements() const { return m_potentially_named_elements; }
+    Vector<GC::Ref<DOM::Element>> const& potentially_named_elements() const { return m_potentially_named_elements; }
 
     void gather_active_observations_at_depth(size_t depth);
     [[nodiscard]] size_t broadcast_active_resize_observations();
     [[nodiscard]] bool has_active_resize_observations();
     [[nodiscard]] bool has_skipped_resize_observations();
 
-    JS::NonnullGCPtr<WebIDL::ObservableArray> adopted_style_sheets() const;
+    GC::Ref<WebIDL::ObservableArray> adopted_style_sheets() const;
     WebIDL::ExceptionOr<void> set_adopted_style_sheets(JS::Value);
 
     void register_shadow_root(Badge<DOM::ShadowRoot>, DOM::ShadowRoot&);
@@ -683,35 +683,35 @@ public:
     void for_each_shadow_root(Function<void(DOM::ShadowRoot&)>&& callback);
     void for_each_shadow_root(Function<void(DOM::ShadowRoot&)>&& callback) const;
 
-    void add_an_element_to_the_top_layer(JS::NonnullGCPtr<Element>);
-    void request_an_element_to_be_remove_from_the_top_layer(JS::NonnullGCPtr<Element>);
-    void remove_an_element_from_the_top_layer_immediately(JS::NonnullGCPtr<Element>);
+    void add_an_element_to_the_top_layer(GC::Ref<Element>);
+    void request_an_element_to_be_remove_from_the_top_layer(GC::Ref<Element>);
+    void remove_an_element_from_the_top_layer_immediately(GC::Ref<Element>);
     void process_top_layer_removals();
 
-    OrderedHashTable<JS::NonnullGCPtr<Element>> const& top_layer_elements() const { return m_top_layer_elements; }
+    OrderedHashTable<GC::Ref<Element>> const& top_layer_elements() const { return m_top_layer_elements; }
 
     size_t transition_generation() const { return m_transition_generation; }
 
     // Does document represent an embedded svg img
     [[nodiscard]] bool is_decoded_svg() const;
 
-    Vector<JS::Handle<DOM::Range>> find_matching_text(String const&, CaseSensitivity);
+    Vector<GC::Root<DOM::Range>> find_matching_text(String const&, CaseSensitivity);
 
     void parse_html_from_a_string(StringView);
-    static JS::NonnullGCPtr<Document> parse_html_unsafe(JS::VM&, StringView);
+    static GC::Ref<Document> parse_html_unsafe(JS::VM&, StringView);
 
-    void set_console_client(JS::GCPtr<JS::ConsoleClient> console_client) { m_console_client = console_client; }
-    JS::GCPtr<JS::ConsoleClient> console_client() const { return m_console_client; }
+    void set_console_client(GC::Ptr<JS::ConsoleClient> console_client) { m_console_client = console_client; }
+    GC::Ptr<JS::ConsoleClient> console_client() const { return m_console_client; }
 
     InputEventsTarget* active_input_events_target();
-    JS::GCPtr<DOM::Position> cursor_position() const;
+    GC::Ptr<DOM::Position> cursor_position() const;
 
     bool cursor_blink_state() const { return m_cursor_blink_state; }
 
     // Cached pointer to the last known node navigable.
     // If this document is currently the "active document" of the cached navigable, the cache is still valid.
-    JS::GCPtr<HTML::Navigable> cached_navigable();
-    void set_cached_navigable(JS::GCPtr<HTML::Navigable>);
+    GC::Ptr<HTML::Navigable> cached_navigable();
+    void set_cached_navigable(GC::Ptr<HTML::Navigable>);
 
     [[nodiscard]] bool needs_repaint() const { return m_needs_repaint; }
     void set_needs_display(InvalidateDisplayList = InvalidateDisplayList::Yes);
@@ -746,7 +746,7 @@ public:
 
     void reset_cursor_blink_cycle();
 
-    JS::NonnullGCPtr<EditingHostManager> editing_host_manager() const { return *m_editing_host_manager; }
+    GC::Ref<EditingHostManager> editing_host_manager() const { return *m_editing_host_manager; }
 
 protected:
     virtual void initialize(JS::Realm&) override;
@@ -756,7 +756,7 @@ protected:
 
 private:
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<EventTarget> global_event_handlers_to_event_target(FlyString const&) final { return *this; }
+    virtual GC::Ptr<EventTarget> global_event_handlers_to_event_target(FlyString const&) final { return *this; }
 
     void tear_down_layout_tree();
 
@@ -769,44 +769,44 @@ private:
     WebIDL::ExceptionOr<void> run_the_document_write_steps(StringView);
 
     void queue_intersection_observer_task();
-    void queue_an_intersection_observer_entry(IntersectionObserver::IntersectionObserver&, HighResolutionTime::DOMHighResTimeStamp time, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> root_bounds, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, JS::NonnullGCPtr<Element> target);
+    void queue_an_intersection_observer_entry(IntersectionObserver::IntersectionObserver&, HighResolutionTime::DOMHighResTimeStamp time, GC::Ref<Geometry::DOMRectReadOnly> root_bounds, GC::Ref<Geometry::DOMRectReadOnly> bounding_client_rect, GC::Ref<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, GC::Ref<Element> target);
 
     Element* find_a_potential_indicated_element(FlyString const& fragment) const;
 
-    void dispatch_events_for_animation_if_necessary(JS::NonnullGCPtr<Animations::Animation>);
+    void dispatch_events_for_animation_if_necessary(GC::Ref<Animations::Animation>);
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
     OwnPtr<CSS::StyleComputer> m_style_computer;
-    JS::GCPtr<CSS::StyleSheetList> m_style_sheets;
-    JS::GCPtr<Node> m_hovered_node;
-    JS::GCPtr<Node> m_inspected_node;
+    GC::Ptr<CSS::StyleSheetList> m_style_sheets;
+    GC::Ptr<Node> m_hovered_node;
+    GC::Ptr<Node> m_inspected_node;
     Optional<CSS::Selector::PseudoElement::Type> m_inspected_pseudo_element;
-    JS::GCPtr<Node> m_active_favicon;
+    GC::Ptr<Node> m_active_favicon;
     WeakPtr<HTML::BrowsingContext> m_browsing_context;
     URL::URL m_url;
 
-    JS::GCPtr<HTML::Window> m_window;
+    GC::Ptr<HTML::Window> m_window;
 
-    JS::GCPtr<Layout::Viewport> m_layout_root;
+    GC::Ptr<Layout::Viewport> m_layout_root;
 
     Optional<Color> m_normal_link_color;
     Optional<Color> m_active_link_color;
     Optional<Color> m_visited_link_color;
 
-    JS::GCPtr<HTML::HTMLParser> m_parser;
+    GC::Ptr<HTML::HTMLParser> m_parser;
     bool m_active_parser_was_aborted { false };
 
     String m_source;
 
-    JS::GCPtr<HTML::HTMLScriptElement> m_pending_parsing_blocking_script;
+    GC::Ptr<HTML::HTMLScriptElement> m_pending_parsing_blocking_script;
 
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_when_parsing_has_finished;
+    Vector<GC::Ref<HTML::HTMLScriptElement>> m_scripts_to_execute_when_parsing_has_finished;
 
     // https://html.spec.whatwg.org/multipage/scripting.html#list-of-scripts-that-will-execute-in-order-as-soon-as-possible
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_in_order_as_soon_as_possible;
+    Vector<GC::Ref<HTML::HTMLScriptElement>> m_scripts_to_execute_in_order_as_soon_as_possible;
 
     // https://html.spec.whatwg.org/multipage/scripting.html#set-of-scripts-that-will-execute-as-soon-as-possible
-    Vector<JS::NonnullGCPtr<HTML::HTMLScriptElement>> m_scripts_to_execute_as_soon_as_possible;
+    Vector<GC::Ref<HTML::HTMLScriptElement>> m_scripts_to_execute_as_soon_as_possible;
 
     QuirksMode m_quirks_mode { QuirksMode::No };
 
@@ -815,13 +815,13 @@ private:
 
     bool m_editable { false };
 
-    JS::GCPtr<Element> m_focused_element;
-    JS::GCPtr<Element> m_active_element;
-    JS::GCPtr<Element> m_target_element;
+    GC::Ptr<Element> m_focused_element;
+    GC::Ptr<Element> m_active_element;
+    GC::Ptr<Element> m_target_element;
 
     bool m_created_for_appropriate_template_contents { false };
-    JS::GCPtr<Document> m_associated_inert_template_document;
-    JS::GCPtr<Document> m_appropriate_template_contents_owner_document;
+    GC::Ptr<Document> m_associated_inert_template_document;
+    GC::Ptr<Document> m_appropriate_template_contents_owner_document;
 
     HTML::DocumentReadyState m_readiness { HTML::DocumentReadyState::Loading };
     String m_content_type { "application/xml"_string };
@@ -830,8 +830,8 @@ private:
 
     bool m_ready_for_post_load_tasks { false };
 
-    JS::GCPtr<DOMImplementation> m_implementation;
-    JS::GCPtr<HTML::HTMLScriptElement> m_current_script;
+    GC::Ptr<DOMImplementation> m_implementation;
+    GC::Ptr<HTML::HTMLScriptElement> m_current_script;
 
     bool m_should_invalidate_styles_on_attribute_changes { true };
 
@@ -846,7 +846,7 @@ private:
     // https://html.spec.whatwg.org/multipage/semantics.html#script-blocking-style-sheet-counter
     u32 m_script_blocking_style_sheet_counter { 0 };
 
-    JS::GCPtr<HTML::History> m_history;
+    GC::Ptr<HTML::History> m_history;
 
     size_t m_number_of_things_delaying_the_load_event { 0 };
 
@@ -862,10 +862,10 @@ private:
     HashTable<ViewportClient*> m_viewport_clients;
 
     // https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scroll-event-targets
-    Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scroll_event_targets;
+    Vector<GC::Ref<EventTarget>> m_pending_scroll_event_targets;
 
     // https://w3c.github.io/csswg-drafts/cssom-view-1/#document-pending-scrollend-event-targets
-    Vector<JS::NonnullGCPtr<EventTarget>> m_pending_scrollend_event_targets;
+    Vector<GC::Ref<EventTarget>> m_pending_scrollend_event_targets;
 
     // Used by evaluate_media_queries_and_report_changes().
     Vector<WeakPtr<CSS::MediaQueryList>> m_media_query_lists;
@@ -876,9 +876,9 @@ private:
 
     bool m_needs_animated_style_update { false };
 
-    HashTable<JS::GCPtr<NodeIterator>> m_node_iterators;
+    HashTable<GC::Ptr<NodeIterator>> m_node_iterators;
 
-    HashTable<JS::NonnullGCPtr<DocumentObserver>> m_document_observers;
+    HashTable<GC::Ref<DocumentObserver>> m_document_observers;
 
     // https://html.spec.whatwg.org/multipage/dom.html#is-initial-about:blank
     bool m_is_initial_about_blank { false };
@@ -895,17 +895,17 @@ private:
     // https://dom.spec.whatwg.org/#concept-document-origin
     URL::Origin m_origin;
 
-    JS::GCPtr<HTMLCollection> m_applets;
-    JS::GCPtr<HTMLCollection> m_anchors;
-    JS::GCPtr<HTMLCollection> m_images;
-    JS::GCPtr<HTMLCollection> m_embeds;
-    JS::GCPtr<HTMLCollection> m_links;
-    JS::GCPtr<HTMLCollection> m_forms;
-    JS::GCPtr<HTMLCollection> m_scripts;
-    JS::GCPtr<HTML::HTMLAllCollection> m_all;
+    GC::Ptr<HTMLCollection> m_applets;
+    GC::Ptr<HTMLCollection> m_anchors;
+    GC::Ptr<HTMLCollection> m_images;
+    GC::Ptr<HTMLCollection> m_embeds;
+    GC::Ptr<HTMLCollection> m_links;
+    GC::Ptr<HTMLCollection> m_forms;
+    GC::Ptr<HTMLCollection> m_scripts;
+    GC::Ptr<HTML::HTMLAllCollection> m_all;
 
     // https://drafts.csswg.org/css-font-loading/#font-source
-    JS::GCPtr<CSS::FontFaceSet> m_fonts;
+    GC::Ptr<CSS::FontFaceSet> m_fonts;
 
     // https://html.spec.whatwg.org/#completely-loaded-time
     Optional<AK::UnixDateTime> m_completely_loaded_time;
@@ -929,18 +929,18 @@ private:
     DocumentUnloadTimingInfo m_previous_document_unload_timing;
 
     // https://w3c.github.io/selection-api/#dfn-selection
-    JS::GCPtr<Selection::Selection> m_selection;
+    GC::Ptr<Selection::Selection> m_selection;
 
     // NOTE: This is a cache to make finding the first <base href> element O(1).
-    JS::GCPtr<HTML::HTMLBaseElement const> m_first_base_element_with_href_in_tree_order;
+    GC::Ptr<HTML::HTMLBaseElement const> m_first_base_element_with_href_in_tree_order;
 
     // https://html.spec.whatwg.org/multipage/images.html#list-of-available-images
-    JS::GCPtr<HTML::ListOfAvailableImages> m_list_of_available_images;
+    GC::Ptr<HTML::ListOfAvailableImages> m_list_of_available_images;
 
-    JS::GCPtr<CSS::VisualViewport> m_visual_viewport;
+    GC::Ptr<CSS::VisualViewport> m_visual_viewport;
 
     // NOTE: Not in the spec per se, but Document must be able to access all IntersectionObservers whose root is in the document.
-    IGNORE_GC OrderedHashTable<JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver>> m_intersection_observers;
+    IGNORE_GC OrderedHashTable<GC::Ref<IntersectionObserver::IntersectionObserver>> m_intersection_observers;
 
     // https://www.w3.org/TR/intersection-observer/#document-intersectionobservertaskqueued
     // Each document has an IntersectionObserverTaskQueued flag which is initialized to false.
@@ -948,9 +948,9 @@ private:
 
     // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#lazy-load-intersection-observer
     // Each Document has a lazy load intersection observer, initially set to null but can be set to an IntersectionObserver instance.
-    JS::GCPtr<IntersectionObserver::IntersectionObserver> m_lazy_load_intersection_observer;
+    GC::Ptr<IntersectionObserver::IntersectionObserver> m_lazy_load_intersection_observer;
 
-    Vector<JS::NonnullGCPtr<ResizeObserver::ResizeObserver>> m_resize_observers;
+    Vector<GC::Ref<ResizeObserver::ResizeObserver>> m_resize_observers;
 
     // https://html.spec.whatwg.org/multipage/semantics.html#will-declaratively-refresh
     // A Document object has an associated will declaratively refresh (a boolean). It is initially false.
@@ -961,15 +961,15 @@ private:
     TemporaryDocumentForFragmentParsing m_temporary_document_for_fragment_parsing { TemporaryDocumentForFragmentParsing::No };
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#latest-entry
-    JS::GCPtr<HTML::SessionHistoryEntry> m_latest_entry;
+    GC::Ptr<HTML::SessionHistoryEntry> m_latest_entry;
 
-    HashMap<URL::URL, JS::GCPtr<HTML::SharedResourceRequest>> m_shared_resource_requests;
+    HashMap<URL::URL, GC::Ptr<HTML::SharedResourceRequest>> m_shared_resource_requests;
 
     // https://www.w3.org/TR/web-animations-1/#timeline-associated-with-a-document
-    HashTable<JS::NonnullGCPtr<Animations::AnimationTimeline>> m_associated_animation_timelines;
+    HashTable<GC::Ref<Animations::AnimationTimeline>> m_associated_animation_timelines;
 
     // https://www.w3.org/TR/web-animations-1/#document-default-document-timeline
-    JS::GCPtr<Animations::DocumentTimeline> m_default_timeline;
+    GC::Ptr<Animations::DocumentTimeline> m_default_timeline;
     Optional<double> m_last_animation_frame_timestamp;
 
     // https://www.w3.org/TR/web-animations-1/#pending-animation-event-queue
@@ -986,15 +986,15 @@ private:
 
     Vector<HTML::FormAssociatedElement*> m_form_associated_elements_with_form_attribute;
 
-    Vector<JS::NonnullGCPtr<DOM::Element>> m_potentially_named_elements;
+    Vector<GC::Ref<DOM::Element>> m_potentially_named_elements;
 
     bool m_design_mode_enabled { false };
 
     bool m_needs_to_resolve_paint_only_properties { true };
 
-    mutable JS::GCPtr<WebIDL::ObservableArray> m_adopted_style_sheets;
+    mutable GC::Ptr<WebIDL::ObservableArray> m_adopted_style_sheets;
 
-    Vector<JS::NonnullGCPtr<DOM::ShadowRoot>> m_shadow_roots;
+    Vector<GC::Ref<DOM::ShadowRoot>> m_shadow_roots;
 
     Optional<Core::DateTime> m_last_modified;
 
@@ -1004,8 +1004,8 @@ private:
     // Documents have a top layer, an ordered set containing elements from the document.
     // Elements in the top layer do not lay out normally based on their position in the document;
     // instead they generate boxes as if they were siblings of the root element.
-    OrderedHashTable<JS::NonnullGCPtr<Element>> m_top_layer_elements;
-    OrderedHashTable<JS::NonnullGCPtr<Element>> m_top_layer_pending_removals;
+    OrderedHashTable<GC::Ref<Element>> m_top_layer_elements;
+    OrderedHashTable<GC::Ref<Element>> m_top_layer_pending_removals;
 
     // https://dom.spec.whatwg.org/#document-allow-declarative-shadow-roots
     bool m_allow_declarative_shadow_roots { false };
@@ -1013,7 +1013,7 @@ private:
     // https://w3c.github.io/selection-api/#dfn-has-scheduled-selectionchange-event
     bool m_has_scheduled_selectionchange_event { false };
 
-    JS::GCPtr<JS::ConsoleClient> m_console_client;
+    GC::Ptr<JS::ConsoleClient> m_console_client;
 
     RefPtr<Core::Timer> m_cursor_blink_timer;
     bool m_cursor_blink_state { false };
@@ -1031,7 +1031,7 @@ private:
     mutable OwnPtr<Unicode::Segmenter> m_grapheme_segmenter;
     mutable OwnPtr<Unicode::Segmenter> m_word_segmenter;
 
-    JS::NonnullGCPtr<EditingHostManager> m_editing_host_manager;
+    GC::Ref<EditingHostManager> m_editing_host_manager;
 };
 
 template<>
diff --git a/Libraries/LibWeb/DOM/DocumentFragment.cpp b/Libraries/LibWeb/DOM/DocumentFragment.cpp
index 8e0086ff0b0..dfca5b2e535 100644
--- a/Libraries/LibWeb/DOM/DocumentFragment.cpp
+++ b/Libraries/LibWeb/DOM/DocumentFragment.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DocumentFragment);
+GC_DEFINE_ALLOCATOR(DocumentFragment);
 
 DocumentFragment::DocumentFragment(Document& document)
     : ParentNode(document, NodeType::DOCUMENT_FRAGMENT_NODE)
@@ -35,7 +35,7 @@ void DocumentFragment::set_host(Web::DOM::Element* element)
 }
 
 // https://dom.spec.whatwg.org/#dom-documentfragment-documentfragment
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> DocumentFragment::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> DocumentFragment::construct_impl(JS::Realm& realm)
 {
     auto& window = verify_cast<HTML::Window>(realm.global_object());
     return realm.create<DocumentFragment>(window.associated_document());
diff --git a/Libraries/LibWeb/DOM/DocumentFragment.h b/Libraries/LibWeb/DOM/DocumentFragment.h
index 1e5a0391156..5a3fe876d5a 100644
--- a/Libraries/LibWeb/DOM/DocumentFragment.h
+++ b/Libraries/LibWeb/DOM/DocumentFragment.h
@@ -16,10 +16,10 @@ class DocumentFragment
     : public ParentNode
     , public NonElementParentNode<DocumentFragment> {
     WEB_PLATFORM_OBJECT(DocumentFragment, ParentNode);
-    JS_DECLARE_ALLOCATOR(DocumentFragment);
+    GC_DECLARE_ALLOCATOR(DocumentFragment);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> construct_impl(JS::Realm& realm);
+    static WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> construct_impl(JS::Realm& realm);
 
     virtual ~DocumentFragment() override = default;
 
@@ -38,7 +38,7 @@ protected:
 
 private:
     // https://dom.spec.whatwg.org/#concept-documentfragment-host
-    JS::GCPtr<Element> m_host;
+    GC::Ptr<Element> m_host;
 };
 
 template<>
diff --git a/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.cpp b/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.cpp
index f95c5dafd2f..754a10031f8 100644
--- a/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.cpp
+++ b/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.cpp
@@ -10,7 +10,7 @@
 namespace Web::DOM {
 
 DocumentLoadEventDelayer::DocumentLoadEventDelayer(Document& document)
-    : m_document(JS::make_handle(document))
+    : m_document(GC::make_root(document))
 {
     m_document->increment_number_of_things_delaying_the_load_event({});
 }
diff --git a/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.h b/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.h
index 98bb567b33f..33c2bfe8221 100644
--- a/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.h
+++ b/Libraries/LibWeb/DOM/DocumentLoadEventDelayer.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/Noncopyable.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::DOM {
@@ -21,7 +21,7 @@ public:
     ~DocumentLoadEventDelayer();
 
 private:
-    JS::Handle<Document> m_document;
+    GC::Root<Document> m_document;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/DocumentLoading.cpp b/Libraries/LibWeb/DOM/DocumentLoading.cpp
index 9a88b983e8a..93addf35481 100644
--- a/Libraries/LibWeb/DOM/DocumentLoading.cpp
+++ b/Libraries/LibWeb/DOM/DocumentLoading.cpp
@@ -61,7 +61,7 @@ bool build_xml_document(DOM::Document& document, ByteBuffer const& data, Optiona
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#navigate-html
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_html_document(HTML::NavigationParams const& navigation_params)
+static WebIDL::ExceptionOr<GC::Ref<DOM::Document>> load_html_document(HTML::NavigationParams const& navigation_params)
 {
     // To load an HTML document, given navigation params navigationParams:
 
@@ -92,19 +92,19 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_html_document(H
     //    causes a load event to be fired.
     else {
         // FIXME: Parse as we receive the document data, instead of waiting for the whole document to be fetched first.
-        auto process_body = JS::create_heap_function(document->heap(), [document, url = navigation_params.response->url().value(), mime_type = navigation_params.response->header_list()->extract_mime_type()](ByteBuffer data) {
-            Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(document->heap(), [document = document, data = move(data), url = url, mime_type] {
+        auto process_body = GC::create_function(document->heap(), [document, url = navigation_params.response->url().value(), mime_type = navigation_params.response->header_list()->extract_mime_type()](ByteBuffer data) {
+            Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(document->heap(), [document = document, data = move(data), url = url, mime_type] {
                 auto parser = HTML::HTMLParser::create_with_uncertain_encoding(document, data, mime_type);
                 parser->run(url);
             }));
         });
 
-        auto process_body_error = JS::create_heap_function(document->heap(), [](JS::Value) {
+        auto process_body_error = GC::create_function(document->heap(), [](JS::Value) {
             dbgln("FIXME: Load html page with an error if read of body failed.");
         });
 
         auto& realm = document->realm();
-        navigation_params.response->body()->fully_read(realm, process_body, process_body_error, JS::NonnullGCPtr { realm.global_object() });
+        navigation_params.response->body()->fully_read(realm, process_body, process_body_error, GC::Ref { realm.global_object() });
     }
 
     // 4. Return document.
@@ -112,7 +112,7 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_html_document(H
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#read-xml
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_xml_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
+static WebIDL::ExceptionOr<GC::Ref<DOM::Document>> load_xml_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
 {
     // When faced with displaying an XML file inline, provided navigation params navigationParams and a string type, user agents
     // must follow the requirements defined in XML and Namespaces in XML, XML Media Types, DOM, and other relevant specifications
@@ -147,7 +147,7 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_xml_document(HT
     if (auto maybe_encoding = type.parameters().get("charset"sv); maybe_encoding.has_value())
         content_encoding = maybe_encoding.value();
 
-    auto process_body = JS::create_heap_function(document->heap(), [document, url = navigation_params.response->url().value(), content_encoding = move(content_encoding), mime = type](ByteBuffer data) {
+    auto process_body = GC::create_function(document->heap(), [document, url = navigation_params.response->url().value(), content_encoding = move(content_encoding), mime = type](ByteBuffer data) {
         Optional<TextCodec::Decoder&> decoder;
         // The actual HTTP headers and other metadata, not the headers as mutated or implied by the algorithms given in this specification,
         // are the ones that must be used when determining the character encoding according to the rules given in the above specifications.
@@ -190,18 +190,18 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_xml_document(HT
         }
     });
 
-    auto process_body_error = JS::create_heap_function(document->heap(), [](JS::Value) {
+    auto process_body_error = GC::create_function(document->heap(), [](JS::Value) {
         dbgln("FIXME: Load html page with an error if read of body failed.");
     });
 
     auto& realm = document->realm();
-    navigation_params.response->body()->fully_read(realm, process_body, process_body_error, JS::NonnullGCPtr { realm.global_object() });
+    navigation_params.response->body()->fully_read(realm, process_body, process_body_error, GC::Ref { realm.global_object() });
 
     return document;
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#navigate-text
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_text_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
+static WebIDL::ExceptionOr<GC::Ref<DOM::Document>> load_text_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
 {
     // To load a text document, given a navigation params navigationParams and a string type:
 
@@ -227,7 +227,7 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_text_document(H
     //    document's relevant global object to have the parser to process the implied EOF character, which eventually causes a
     //    load event to be fired.
     // FIXME: Parse as we receive the document data, instead of waiting for the whole document to be fetched first.
-    auto process_body = JS::create_heap_function(document->heap(), [document, url = navigation_params.response->url().value(), mime = type](ByteBuffer data) {
+    auto process_body = GC::create_function(document->heap(), [document, url = navigation_params.response->url().value(), mime = type](ByteBuffer data) {
         auto encoding = run_encoding_sniffing_algorithm(document, data, mime);
         dbgln_if(HTML_PARSER_DEBUG, "The encoding sniffing algorithm returned encoding '{}'", encoding);
 
@@ -253,19 +253,19 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_text_document(H
         MUST(title_element->append_child(*title_text));
     });
 
-    auto process_body_error = JS::create_heap_function(document->heap(), [](JS::Value) {
+    auto process_body_error = GC::create_function(document->heap(), [](JS::Value) {
         dbgln("FIXME: Load html page with an error if read of body failed.");
     });
 
     auto& realm = document->realm();
-    navigation_params.response->body()->fully_read(realm, process_body, process_body_error, JS::NonnullGCPtr { realm.global_object() });
+    navigation_params.response->body()->fully_read(realm, process_body, process_body_error, GC::Ref { realm.global_object() });
 
     // 6. Return document.
     return document;
 }
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#navigate-media
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_media_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
+static WebIDL::ExceptionOr<GC::Ref<DOM::Document>> load_media_document(HTML::NavigationParams const& navigation_params, MimeSniff::MimeType type)
 {
     // To load a media document, given navigationParams and a string type:
 
@@ -348,9 +348,9 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::Document>> load_media_document(
     auto& realm = document->realm();
     navigation_params.response->body()->fully_read(
         realm,
-        JS::create_heap_function(document->heap(), [document](ByteBuffer) { HTML::HTMLParser::the_end(document); }),
-        JS::create_heap_function(document->heap(), [](JS::Value) {}),
-        JS::NonnullGCPtr { realm.global_object() });
+        GC::create_function(document->heap(), [document](ByteBuffer) { HTML::HTMLParser::the_end(document); }),
+        GC::create_function(document->heap(), [](JS::Value) {}),
+        GC::Ref { realm.global_object() });
 
     // 9. Return document.
     return document;
@@ -393,7 +393,7 @@ bool can_load_document_with_type(MimeSniff::MimeType const& type)
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#loading-a-document
-JS::GCPtr<DOM::Document> load_document(HTML::NavigationParams const& navigation_params)
+GC::Ptr<DOM::Document> load_document(HTML::NavigationParams const& navigation_params)
 {
     // To load a document given navigation params navigationParams, source snapshot params sourceSnapshotParams,
     // and origin initiatorOrigin, perform the following steps. They return a Document or null.
@@ -404,7 +404,7 @@ JS::GCPtr<DOM::Document> load_document(HTML::NavigationParams const& navigation_
         navigation_params.response->body()->source().visit(
             [](Empty) { return ReadonlyBytes {}; },
             [](ByteBuffer const& buffer) { return ReadonlyBytes { buffer }; },
-            [](JS::Handle<FileAPI::Blob> const& blob) { return blob->raw_bytes(); }),
+            [](GC::Root<FileAPI::Blob> const& blob) { return blob->raw_bytes(); }),
         MimeSniff::SniffingConfiguration {
             .sniffing_context = MimeSniff::SniffingContext::Browsing,
             .supplied_type = move(supplied_type) });
diff --git a/Libraries/LibWeb/DOM/DocumentLoading.h b/Libraries/LibWeb/DOM/DocumentLoading.h
index f8c5395250f..c09d5714c5e 100644
--- a/Libraries/LibWeb/DOM/DocumentLoading.h
+++ b/Libraries/LibWeb/DOM/DocumentLoading.h
@@ -13,12 +13,12 @@
 namespace Web {
 
 bool build_xml_document(DOM::Document& document, ByteBuffer const& data, Optional<String> content_encoding);
-JS::GCPtr<DOM::Document> load_document(HTML::NavigationParams const& navigation_params);
+GC::Ptr<DOM::Document> load_document(HTML::NavigationParams const& navigation_params);
 bool can_load_document_with_type(MimeSniff::MimeType const&);
 
 // https://html.spec.whatwg.org/multipage/document-lifecycle.html#read-ua-inline
 template<typename MutateDocument>
-JS::NonnullGCPtr<DOM::Document> create_document_for_inline_content(JS::GCPtr<HTML::Navigable> navigable, Optional<String> navigation_id, MutateDocument mutate_document)
+GC::Ref<DOM::Document> create_document_for_inline_content(GC::Ptr<HTML::Navigable> navigable, Optional<String> navigation_id, MutateDocument mutate_document)
 {
     auto& vm = navigable->vm();
 
diff --git a/Libraries/LibWeb/DOM/DocumentObserver.cpp b/Libraries/LibWeb/DOM/DocumentObserver.cpp
index ae2ee3aa3ce..76b4c018284 100644
--- a/Libraries/LibWeb/DOM/DocumentObserver.cpp
+++ b/Libraries/LibWeb/DOM/DocumentObserver.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DocumentObserver);
+GC_DEFINE_ALLOCATOR(DocumentObserver);
 
 DocumentObserver::DocumentObserver(JS::Realm& realm, DOM::Document& document)
     : Bindings::PlatformObject(realm)
@@ -39,7 +39,7 @@ void DocumentObserver::finalize()
 void DocumentObserver::set_document_became_inactive(Function<void()> callback)
 {
     if (callback)
-        m_document_became_inactive = JS::create_heap_function(vm().heap(), move(callback));
+        m_document_became_inactive = GC::create_function(vm().heap(), move(callback));
     else
         m_document_became_inactive = nullptr;
 }
@@ -47,7 +47,7 @@ void DocumentObserver::set_document_became_inactive(Function<void()> callback)
 void DocumentObserver::set_document_completely_loaded(Function<void()> callback)
 {
     if (callback)
-        m_document_completely_loaded = JS::create_heap_function(vm().heap(), move(callback));
+        m_document_completely_loaded = GC::create_function(vm().heap(), move(callback));
     else
         m_document_completely_loaded = nullptr;
 }
@@ -55,7 +55,7 @@ void DocumentObserver::set_document_completely_loaded(Function<void()> callback)
 void DocumentObserver::set_document_readiness_observer(Function<void(HTML::DocumentReadyState)> callback)
 {
     if (callback)
-        m_document_readiness_observer = JS::create_heap_function(vm().heap(), move(callback));
+        m_document_readiness_observer = GC::create_function(vm().heap(), move(callback));
     else
         m_document_readiness_observer = nullptr;
 }
@@ -63,7 +63,7 @@ void DocumentObserver::set_document_readiness_observer(Function<void(HTML::Docum
 void DocumentObserver::set_document_visibility_state_observer(Function<void(HTML::VisibilityState)> callback)
 {
     if (callback)
-        m_document_visibility_state_observer = JS::create_heap_function(vm().heap(), move(callback));
+        m_document_visibility_state_observer = GC::create_function(vm().heap(), move(callback));
     else
         m_document_visibility_state_observer = nullptr;
 }
@@ -71,7 +71,7 @@ void DocumentObserver::set_document_visibility_state_observer(Function<void(HTML
 void DocumentObserver::set_document_page_showing_observer(Function<void(bool)> callback)
 {
     if (callback)
-        m_document_page_showing_observer = JS::create_heap_function(vm().heap(), move(callback));
+        m_document_page_showing_observer = GC::create_function(vm().heap(), move(callback));
     else
         m_document_page_showing_observer = nullptr;
 }
diff --git a/Libraries/LibWeb/DOM/DocumentObserver.h b/Libraries/LibWeb/DOM/DocumentObserver.h
index ad4f0ba15e8..5318d0453af 100644
--- a/Libraries/LibWeb/DOM/DocumentObserver.h
+++ b/Libraries/LibWeb/DOM/DocumentObserver.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Function.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/DocumentReadyState.h>
@@ -17,22 +17,22 @@ namespace Web::DOM {
 
 class DocumentObserver final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DocumentObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DocumentObserver);
+    GC_DECLARE_ALLOCATOR(DocumentObserver);
 
 public:
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void()>> document_became_inactive() const { return m_document_became_inactive; }
+    [[nodiscard]] GC::Ptr<GC::Function<void()>> document_became_inactive() const { return m_document_became_inactive; }
     void set_document_became_inactive(Function<void()>);
 
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void()>> document_completely_loaded() const { return m_document_completely_loaded; }
+    [[nodiscard]] GC::Ptr<GC::Function<void()>> document_completely_loaded() const { return m_document_completely_loaded; }
     void set_document_completely_loaded(Function<void()>);
 
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void(HTML::DocumentReadyState)>> document_readiness_observer() const { return m_document_readiness_observer; }
+    [[nodiscard]] GC::Ptr<GC::Function<void(HTML::DocumentReadyState)>> document_readiness_observer() const { return m_document_readiness_observer; }
     void set_document_readiness_observer(Function<void(HTML::DocumentReadyState)>);
 
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void(HTML::VisibilityState)>> document_visibility_state_observer() const { return m_document_visibility_state_observer; }
+    [[nodiscard]] GC::Ptr<GC::Function<void(HTML::VisibilityState)>> document_visibility_state_observer() const { return m_document_visibility_state_observer; }
     void set_document_visibility_state_observer(Function<void(HTML::VisibilityState)>);
 
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void(bool)>> document_page_showing_observer() const { return m_document_page_showing_observer; }
+    [[nodiscard]] GC::Ptr<GC::Function<void(bool)>> document_page_showing_observer() const { return m_document_page_showing_observer; }
     void set_document_page_showing_observer(Function<void(bool)>);
 
 private:
@@ -41,12 +41,12 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
     virtual void finalize() override;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
-    JS::GCPtr<JS::HeapFunction<void()>> m_document_became_inactive;
-    JS::GCPtr<JS::HeapFunction<void()>> m_document_completely_loaded;
-    JS::GCPtr<JS::HeapFunction<void(HTML::DocumentReadyState)>> m_document_readiness_observer;
-    JS::GCPtr<JS::HeapFunction<void(HTML::VisibilityState)>> m_document_visibility_state_observer;
-    JS::GCPtr<JS::HeapFunction<void(bool)>> m_document_page_showing_observer;
+    GC::Ref<DOM::Document> m_document;
+    GC::Ptr<GC::Function<void()>> m_document_became_inactive;
+    GC::Ptr<GC::Function<void()>> m_document_completely_loaded;
+    GC::Ptr<GC::Function<void(HTML::DocumentReadyState)>> m_document_readiness_observer;
+    GC::Ptr<GC::Function<void(HTML::VisibilityState)>> m_document_visibility_state_observer;
+    GC::Ptr<GC::Function<void(bool)>> m_document_page_showing_observer;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/DocumentType.cpp b/Libraries/LibWeb/DOM/DocumentType.cpp
index f7ebc6466c5..8825d736a9a 100644
--- a/Libraries/LibWeb/DOM/DocumentType.cpp
+++ b/Libraries/LibWeb/DOM/DocumentType.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(DocumentType);
+GC_DEFINE_ALLOCATOR(DocumentType);
 
-JS::NonnullGCPtr<DocumentType> DocumentType::create(Document& document)
+GC::Ref<DocumentType> DocumentType::create(Document& document)
 {
     return document.realm().create<DocumentType>(document);
 }
diff --git a/Libraries/LibWeb/DOM/DocumentType.h b/Libraries/LibWeb/DOM/DocumentType.h
index 6434c5e365a..08067ce72b2 100644
--- a/Libraries/LibWeb/DOM/DocumentType.h
+++ b/Libraries/LibWeb/DOM/DocumentType.h
@@ -16,10 +16,10 @@ class DocumentType final
     : public Node
     , public ChildNode<DocumentType> {
     WEB_PLATFORM_OBJECT(DocumentType, Node);
-    JS_DECLARE_ALLOCATOR(DocumentType);
+    GC_DECLARE_ALLOCATOR(DocumentType);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DocumentType> create(Document&);
+    [[nodiscard]] static GC::Ref<DocumentType> create(Document&);
 
     virtual ~DocumentType() override = default;
 
diff --git a/Libraries/LibWeb/DOM/EditingHostManager.cpp b/Libraries/LibWeb/DOM/EditingHostManager.cpp
index 446c032fd66..f66486833b2 100644
--- a/Libraries/LibWeb/DOM/EditingHostManager.cpp
+++ b/Libraries/LibWeb/DOM/EditingHostManager.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(EditingHostManager);
+GC_DEFINE_ALLOCATOR(EditingHostManager);
 
-JS::NonnullGCPtr<EditingHostManager> EditingHostManager::create(JS::Realm& realm, JS::NonnullGCPtr<Document> document)
+GC::Ref<EditingHostManager> EditingHostManager::create(JS::Realm& realm, GC::Ref<Document> document)
 {
     return realm.create<EditingHostManager>(document);
 }
 
-EditingHostManager::EditingHostManager(JS::NonnullGCPtr<Document> document)
+EditingHostManager::EditingHostManager(GC::Ref<Document> document)
     : m_document(document)
 {
 }
@@ -79,14 +79,14 @@ void EditingHostManager::select_all()
     MUST(selection->set_base_and_extent(*selection->anchor_node(), 0, *selection->focus_node(), selection->focus_node()->length()));
 }
 
-void EditingHostManager::set_selection_anchor(JS::NonnullGCPtr<DOM::Node> anchor_node, size_t anchor_offset)
+void EditingHostManager::set_selection_anchor(GC::Ref<DOM::Node> anchor_node, size_t anchor_offset)
 {
     auto selection = m_document->get_selection();
     MUST(selection->collapse(*anchor_node, anchor_offset));
     m_document->reset_cursor_blink_cycle();
 }
 
-void EditingHostManager::set_selection_focus(JS::NonnullGCPtr<DOM::Node> focus_node, size_t focus_offset)
+void EditingHostManager::set_selection_focus(GC::Ref<DOM::Node> focus_node, size_t focus_offset)
 {
     if (!m_active_contenteditable_element || !m_active_contenteditable_element->is_ancestor_of(*focus_node))
         return;
diff --git a/Libraries/LibWeb/DOM/EditingHostManager.h b/Libraries/LibWeb/DOM/EditingHostManager.h
index c07bc709f6a..283aca0e825 100644
--- a/Libraries/LibWeb/DOM/EditingHostManager.h
+++ b/Libraries/LibWeb/DOM/EditingHostManager.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/DOM/InputEventsTarget.h>
 #include <LibWeb/Forward.h>
@@ -16,18 +16,18 @@ namespace Web::DOM {
 
 class EditingHostManager : public JS::Cell
     , public InputEventsTarget {
-    JS_CELL(EditingHostManager, JS::Cell);
-    JS_DECLARE_ALLOCATOR(EditingHostManager);
+    GC_CELL(EditingHostManager, JS::Cell);
+    GC_DECLARE_ALLOCATOR(EditingHostManager);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<EditingHostManager> create(JS::Realm&, JS::NonnullGCPtr<Document>);
+    [[nodiscard]] static GC::Ref<EditingHostManager> create(JS::Realm&, GC::Ref<Document>);
 
     virtual void handle_insert(String const&) override;
     virtual void handle_delete(DeleteDirection) override;
     virtual void handle_return_key() override;
     virtual void select_all() override;
-    virtual void set_selection_anchor(JS::NonnullGCPtr<DOM::Node>, size_t offset) override;
-    virtual void set_selection_focus(JS::NonnullGCPtr<DOM::Node>, size_t offset) override;
+    virtual void set_selection_anchor(GC::Ref<DOM::Node>, size_t offset) override;
+    virtual void set_selection_focus(GC::Ref<DOM::Node>, size_t offset) override;
     virtual void move_cursor_to_start(CollapseSelection) override;
     virtual void move_cursor_to_end(CollapseSelection) override;
     virtual void increment_cursor_position_offset(CollapseSelection) override;
@@ -37,16 +37,16 @@ public:
 
     virtual void visit_edges(Cell::Visitor& visitor) override;
 
-    void set_active_contenteditable_element(JS::GCPtr<DOM::Node> element)
+    void set_active_contenteditable_element(GC::Ptr<DOM::Node> element)
     {
         m_active_contenteditable_element = element;
     }
 
 private:
-    EditingHostManager(JS::NonnullGCPtr<Document>);
+    EditingHostManager(GC::Ref<Document>);
 
-    JS::NonnullGCPtr<Document> m_document;
-    JS::GCPtr<DOM::Node> m_active_contenteditable_element;
+    GC::Ref<Document> m_document;
+    GC::Ptr<DOM::Node> m_active_contenteditable_element;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/Element.cpp b/Libraries/LibWeb/DOM/Element.cpp
index d0a0ba7af1c..fea2ff0449f 100644
--- a/Libraries/LibWeb/DOM/Element.cpp
+++ b/Libraries/LibWeb/DOM/Element.cpp
@@ -155,14 +155,14 @@ String Element::get_attribute_value(FlyString const& local_name, Optional<FlyStr
 }
 
 // https://dom.spec.whatwg.org/#dom-element-getattributenode
-JS::GCPtr<Attr> Element::get_attribute_node(FlyString const& name) const
+GC::Ptr<Attr> Element::get_attribute_node(FlyString const& name) const
 {
     // The getAttributeNode(qualifiedName) method steps are to return the result of getting an attribute given qualifiedName and this.
     return m_attributes->get_attribute(name);
 }
 
 // https://dom.spec.whatwg.org/#dom-element-getattributenodens
-JS::GCPtr<Attr> Element::get_attribute_node_ns(Optional<FlyString> const& namespace_, FlyString const& name) const
+GC::Ptr<Attr> Element::get_attribute_node_ns(Optional<FlyString> const& namespace_, FlyString const& name) const
 {
     // The getAttributeNodeNS(namespace, localName) method steps are to return the result of getting an attribute given namespace, localName, and this.
     return m_attributes->get_attribute_ns(namespace_, name);
@@ -286,14 +286,14 @@ void Element::set_attribute_value(FlyString const& local_name, String const& val
 }
 
 // https://dom.spec.whatwg.org/#dom-element-setattributenode
-WebIDL::ExceptionOr<JS::GCPtr<Attr>> Element::set_attribute_node(Attr& attr)
+WebIDL::ExceptionOr<GC::Ptr<Attr>> Element::set_attribute_node(Attr& attr)
 {
     // The setAttributeNode(attr) and setAttributeNodeNS(attr) methods steps are to return the result of setting an attribute given attr and this.
     return m_attributes->set_attribute(attr);
 }
 
 // https://dom.spec.whatwg.org/#dom-element-setattributenodens
-WebIDL::ExceptionOr<JS::GCPtr<Attr>> Element::set_attribute_node_ns(Attr& attr)
+WebIDL::ExceptionOr<GC::Ptr<Attr>> Element::set_attribute_node_ns(Attr& attr)
 {
     // The setAttributeNode(attr) and setAttributeNodeNS(attr) methods steps are to return the result of setting an attribute given attr and this.
     return m_attributes->set_attribute(attr);
@@ -314,7 +314,7 @@ void Element::remove_attribute_ns(Optional<FlyString> const& namespace_, FlyStri
 }
 
 // https://dom.spec.whatwg.org/#dom-element-removeattributenode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> Element::remove_attribute_node(JS::NonnullGCPtr<Attr> attr)
+WebIDL::ExceptionOr<GC::Ref<Attr>> Element::remove_attribute_node(GC::Ref<Attr> attr)
 {
     return m_attributes->remove_attribute_node(attr);
 }
@@ -386,7 +386,7 @@ Vector<String> Element::get_attribute_names() const
     return names;
 }
 
-JS::GCPtr<Layout::Node> Element::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> Element::create_layout_node(CSS::StyleProperties style)
 {
     if (local_name() == "noscript" && document().is_scripting_enabled())
         return nullptr;
@@ -395,7 +395,7 @@ JS::GCPtr<Layout::Node> Element::create_layout_node(CSS::StyleProperties style)
     return create_layout_node_for_display_type(document(), display, move(style), this);
 }
 
-JS::GCPtr<Layout::NodeWithStyle> Element::create_layout_node_for_display_type(DOM::Document& document, CSS::Display const& display, CSS::StyleProperties style, Element* element)
+GC::Ptr<Layout::NodeWithStyle> Element::create_layout_node_for_display_type(DOM::Document& document, CSS::Display const& display, CSS::StyleProperties style, Element* element)
 {
     if (display.is_table_inside() || display.is_table_row_group() || display.is_table_header_group() || display.is_table_footer_group() || display.is_table_row())
         return document.heap().allocate<Layout::Box>(document, element, move(style));
@@ -666,17 +666,17 @@ WebIDL::ExceptionOr<void> Element::attach_a_shadow_root(Bindings::ShadowRootMode
 }
 
 // https://dom.spec.whatwg.org/#dom-element-attachshadow
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ShadowRoot>> Element::attach_shadow(ShadowRootInit init)
+WebIDL::ExceptionOr<GC::Ref<ShadowRoot>> Element::attach_shadow(ShadowRootInit init)
 {
     // 1. Run attach a shadow root with this, init["mode"], init["clonable"], init["serializable"], init["delegatesFocus"], and init["slotAssignment"].
     TRY(attach_a_shadow_root(init.mode, init.clonable, init.serializable, init.delegates_focus, init.slot_assignment));
 
     // 2. Return this’s shadow root.
-    return JS::NonnullGCPtr { *shadow_root() };
+    return GC::Ref { *shadow_root() };
 }
 
 // https://dom.spec.whatwg.org/#dom-element-shadowroot
-JS::GCPtr<ShadowRoot> Element::shadow_root_for_bindings() const
+GC::Ptr<ShadowRoot> Element::shadow_root_for_bindings() const
 {
     // 1. Let shadow be this’s shadow root.
     auto shadow = m_shadow_root;
@@ -807,7 +807,7 @@ bool Element::is_shadow_host() const
     return m_shadow_root != nullptr;
 }
 
-void Element::set_shadow_root(JS::GCPtr<ShadowRoot> shadow_root)
+void Element::set_shadow_root(GC::Ptr<ShadowRoot> shadow_root)
 {
     if (m_shadow_root == shadow_root)
         return;
@@ -839,7 +839,7 @@ void Element::make_html_uppercased_qualified_name()
 // https://html.spec.whatwg.org/multipage/webappapis.html#queue-an-element-task
 HTML::TaskID Element::queue_an_element_task(HTML::Task::Source source, Function<void()> steps)
 {
-    return queue_a_task(source, HTML::main_thread_event_loop(), document(), JS::create_heap_function(heap(), move(steps)));
+    return queue_a_task(source, HTML::main_thread_event_loop(), document(), GC::create_function(heap(), move(steps)));
 }
 
 // https://html.spec.whatwg.org/multipage/syntax.html#void-elements
@@ -855,7 +855,7 @@ bool Element::serializes_as_void() const
 }
 
 // https://drafts.csswg.org/cssom-view/#dom-element-getboundingclientrect
-JS::NonnullGCPtr<Geometry::DOMRect> Element::get_bounding_client_rect() const
+GC::Ref<Geometry::DOMRect> Element::get_bounding_client_rect() const
 {
     // 1. Let list be the result of invoking getClientRects() on element.
     auto list = get_client_rects();
@@ -874,7 +874,7 @@ JS::NonnullGCPtr<Geometry::DOMRect> Element::get_bounding_client_rect() const
         }
     }
     if (all_rectangle_has_zero_width_or_height)
-        return JS::NonnullGCPtr { *const_cast<Geometry::DOMRect*>(list->item(0)) };
+        return GC::Ref { *const_cast<Geometry::DOMRect*>(list->item(0)) };
 
     // 4. Otherwise, return a DOMRect object describing the smallest rectangle that includes all of the rectangles in
     //    list of which the height or width is not zero.
@@ -890,7 +890,7 @@ JS::NonnullGCPtr<Geometry::DOMRect> Element::get_bounding_client_rect() const
 }
 
 // https://drafts.csswg.org/cssom-view/#dom-element-getclientrects
-JS::NonnullGCPtr<Geometry::DOMRectList> Element::get_client_rects() const
+GC::Ref<Geometry::DOMRectList> Element::get_client_rects() const
 {
     auto navigable = document().navigable();
     if (!navigable)
@@ -923,7 +923,7 @@ JS::NonnullGCPtr<Geometry::DOMRectList> Element::get_client_rects() const
     CSSPixelPoint scroll_offset;
     auto const* paintable = this->paintable();
 
-    Vector<JS::Handle<Geometry::DOMRect>> rects;
+    Vector<GC::Root<Geometry::DOMRect>> rects;
     if (auto const* paintable_box = this->paintable_box()) {
         transform = Gfx::extract_2d_affine_transform(paintable_box->transform());
         for (auto const* containing_block = paintable->containing_block(); !containing_block->is_viewport(); containing_block = containing_block->containing_block()) {
@@ -1063,7 +1063,7 @@ void Element::children_changed()
     set_needs_style_update(true);
 }
 
-void Element::set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement::Type pseudo_element, JS::GCPtr<Layout::NodeWithStyle> pseudo_element_node)
+void Element::set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement::Type pseudo_element, GC::Ptr<Layout::NodeWithStyle> pseudo_element_node)
 {
     auto existing_pseudo_element = get_pseudo_element(pseudo_element);
     if (!existing_pseudo_element.has_value() && !pseudo_element_node)
@@ -1072,7 +1072,7 @@ void Element::set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector:
     ensure_pseudo_element(pseudo_element).layout_node = move(pseudo_element_node);
 }
 
-JS::GCPtr<Layout::NodeWithStyle> Element::get_pseudo_element_node(CSS::Selector::PseudoElement::Type pseudo_element) const
+GC::Ptr<Layout::NodeWithStyle> Element::get_pseudo_element_node(CSS::Selector::PseudoElement::Type pseudo_element) const
 {
     if (auto element_data = get_pseudo_element(pseudo_element); element_data.has_value())
         return element_data->layout_node;
@@ -1473,7 +1473,7 @@ bool Element::is_actually_disabled() const
 }
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#fragment-parsing-algorithm-steps
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::DocumentFragment>> Element::parse_fragment(StringView markup)
+WebIDL::ExceptionOr<GC::Ref<DOM::DocumentFragment>> Element::parse_fragment(StringView markup)
 {
     // 1. Let algorithm be the HTML fragment parsing algorithm.
     auto algorithm = HTML::HTMLParser::parse_html_fragment;
@@ -1537,7 +1537,7 @@ WebIDL::ExceptionOr<void> Element::set_outer_html(String const& value)
 WebIDL::ExceptionOr<void> Element::insert_adjacent_html(String const& position, String const& string)
 {
     // 1. Let context be null.
-    JS::GCPtr<Node> context;
+    GC::Ptr<Node> context;
 
     // 2. Use the first matching item from this list:
     // - If position is an ASCII case-insensitive match for the string "beforebegin"
@@ -1607,39 +1607,39 @@ WebIDL::ExceptionOr<void> Element::insert_adjacent_html(String const& position,
 }
 
 // https://dom.spec.whatwg.org/#insert-adjacent
-WebIDL::ExceptionOr<JS::GCPtr<Node>> Element::insert_adjacent(StringView where, JS::NonnullGCPtr<Node> node)
+WebIDL::ExceptionOr<GC::Ptr<Node>> Element::insert_adjacent(StringView where, GC::Ref<Node> node)
 {
     // To insert adjacent, given an element element, string where, and a node node, run the steps associated with the first ASCII case-insensitive match for where:
     if (Infra::is_ascii_case_insensitive_match(where, "beforebegin"sv)) {
         // -> "beforebegin"
         // If element’s parent is null, return null.
         if (!parent())
-            return JS::GCPtr<Node> { nullptr };
+            return GC::Ptr<Node> { nullptr };
 
         // Return the result of pre-inserting node into element’s parent before element.
-        return JS::GCPtr<Node> { TRY(parent()->pre_insert(move(node), this)) };
+        return GC::Ptr<Node> { TRY(parent()->pre_insert(move(node), this)) };
     }
 
     if (Infra::is_ascii_case_insensitive_match(where, "afterbegin"sv)) {
         // -> "afterbegin"
         // Return the result of pre-inserting node into element before element’s first child.
-        return JS::GCPtr<Node> { TRY(pre_insert(move(node), first_child())) };
+        return GC::Ptr<Node> { TRY(pre_insert(move(node), first_child())) };
     }
 
     if (Infra::is_ascii_case_insensitive_match(where, "beforeend"sv)) {
         // -> "beforeend"
         // Return the result of pre-inserting node into element before null.
-        return JS::GCPtr<Node> { TRY(pre_insert(move(node), nullptr)) };
+        return GC::Ptr<Node> { TRY(pre_insert(move(node), nullptr)) };
     }
 
     if (Infra::is_ascii_case_insensitive_match(where, "afterend"sv)) {
         // -> "afterend"
         // If element’s parent is null, return null.
         if (!parent())
-            return JS::GCPtr<Node> { nullptr };
+            return GC::Ptr<Node> { nullptr };
 
         // Return the result of pre-inserting node into element’s parent before element’s next sibling.
-        return JS::GCPtr<Node> { TRY(parent()->pre_insert(move(node), next_sibling())) };
+        return GC::Ptr<Node> { TRY(parent()->pre_insert(move(node), next_sibling())) };
     }
 
     // -> Otherwise
@@ -1648,13 +1648,13 @@ WebIDL::ExceptionOr<JS::GCPtr<Node>> Element::insert_adjacent(StringView where,
 }
 
 // https://dom.spec.whatwg.org/#dom-element-insertadjacentelement
-WebIDL::ExceptionOr<JS::GCPtr<Element>> Element::insert_adjacent_element(String const& where, JS::NonnullGCPtr<Element> element)
+WebIDL::ExceptionOr<GC::Ptr<Element>> Element::insert_adjacent_element(String const& where, GC::Ref<Element> element)
 {
     // The insertAdjacentElement(where, element) method steps are to return the result of running insert adjacent, give this, where, and element.
     auto returned_node = TRY(insert_adjacent(where, element));
     if (!returned_node)
-        return JS::GCPtr<Element> { nullptr };
-    return JS::GCPtr<Element> { verify_cast<Element>(*returned_node) };
+        return GC::Ptr<Element> { nullptr };
+    return GC::Ptr<Element> { verify_cast<Element>(*returned_node) };
 }
 
 // https://dom.spec.whatwg.org/#dom-element-insertadjacenttext
@@ -1954,8 +1954,8 @@ void Element::enqueue_an_element_on_the_appropriate_element_queue()
         reactions_stack.processing_the_backup_element_queue = true;
 
         // 4. Queue a microtask to perform the following steps:
-        // NOTE: `this` is protected by JS::HeapFunction
-        HTML::queue_a_microtask(&document(), JS::create_heap_function(relevant_agent.heap(), [this]() {
+        // NOTE: `this` is protected by GC::Function
+        HTML::queue_a_microtask(&document(), GC::create_function(relevant_agent.heap(), [this]() {
             auto& relevant_agent = HTML::relevant_agent(*this);
             auto* custom_data = verify_cast<Bindings::WebEngineCustomData>(relevant_agent.custom_data());
             auto& reactions_stack = custom_data->custom_element_reactions_stack;
@@ -1984,7 +1984,7 @@ void Element::enqueue_a_custom_element_upgrade_reaction(HTML::CustomElementDefin
     enqueue_an_element_on_the_appropriate_element_queue();
 }
 
-void Element::enqueue_a_custom_element_callback_reaction(FlyString const& callback_name, JS::MarkedVector<JS::Value> arguments)
+void Element::enqueue_a_custom_element_callback_reaction(FlyString const& callback_name, GC::MarkedVector<JS::Value> arguments)
 {
     // 1. Let definition be element's custom element definition.
     auto& definition = m_custom_element_definition;
@@ -2020,7 +2020,7 @@ void Element::enqueue_a_custom_element_callback_reaction(FlyString const& callba
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#concept-upgrade-an-element
-JS::ThrowCompletionOr<void> Element::upgrade_element(JS::NonnullGCPtr<HTML::CustomElementDefinition> custom_element_definition)
+JS::ThrowCompletionOr<void> Element::upgrade_element(GC::Ref<HTML::CustomElementDefinition> custom_element_definition)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -2041,7 +2041,7 @@ JS::ThrowCompletionOr<void> Element::upgrade_element(JS::NonnullGCPtr<HTML::Cust
         auto const* attribute = m_attributes->item(attribute_index);
         VERIFY(attribute);
 
-        JS::MarkedVector<JS::Value> arguments { vm.heap() };
+        GC::MarkedVector<JS::Value> arguments { vm.heap() };
 
         arguments.append(JS::PrimitiveString::create(vm, attribute->local_name()));
         arguments.append(JS::js_null());
@@ -2053,12 +2053,12 @@ JS::ThrowCompletionOr<void> Element::upgrade_element(JS::NonnullGCPtr<HTML::Cust
 
     // 5. If element is connected, then enqueue a custom element callback reaction with element, callback name "connectedCallback", and an empty argument list.
     if (is_connected()) {
-        JS::MarkedVector<JS::Value> empty_arguments { vm.heap() };
+        GC::MarkedVector<JS::Value> empty_arguments { vm.heap() };
         enqueue_a_custom_element_callback_reaction(HTML::CustomElementReactionNames::connectedCallback, move(empty_arguments));
     }
 
     // 6. Add element to the end of definition's construction stack.
-    custom_element_definition->construction_stack().append(JS::make_handle(this));
+    custom_element_definition->construction_stack().append(GC::make_root(this));
 
     // 7. Let C be definition's constructor.
     auto& constructor = custom_element_definition->constructor();
@@ -2201,12 +2201,12 @@ void Element::for_each_attribute(Function<void(FlyString const&, String const&)>
     });
 }
 
-JS::GCPtr<Layout::NodeWithStyle> Element::layout_node()
+GC::Ptr<Layout::NodeWithStyle> Element::layout_node()
 {
     return static_cast<Layout::NodeWithStyle*>(Node::layout_node());
 }
 
-JS::GCPtr<Layout::NodeWithStyle const> Element::layout_node() const
+GC::Ptr<Layout::NodeWithStyle const> Element::layout_node() const
 {
     return static_cast<Layout::NodeWithStyle const*>(Node::layout_node());
 }
@@ -2442,7 +2442,7 @@ void Element::register_intersection_observer(Badge<IntersectionObserver::Interse
     m_registered_intersection_observers->append(move(registration));
 }
 
-void Element::unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver> observer)
+void Element::unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, GC::Ref<IntersectionObserver::IntersectionObserver> observer)
 {
     if (!m_registered_intersection_observers)
         return;
@@ -2697,7 +2697,7 @@ void Element::attribute_changed(FlyString const& local_name, Optional<String> co
             assign_slottables(*assigned_slot);
 
         // 7. Run assign a slot for element.
-        assign_a_slot(JS::NonnullGCPtr { *this });
+        assign_a_slot(GC::Ref { *this });
         return;
     }
 
diff --git a/Libraries/LibWeb/DOM/Element.h b/Libraries/LibWeb/DOM/Element.h
index 33e7e0dcd6a..94caa57ef42 100644
--- a/Libraries/LibWeb/DOM/Element.h
+++ b/Libraries/LibWeb/DOM/Element.h
@@ -42,7 +42,7 @@ struct ShadowRootInit {
 
 struct GetHTMLOptions {
     bool serializable_shadow_roots { false };
-    Vector<JS::Handle<ShadowRoot>> shadow_roots {};
+    Vector<GC::Root<ShadowRoot>> shadow_roots {};
 };
 
 // https://w3c.github.io/csswg-drafts/cssom-view-1/#dictdef-scrollintoviewoptions
@@ -63,14 +63,14 @@ struct CheckVisibilityOptions {
 // https://html.spec.whatwg.org/multipage/custom-elements.html#upgrade-reaction
 // An upgrade reaction, which will upgrade the custom element and contains a custom element definition; or
 struct CustomElementUpgradeReaction {
-    JS::Handle<HTML::CustomElementDefinition> custom_element_definition;
+    GC::Root<HTML::CustomElementDefinition> custom_element_definition;
 };
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#callback-reaction
 // A callback reaction, which will call a lifecycle callback, and contains a callback function as well as a list of arguments.
 struct CustomElementCallbackReaction {
-    JS::Handle<WebIDL::CallbackType> callback;
-    JS::MarkedVector<JS::Value> arguments;
+    GC::Root<WebIDL::CallbackType> callback;
+    GC::MarkedVector<JS::Value> arguments;
 };
 
 // https://dom.spec.whatwg.org/#concept-element-custom-element-state
@@ -129,28 +129,28 @@ public:
 
     WebIDL::ExceptionOr<void> set_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& qualified_name, String const& value);
     void set_attribute_value(FlyString const& local_name, String const& value, Optional<FlyString> const& prefix = {}, Optional<FlyString> const& namespace_ = {});
-    WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_attribute_node(Attr&);
-    WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_attribute_node_ns(Attr&);
+    WebIDL::ExceptionOr<GC::Ptr<Attr>> set_attribute_node(Attr&);
+    WebIDL::ExceptionOr<GC::Ptr<Attr>> set_attribute_node_ns(Attr&);
 
     void append_attribute(FlyString const& name, String const& value);
     void append_attribute(Attr&);
     void remove_attribute(FlyString const& name);
     void remove_attribute_ns(Optional<FlyString> const& namespace_, FlyString const& name);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> remove_attribute_node(JS::NonnullGCPtr<Attr>);
+    WebIDL::ExceptionOr<GC::Ref<Attr>> remove_attribute_node(GC::Ref<Attr>);
 
     WebIDL::ExceptionOr<bool> toggle_attribute(FlyString const& name, Optional<bool> force);
     size_t attribute_list_size() const;
     NamedNodeMap const* attributes() const { return m_attributes.ptr(); }
     Vector<String> get_attribute_names() const;
 
-    JS::GCPtr<Attr> get_attribute_node(FlyString const& name) const;
-    JS::GCPtr<Attr> get_attribute_node_ns(Optional<FlyString> const& namespace_, FlyString const& name) const;
+    GC::Ptr<Attr> get_attribute_node(FlyString const& name) const;
+    GC::Ptr<Attr> get_attribute_node_ns(Optional<FlyString> const& namespace_, FlyString const& name) const;
 
     DOMTokenList* class_list();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<ShadowRoot>> attach_shadow(ShadowRootInit init);
+    WebIDL::ExceptionOr<GC::Ref<ShadowRoot>> attach_shadow(ShadowRootInit init);
     WebIDL::ExceptionOr<void> attach_a_shadow_root(Bindings::ShadowRootMode mode, bool clonable, bool serializable, bool delegates_focus, Bindings::SlotAssignmentMode slot_assignment);
-    JS::GCPtr<ShadowRoot> shadow_root_for_bindings() const;
+    GC::Ptr<ShadowRoot> shadow_root_for_bindings() const;
 
     WebIDL::ExceptionOr<bool> matches(StringView selectors) const;
     WebIDL::ExceptionOr<DOM::Element const*> closest(StringView selectors) const;
@@ -180,8 +180,8 @@ public:
     Optional<CSS::Selector::PseudoElement::Type> use_pseudo_element() const { return m_use_pseudo_element; }
     void set_use_pseudo_element(Optional<CSS::Selector::PseudoElement::Type> use_pseudo_element) { m_use_pseudo_element = move(use_pseudo_element); }
 
-    JS::GCPtr<Layout::NodeWithStyle> layout_node();
-    JS::GCPtr<Layout::NodeWithStyle const> layout_node() const;
+    GC::Ptr<Layout::NodeWithStyle> layout_node();
+    GC::Ptr<Layout::NodeWithStyle const> layout_node() const;
 
     Optional<CSS::StyleProperties>& computed_css_values() { return m_computed_css_values; }
     Optional<CSS::StyleProperties> const& computed_css_values() const { return m_computed_css_values; }
@@ -193,13 +193,13 @@ public:
 
     void reset_animated_css_properties();
 
-    JS::GCPtr<CSS::ElementInlineCSSStyleDeclaration const> inline_style() const { return m_inline_style; }
+    GC::Ptr<CSS::ElementInlineCSSStyleDeclaration const> inline_style() const { return m_inline_style; }
 
     CSS::CSSStyleDeclaration* style_for_bindings();
 
     CSS::StyleSheetList& document_or_shadow_root_style_sheets();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOM::DocumentFragment>> parse_fragment(StringView markup);
+    WebIDL::ExceptionOr<GC::Ref<DOM::DocumentFragment>> parse_fragment(StringView markup);
 
     WebIDL::ExceptionOr<String> inner_html() const;
     WebIDL::ExceptionOr<void> set_inner_html(StringView);
@@ -219,32 +219,32 @@ public:
     bool is_document_element() const;
 
     bool is_shadow_host() const;
-    JS::GCPtr<ShadowRoot> shadow_root() { return m_shadow_root; }
-    JS::GCPtr<ShadowRoot const> shadow_root() const { return m_shadow_root; }
-    void set_shadow_root(JS::GCPtr<ShadowRoot>);
+    GC::Ptr<ShadowRoot> shadow_root() { return m_shadow_root; }
+    GC::Ptr<ShadowRoot const> shadow_root() const { return m_shadow_root; }
+    void set_shadow_root(GC::Ptr<ShadowRoot>);
 
     void set_custom_properties(Optional<CSS::Selector::PseudoElement::Type>, HashMap<FlyString, CSS::StyleProperty> custom_properties);
     [[nodiscard]] HashMap<FlyString, CSS::StyleProperty> const& custom_properties(Optional<CSS::Selector::PseudoElement::Type>) const;
 
-    // NOTE: The function is wrapped in a JS::HeapFunction immediately.
+    // NOTE: The function is wrapped in a GC::HeapFunction immediately.
     HTML::TaskID queue_an_element_task(HTML::Task::Source, Function<void()>);
 
     bool is_void_element() const;
     bool serializes_as_void() const;
 
-    JS::NonnullGCPtr<Geometry::DOMRect> get_bounding_client_rect() const;
-    JS::NonnullGCPtr<Geometry::DOMRectList> get_client_rects() const;
+    GC::Ref<Geometry::DOMRect> get_bounding_client_rect() const;
+    GC::Ref<Geometry::DOMRectList> get_client_rects() const;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties);
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties);
     virtual void adjust_computed_style(CSS::StyleProperties&) { }
 
     virtual void did_receive_focus() { }
     virtual void did_lose_focus() { }
 
-    static JS::GCPtr<Layout::NodeWithStyle> create_layout_node_for_display_type(DOM::Document&, CSS::Display const&, CSS::StyleProperties, Element*);
+    static GC::Ptr<Layout::NodeWithStyle> create_layout_node_for_display_type(DOM::Document&, CSS::Display const&, CSS::StyleProperties, Element*);
 
-    void set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement::Type, JS::GCPtr<Layout::NodeWithStyle>);
-    JS::GCPtr<Layout::NodeWithStyle> get_pseudo_element_node(CSS::Selector::PseudoElement::Type) const;
+    void set_pseudo_element_node(Badge<Layout::TreeBuilder>, CSS::Selector::PseudoElement::Type, GC::Ptr<Layout::NodeWithStyle>);
+    GC::Ptr<Layout::NodeWithStyle> get_pseudo_element_node(CSS::Selector::PseudoElement::Type) const;
     bool has_pseudo_elements() const;
     void clear_pseudo_element_nodes(Badge<Layout::TreeBuilder>);
     void serialize_pseudo_elements_as_json(JsonArraySerializer<StringBuilder>& children_array) const;
@@ -264,7 +264,7 @@ public:
 
     bool is_actually_disabled() const;
 
-    WebIDL::ExceptionOr<JS::GCPtr<Element>> insert_adjacent_element(String const& where, JS::NonnullGCPtr<Element> element);
+    WebIDL::ExceptionOr<GC::Ptr<Element>> insert_adjacent_element(String const& where, GC::Ref<Element> element);
     WebIDL::ExceptionOr<void> insert_adjacent_text(String const& where, String const& data);
 
     // https://w3c.github.io/csswg-drafts/cssom-view-1/#dom-element-scrollintoview
@@ -349,14 +349,14 @@ public:
     virtual bool include_in_accessibility_tree() const override;
 
     void enqueue_a_custom_element_upgrade_reaction(HTML::CustomElementDefinition& custom_element_definition);
-    void enqueue_a_custom_element_callback_reaction(FlyString const& callback_name, JS::MarkedVector<JS::Value> arguments);
+    void enqueue_a_custom_element_callback_reaction(FlyString const& callback_name, GC::MarkedVector<JS::Value> arguments);
 
     using CustomElementReactionQueue = Vector<Variant<CustomElementUpgradeReaction, CustomElementCallbackReaction>>;
     CustomElementReactionQueue* custom_element_reaction_queue() { return m_custom_element_reaction_queue; }
     CustomElementReactionQueue const* custom_element_reaction_queue() const { return m_custom_element_reaction_queue; }
     CustomElementReactionQueue& ensure_custom_element_reaction_queue();
 
-    JS::ThrowCompletionOr<void> upgrade_element(JS::NonnullGCPtr<HTML::CustomElementDefinition> custom_element_definition);
+    JS::ThrowCompletionOr<void> upgrade_element(GC::Ref<HTML::CustomElementDefinition> custom_element_definition);
     void try_to_upgrade();
 
     bool is_defined() const;
@@ -376,7 +376,7 @@ public:
     bool check_visibility(Optional<CheckVisibilityOptions>);
 
     void register_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, IntersectionObserver::IntersectionObserverRegistration);
-    void unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, JS::NonnullGCPtr<IntersectionObserver::IntersectionObserver>);
+    void unregister_intersection_observer(Badge<IntersectionObserver::IntersectionObserver>, GC::Ref<IntersectionObserver::IntersectionObserver>);
     IntersectionObserver::IntersectionObserverRegistration& get_intersection_observer_registration(Badge<DOM::Document>, IntersectionObserver::IntersectionObserver const&);
 
     enum class ScrollOffsetFor {
@@ -403,7 +403,7 @@ public:
     Optional<FlyString> const& id() const { return m_id; }
     Optional<FlyString> const& name() const { return m_name; }
 
-    virtual JS::GCPtr<JS::HeapFunction<void()>> take_lazy_load_resumption_steps(Badge<DOM::Document>)
+    virtual GC::Ptr<GC::Function<void()>> take_lazy_load_resumption_steps(Badge<DOM::Document>)
     {
         return nullptr;
     }
@@ -442,7 +442,7 @@ private:
 
     void invalidate_style_after_attribute_change(FlyString const& attribute_name);
 
-    WebIDL::ExceptionOr<JS::GCPtr<Node>> insert_adjacent(StringView where, JS::NonnullGCPtr<Node> node);
+    WebIDL::ExceptionOr<GC::Ptr<Node>> insert_adjacent(StringView where, GC::Ref<Node> node);
 
     void enqueue_an_element_on_the_appropriate_element_queue();
 
@@ -454,16 +454,16 @@ private:
     QualifiedName m_qualified_name;
     FlyString m_html_uppercased_qualified_name;
 
-    JS::GCPtr<NamedNodeMap> m_attributes;
-    JS::GCPtr<CSS::ElementInlineCSSStyleDeclaration> m_inline_style;
-    JS::GCPtr<DOMTokenList> m_class_list;
-    JS::GCPtr<ShadowRoot> m_shadow_root;
+    GC::Ptr<NamedNodeMap> m_attributes;
+    GC::Ptr<CSS::ElementInlineCSSStyleDeclaration> m_inline_style;
+    GC::Ptr<DOMTokenList> m_class_list;
+    GC::Ptr<ShadowRoot> m_shadow_root;
 
     Optional<CSS::StyleProperties> m_computed_css_values;
     HashMap<FlyString, CSS::StyleProperty> m_custom_properties;
 
     struct PseudoElement {
-        JS::GCPtr<Layout::NodeWithStyle> layout_node;
+        GC::Ptr<Layout::NodeWithStyle> layout_node;
         Optional<CSS::StyleProperties> computed_css_values;
         HashMap<FlyString, CSS::StyleProperty> custom_properties;
     };
@@ -491,7 +491,7 @@ private:
     CustomElementState m_custom_element_state { CustomElementState::Undefined };
 
     // https://dom.spec.whatwg.org/#concept-element-custom-element-definition
-    JS::GCPtr<HTML::CustomElementDefinition> m_custom_element_definition;
+    GC::Ptr<HTML::CustomElementDefinition> m_custom_element_definition;
 
     // https://dom.spec.whatwg.org/#concept-element-is-value
     Optional<String> m_is_value;
diff --git a/Libraries/LibWeb/DOM/ElementFactory.cpp b/Libraries/LibWeb/DOM/ElementFactory.cpp
index c7fb3798a23..db448f828e0 100644
--- a/Libraries/LibWeb/DOM/ElementFactory.cpp
+++ b/Libraries/LibWeb/DOM/ElementFactory.cpp
@@ -276,7 +276,7 @@ bool is_unknown_html_element(FlyString const& tag_name)
 }
 
 // https://html.spec.whatwg.org/#elements-in-the-dom:element-interface
-static JS::NonnullGCPtr<Element> create_html_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
+static GC::Ref<Element> create_html_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
 {
     FlyString tag_name = qualified_name.local_name();
 
@@ -430,7 +430,7 @@ static JS::NonnullGCPtr<Element> create_html_element(JS::Realm& realm, Document&
     return realm.create<HTML::HTMLUnknownElement>(document, move(qualified_name));
 }
 
-static JS::NonnullGCPtr<SVG::SVGElement> create_svg_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
+static GC::Ref<SVG::SVGElement> create_svg_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
 {
     auto const& local_name = qualified_name.local_name();
 
@@ -498,7 +498,7 @@ static JS::NonnullGCPtr<SVG::SVGElement> create_svg_element(JS::Realm& realm, Do
     return realm.create<SVG::SVGElement>(document, move(qualified_name));
 }
 
-static JS::NonnullGCPtr<MathML::MathMLElement> create_mathml_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
+static GC::Ref<MathML::MathMLElement> create_mathml_element(JS::Realm& realm, Document& document, QualifiedName qualified_name)
 {
     // https://w3c.github.io/mathml-core/#dom-and-javascript
     // All the nodes representing MathML elements in the DOM must implement, and expose to scripts,
@@ -510,7 +510,7 @@ static JS::NonnullGCPtr<MathML::MathMLElement> create_mathml_element(JS::Realm&
     return realm.create<MathML::MathMLElement>(document, move(qualified_name));
 }
 // https://dom.spec.whatwg.org/#concept-create-element
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(Document& document, FlyString local_name, Optional<FlyString> namespace_, Optional<FlyString> prefix, Optional<String> is_value, bool synchronous_custom_elements_flag)
+WebIDL::ExceptionOr<GC::Ref<Element>> create_element(Document& document, FlyString local_name, Optional<FlyString> namespace_, Optional<FlyString> prefix, Optional<String> is_value, bool synchronous_custom_elements_flag)
 {
     auto& realm = document.realm();
 
@@ -561,7 +561,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(Document& document
     if (definition) {
         // 1. If the synchronous custom elements flag is set, then run these steps while catching any exceptions:
         if (synchronous_custom_elements_flag) {
-            auto synchronously_upgrade_custom_element = [&]() -> JS::ThrowCompletionOr<JS::NonnullGCPtr<HTML::HTMLElement>> {
+            auto synchronously_upgrade_custom_element = [&]() -> JS::ThrowCompletionOr<GC::Ref<HTML::HTMLElement>> {
                 auto& vm = document.vm();
 
                 // 1. Let C be definition’s constructor.
@@ -578,7 +578,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(Document& document
                 if (!result.has_value() || !result->is_object() || !is<HTML::HTMLElement>(result->as_object()))
                     return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "HTMLElement"sv);
 
-                JS::NonnullGCPtr<HTML::HTMLElement> element = verify_cast<HTML::HTMLElement>(result->as_object());
+                GC::Ref<HTML::HTMLElement> element = verify_cast<HTML::HTMLElement>(result->as_object());
 
                 // 5. If result’s attribute list is not empty, then throw a "NotSupportedError" DOMException.
                 if (element->has_attributes())
@@ -617,7 +617,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(Document& document
 
                 // 2. Set result to a new element that implements the HTMLUnknownElement interface, with no attributes, namespace set to the HTML namespace, namespace prefix set to prefix,
                 //    local name set to localName, custom element state set to "failed", custom element definition set to null, is value set to null, and node document set to document.
-                JS::NonnullGCPtr<Element> element = realm.create<HTML::HTMLUnknownElement>(document, QualifiedName { local_name, prefix, Namespace::HTML });
+                GC::Ref<Element> element = realm.create<HTML::HTMLUnknownElement>(document, QualifiedName { local_name, prefix, Namespace::HTML });
                 element->set_custom_element_state(CustomElementState::Failed);
                 return element;
             }
diff --git a/Libraries/LibWeb/DOM/ElementFactory.h b/Libraries/LibWeb/DOM/ElementFactory.h
index 7511b7cbf5c..a615caba95b 100644
--- a/Libraries/LibWeb/DOM/ElementFactory.h
+++ b/Libraries/LibWeb/DOM/ElementFactory.h
@@ -15,6 +15,6 @@ ErrorOr<FixedArray<FlyString>> valid_local_names_for_given_html_element_interfac
 bool is_unknown_html_element(FlyString const& tag_name);
 
 // FIXME: The spec doesn't say what the default value of synchronous_custom_elements_flag should be.
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Element>> create_element(Document&, FlyString local_name, Optional<FlyString> namespace_, Optional<FlyString> prefix = {}, Optional<String> is = Optional<String> {}, bool synchronous_custom_elements_flag = false);
+WebIDL::ExceptionOr<GC::Ref<Element>> create_element(Document&, FlyString local_name, Optional<FlyString> namespace_, Optional<FlyString> prefix = {}, Optional<String> is = Optional<String> {}, bool synchronous_custom_elements_flag = false);
 
 }
diff --git a/Libraries/LibWeb/DOM/Event.cpp b/Libraries/LibWeb/DOM/Event.cpp
index b34b4bcc60a..27767e17d1b 100644
--- a/Libraries/LibWeb/DOM/Event.cpp
+++ b/Libraries/LibWeb/DOM/Event.cpp
@@ -16,10 +16,10 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Event);
+GC_DEFINE_ALLOCATOR(Event);
 
 // https://dom.spec.whatwg.org/#concept-event-create
-JS::NonnullGCPtr<Event> Event::create(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
+GC::Ref<Event> Event::create(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
 {
     auto event = realm.create<Event>(realm, event_name, event_init);
     // 4. Initialize event’s isTrusted attribute to true.
@@ -27,7 +27,7 @@ JS::NonnullGCPtr<Event> Event::create(JS::Realm& realm, FlyString const& event_n
     return event;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> Event::construct_impl(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<Event>> Event::construct_impl(JS::Realm& realm, FlyString const& event_name, EventInit const& event_init)
 {
     return realm.create<Event>(realm, event_name, event_init);
 }
@@ -75,7 +75,7 @@ void Event::visit_edges(Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#concept-event-path-append
-void Event::append_to_path(EventTarget& invocation_target, JS::GCPtr<EventTarget> shadow_adjusted_target, JS::GCPtr<EventTarget> related_target, TouchTargetList& touch_targets, bool slot_in_closed_tree)
+void Event::append_to_path(EventTarget& invocation_target, GC::Ptr<EventTarget> shadow_adjusted_target, GC::Ptr<EventTarget> related_target, TouchTargetList& touch_targets, bool slot_in_closed_tree)
 {
     // 1. Let invocationTargetInShadowTree be false.
     bool invocation_target_in_shadow_tree = false;
@@ -146,10 +146,10 @@ void Event::init_event(String const& type, bool bubbles, bool cancelable)
 }
 
 // https://dom.spec.whatwg.org/#dom-event-composedpath
-Vector<JS::Handle<EventTarget>> Event::composed_path() const
+Vector<GC::Root<EventTarget>> Event::composed_path() const
 {
     // 1. Let composedPath be an empty list.
-    Vector<JS::Handle<EventTarget>> composed_path;
+    Vector<GC::Root<EventTarget>> composed_path;
 
     // 2. Let path be this’s path. (NOTE: Not necessary)
 
diff --git a/Libraries/LibWeb/DOM/Event.h b/Libraries/LibWeb/DOM/Event.h
index 0e57dbaa674..20a42718274 100644
--- a/Libraries/LibWeb/DOM/Event.h
+++ b/Libraries/LibWeb/DOM/Event.h
@@ -21,7 +21,7 @@ struct EventInit {
 
 class Event : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Event, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Event);
+    GC_DECLARE_ALLOCATOR(Event);
 
 public:
     enum Phase : u16 {
@@ -32,13 +32,13 @@ public:
     };
 
     // FIXME: These need explicit marking somehow.
-    using TouchTargetList = Vector<JS::GCPtr<EventTarget>>;
+    using TouchTargetList = Vector<GC::Ptr<EventTarget>>;
 
     struct PathEntry {
-        JS::GCPtr<EventTarget> invocation_target;
+        GC::Ptr<EventTarget> invocation_target;
         bool invocation_target_in_shadow_tree { false };
-        JS::GCPtr<EventTarget> shadow_adjusted_target;
-        JS::GCPtr<EventTarget> related_target;
+        GC::Ptr<EventTarget> shadow_adjusted_target;
+        GC::Ptr<EventTarget> related_target;
         TouchTargetList touch_target_list;
         bool root_of_closed_tree { false };
         bool slot_in_closed_tree { false };
@@ -47,8 +47,8 @@ public:
 
     using Path = Vector<PathEntry>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<Event> create(JS::Realm&, FlyString const& event_name, EventInit const& event_init = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Event>> construct_impl(JS::Realm&, FlyString const& event_name, EventInit const& event_init);
+    [[nodiscard]] static GC::Ref<Event> create(JS::Realm&, FlyString const& event_name, EventInit const& event_init = {});
+    static WebIDL::ExceptionOr<GC::Ref<Event>> construct_impl(JS::Realm&, FlyString const& event_name, EventInit const& event_init);
 
     Event(JS::Realm&, FlyString const& type);
     Event(JS::Realm&, FlyString const& type, EventInit const& event_init);
@@ -61,13 +61,13 @@ public:
     FlyString const& type() const { return m_type; }
     void set_type(FlyString const& type) { m_type = type; }
 
-    JS::GCPtr<EventTarget> target() const { return m_target; }
+    GC::Ptr<EventTarget> target() const { return m_target; }
     void set_target(EventTarget* target) { m_target = target; }
 
     // NOTE: This is intended for the JS bindings.
-    JS::GCPtr<EventTarget> src_element() const { return target(); }
+    GC::Ptr<EventTarget> src_element() const { return target(); }
 
-    JS::GCPtr<EventTarget> related_target() const { return m_related_target; }
+    GC::Ptr<EventTarget> related_target() const { return m_related_target; }
     void set_related_target(EventTarget* related_target) { m_related_target = related_target; }
 
     bool should_stop_propagation() const { return m_stop_propagation; }
@@ -97,7 +97,7 @@ public:
     u16 event_phase() const { return m_phase; }
     void set_phase(Phase phase) { m_phase = phase; }
 
-    JS::GCPtr<EventTarget> current_target() const { return m_current_target; }
+    GC::Ptr<EventTarget> current_target() const { return m_current_target; }
     void set_current_target(EventTarget* current_target) { m_current_target = current_target; }
 
     bool return_value() const { return !m_cancelled; }
@@ -107,7 +107,7 @@ public:
             set_cancelled_flag();
     }
 
-    void append_to_path(EventTarget&, JS::GCPtr<EventTarget>, JS::GCPtr<EventTarget>, TouchTargetList&, bool);
+    void append_to_path(EventTarget&, GC::Ptr<EventTarget>, GC::Ptr<EventTarget>, TouchTargetList&, bool);
     Path& path() { return m_path; }
     Path const& path() const { return m_path; }
     void clear_path() { m_path.clear(); }
@@ -144,7 +144,7 @@ public:
 
     void set_time_stamp(double time_stamp) { m_time_stamp = time_stamp; }
 
-    Vector<JS::Handle<EventTarget>> composed_path() const;
+    Vector<GC::Root<EventTarget>> composed_path() const;
 
     template<typename T>
     bool fast_is() const = delete;
@@ -160,9 +160,9 @@ protected:
 
 private:
     FlyString m_type;
-    JS::GCPtr<EventTarget> m_target;
-    JS::GCPtr<EventTarget> m_related_target;
-    JS::GCPtr<EventTarget> m_current_target;
+    GC::Ptr<EventTarget> m_target;
+    GC::Ptr<EventTarget> m_related_target;
+    GC::Ptr<EventTarget> m_current_target;
 
     Phase m_phase { None };
 
diff --git a/Libraries/LibWeb/DOM/EventDispatcher.cpp b/Libraries/LibWeb/DOM/EventDispatcher.cpp
index 97edc98b782..28f426cc2f1 100644
--- a/Libraries/LibWeb/DOM/EventDispatcher.cpp
+++ b/Libraries/LibWeb/DOM/EventDispatcher.cpp
@@ -31,7 +31,7 @@
 namespace Web::DOM {
 
 // https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke
-bool EventDispatcher::inner_invoke(Event& event, Vector<JS::Handle<DOM::DOMEventListener>>& listeners, Event::Phase phase, bool invocation_target_in_shadow_tree)
+bool EventDispatcher::inner_invoke(Event& event, Vector<GC::Root<DOM::DOMEventListener>>& listeners, Event::Phase phase, bool invocation_target_in_shadow_tree)
 {
     // 1. Let found be false.
     bool found = false;
@@ -181,14 +181,14 @@ void EventDispatcher::invoke(Event::PathEntry& struct_, Event& event, Event::Pha
 }
 
 // https://dom.spec.whatwg.org/#concept-event-dispatch
-bool EventDispatcher::dispatch(JS::NonnullGCPtr<EventTarget> target, Event& event, bool legacy_target_override)
+bool EventDispatcher::dispatch(GC::Ref<EventTarget> target, Event& event, bool legacy_target_override)
 {
     // 1. Set event’s dispatch flag.
     event.set_dispatched(true);
 
     // 2. Let targetOverride be target, if legacy target override flag is not given, and target’s associated Document otherwise. [HTML]
     // NOTE: legacy target override flag is only used by HTML and only when target is a Window object.
-    JS::GCPtr<EventTarget> target_override;
+    GC::Ptr<EventTarget> target_override;
     if (!legacy_target_override) {
         target_override = target;
     } else {
@@ -196,10 +196,10 @@ bool EventDispatcher::dispatch(JS::NonnullGCPtr<EventTarget> target, Event& even
     }
 
     // 3. Let activationTarget be null.
-    JS::GCPtr<EventTarget> activation_target;
+    GC::Ptr<EventTarget> activation_target;
 
     // 4. Let relatedTarget be the result of retargeting event’s relatedTarget against target.
-    JS::GCPtr<EventTarget> related_target = retarget(event.related_target(), target);
+    GC::Ptr<EventTarget> related_target = retarget(event.related_target(), target);
 
     bool clear_targets = false;
     // 5. If target is not relatedTarget or target is event’s relatedTarget, then:
@@ -223,7 +223,7 @@ bool EventDispatcher::dispatch(JS::NonnullGCPtr<EventTarget> target, Event& even
             activation_target = target;
 
         // 6. Let slottable be target, if target is a slottable and is assigned, and null otherwise.
-        JS::GCPtr<EventTarget> slottable;
+        GC::Ptr<EventTarget> slottable;
 
         if (is<Node>(*target) && is_an_assigned_slottable(static_cast<Node&>(*target)))
             slottable = target;
diff --git a/Libraries/LibWeb/DOM/EventDispatcher.h b/Libraries/LibWeb/DOM/EventDispatcher.h
index 78c355f870d..8ff24f1fbee 100644
--- a/Libraries/LibWeb/DOM/EventDispatcher.h
+++ b/Libraries/LibWeb/DOM/EventDispatcher.h
@@ -14,11 +14,11 @@ namespace Web::DOM {
 
 class EventDispatcher {
 public:
-    static bool dispatch(JS::NonnullGCPtr<EventTarget>, Event&, bool legacy_target_override = false);
+    static bool dispatch(GC::Ref<EventTarget>, Event&, bool legacy_target_override = false);
 
 private:
     static void invoke(Event::PathEntry&, Event&, Event::Phase);
-    static bool inner_invoke(Event&, Vector<JS::Handle<DOM::DOMEventListener>>&, Event::Phase, bool);
+    static bool inner_invoke(Event&, Vector<GC::Root<DOM::DOMEventListener>>&, Event::Phase, bool);
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/EventTarget.cpp b/Libraries/LibWeb/DOM/EventTarget.cpp
index ec839b9f368..1427158d5dd 100644
--- a/Libraries/LibWeb/DOM/EventTarget.cpp
+++ b/Libraries/LibWeb/DOM/EventTarget.cpp
@@ -41,7 +41,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(EventTarget);
+GC_DEFINE_ALLOCATOR(EventTarget);
 
 EventTarget::EventTarget(JS::Realm& realm, MayInterfereWithIndexedPropertyAccess may_interfere_with_indexed_property_access)
     : PlatformObject(realm, may_interfere_with_indexed_property_access)
@@ -51,7 +51,7 @@ EventTarget::EventTarget(JS::Realm& realm, MayInterfereWithIndexedPropertyAccess
 EventTarget::~EventTarget() = default;
 
 // https://dom.spec.whatwg.org/#dom-eventtarget-eventtarget
-WebIDL::ExceptionOr<JS::NonnullGCPtr<EventTarget>> EventTarget::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<EventTarget>> EventTarget::construct_impl(JS::Realm& realm)
 {
     // The new EventTarget() constructor steps are to do nothing.
     return realm.create<EventTarget>(realm);
@@ -77,9 +77,9 @@ void EventTarget::visit_edges(Cell::Visitor& visitor)
     }
 }
 
-Vector<JS::Handle<DOMEventListener>> EventTarget::event_listener_list()
+Vector<GC::Root<DOMEventListener>> EventTarget::event_listener_list()
 {
-    Vector<JS::Handle<DOMEventListener>> list;
+    Vector<GC::Root<DOMEventListener>> list;
     if (!m_data)
         return list;
     for (auto& listener : m_data->event_listener_list)
@@ -112,7 +112,7 @@ struct FlattenedAddEventListenerOptions {
     bool capture { false };
     bool passive { false };
     bool once { false };
-    JS::GCPtr<AbortSignal> signal;
+    GC::Ptr<AbortSignal> signal;
 };
 
 // https://dom.spec.whatwg.org/#event-flatten-more
@@ -126,7 +126,7 @@ static FlattenedAddEventListenerOptions flatten_add_event_listener_options(Varia
     bool passive = false;
 
     // 3. Let signal be null.
-    JS::GCPtr<AbortSignal> signal;
+    GC::Ptr<AbortSignal> signal;
 
     // 4. If options is a dictionary, then:
     if (options.has<AddEventListenerOptions>()) {
@@ -198,7 +198,7 @@ void EventTarget::add_an_event_listener(DOMEventListener& listener)
 
     // 5. If listener’s signal is not null, then add the following abort steps to it:
     if (listener.signal) {
-        // NOTE: `this` and `listener` are protected by AbortSignal using JS::HeapFunction.
+        // NOTE: `this` and `listener` are protected by AbortSignal using GC::HeapFunction.
         listener.signal->add_abort_algorithm([this, &listener] {
             // 1. Remove an event listener with eventTarget and listener.
             remove_an_event_listener(listener);
@@ -369,8 +369,8 @@ WebIDL::CallbackType* EventTarget::get_current_value_of_event_handler(FlyString
     if (event_handler->value.has<ByteString>()) {
         // 1. If eventTarget is an element, then let element be eventTarget, and document be element's node document.
         //    Otherwise, eventTarget is a Window object, let element be null, and document be eventTarget's associated Document.
-        JS::GCPtr<Element> element;
-        JS::GCPtr<Document> document;
+        GC::Ptr<Element> element;
+        GC::Ptr<Document> document;
 
         if (is<Element>(this)) {
             auto* element_event_target = verify_cast<Element>(this);
@@ -394,7 +394,7 @@ WebIDL::CallbackType* EventTarget::get_current_value_of_event_handler(FlyString
         // FIXME: 4. Let location be the location where the script body originated, as given by eventHandler's value.
 
         // 5. If element is not null and element has a form owner, let form owner be that form owner. Otherwise, let form owner be null.
-        JS::GCPtr<HTML::HTMLFormElement> form_owner;
+        GC::Ptr<HTML::HTMLFormElement> form_owner;
         if (is<HTML::FormAssociatedElement>(element.ptr())) {
             auto* form_associated_element = dynamic_cast<HTML::FormAssociatedElement*>(element.ptr());
             VERIFY(form_associated_element);
@@ -471,7 +471,7 @@ WebIDL::CallbackType* EventTarget::get_current_value_of_event_handler(FlyString
         auto& realm = settings_object.realm();
 
         //  2. Let scope be realm.[[GlobalEnv]].
-        auto scope = JS::NonnullGCPtr<JS::Environment> { realm.global_environment() };
+        auto scope = GC::Ref<JS::Environment> { realm.global_environment() };
 
         // 3. If eventHandler is an element's event handler, then set scope to NewObjectEnvironment(document, true, scope).
         //    (Otherwise, eventHandler is a Window object's event handler.)
@@ -499,12 +499,12 @@ WebIDL::CallbackType* EventTarget::get_current_value_of_event_handler(FlyString
         function->set_script_or_module({});
 
         // 12. Set eventHandler's value to the result of creating a Web IDL EventHandler callback function object whose object reference is function and whose callback context is settings object.
-        event_handler->value = JS::GCPtr(realm.heap().allocate<WebIDL::CallbackType>(*function, settings_object));
+        event_handler->value = GC::Ptr(realm.heap().allocate<WebIDL::CallbackType>(*function, settings_object));
     }
 
     // 4. Return eventHandler's value.
-    VERIFY(event_handler->value.has<JS::GCPtr<WebIDL::CallbackType>>());
-    return *event_handler->value.get_pointer<JS::GCPtr<WebIDL::CallbackType>>();
+    VERIFY(event_handler->value.has<GC::Ptr<WebIDL::CallbackType>>());
+    return *event_handler->value.get_pointer<GC::Ptr<WebIDL::CallbackType>>();
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-attributes:event-handler-idl-attributes-3
@@ -547,7 +547,7 @@ void EventTarget::set_event_handler_attribute(FlyString const& name, WebIDL::Cal
 
     auto& event_handler = event_handler_iterator->value;
 
-    event_handler->value = JS::GCPtr(value);
+    event_handler->value = GC::Ptr(value);
 
     //  4. Activate an event handler given eventTarget and name.
     //  NOTE: See the optimization comment above.
diff --git a/Libraries/LibWeb/DOM/EventTarget.h b/Libraries/LibWeb/DOM/EventTarget.h
index ea6e69eb830..5b850f43176 100644
--- a/Libraries/LibWeb/DOM/EventTarget.h
+++ b/Libraries/LibWeb/DOM/EventTarget.h
@@ -19,12 +19,12 @@ namespace Web::DOM {
 
 class EventTarget : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(EventTarget, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(EventTarget);
+    GC_DECLARE_ALLOCATOR(EventTarget);
 
 public:
     virtual ~EventTarget() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<EventTarget>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<EventTarget>> construct_impl(JS::Realm&);
 
     virtual bool is_focusable() const { return false; }
 
@@ -44,7 +44,7 @@ public:
     void remove_an_event_listener(DOMEventListener&);
     void remove_from_event_listener_list(DOMEventListener&);
 
-    Vector<JS::Handle<DOMEventListener>> event_listener_list();
+    Vector<GC::Root<DOMEventListener>> event_listener_list();
 
     virtual bool has_activation_behavior() const;
     virtual void activation_behavior(Event const&);
@@ -70,11 +70,11 @@ protected:
 
 private:
     struct Data {
-        Vector<JS::NonnullGCPtr<DOMEventListener>> event_listener_list;
+        Vector<GC::Ref<DOMEventListener>> event_listener_list;
 
         // https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-map
         // Spec Note: The order of the entries of event handler map could be arbitrary. It is not observable through any algorithms that operate on the map.
-        HashMap<FlyString, JS::NonnullGCPtr<HTML::EventHandler>> event_handler_map;
+        HashMap<FlyString, GC::Ref<HTML::EventHandler>> event_handler_map;
     };
 
     Data& ensure_data();
diff --git a/Libraries/LibWeb/DOM/HTMLCollection.cpp b/Libraries/LibWeb/DOM/HTMLCollection.cpp
index b590842c278..397abcd4000 100644
--- a/Libraries/LibWeb/DOM/HTMLCollection.cpp
+++ b/Libraries/LibWeb/DOM/HTMLCollection.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(HTMLCollection);
+GC_DEFINE_ALLOCATOR(HTMLCollection);
 
-JS::NonnullGCPtr<HTMLCollection> HTMLCollection::create(ParentNode& root, Scope scope, Function<bool(Element const&)> filter)
+GC::Ref<HTMLCollection> HTMLCollection::create(ParentNode& root, Scope scope, Function<bool(Element const&)> filter)
 {
     return root.realm().create<HTMLCollection>(root, scope, move(filter));
 }
@@ -57,7 +57,7 @@ void HTMLCollection::update_name_to_element_mappings_if_needed() const
     update_cache_if_needed();
     if (m_cached_name_to_element_mappings)
         return;
-    m_cached_name_to_element_mappings = make<OrderedHashMap<FlyString, JS::NonnullGCPtr<Element>>>();
+    m_cached_name_to_element_mappings = make<OrderedHashMap<FlyString, GC::Ref<Element>>>();
     for (auto const& element : m_cached_elements) {
         // 1. If element has an ID which is not in result, append element’s ID to result.
         if (auto const& id = element->id(); id.has_value()) {
@@ -98,10 +98,10 @@ void HTMLCollection::update_cache_if_needed() const
     m_cached_dom_tree_version = root()->document().dom_tree_version();
 }
 
-JS::MarkedVector<JS::NonnullGCPtr<Element>> HTMLCollection::collect_matching_elements() const
+GC::MarkedVector<GC::Ref<Element>> HTMLCollection::collect_matching_elements() const
 {
     update_cache_if_needed();
-    JS::MarkedVector<JS::NonnullGCPtr<Element>> elements(heap());
+    GC::MarkedVector<GC::Ref<Element>> elements(heap());
     for (auto& element : m_cached_elements)
         elements.append(element);
     return elements;
diff --git a/Libraries/LibWeb/DOM/HTMLCollection.h b/Libraries/LibWeb/DOM/HTMLCollection.h
index 5ebafa79772..fd4f3ebc978 100644
--- a/Libraries/LibWeb/DOM/HTMLCollection.h
+++ b/Libraries/LibWeb/DOM/HTMLCollection.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/Function.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 
@@ -23,14 +23,14 @@ namespace Web::DOM {
 
 class HTMLCollection : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(HTMLCollection, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(HTMLCollection);
+    GC_DECLARE_ALLOCATOR(HTMLCollection);
 
 public:
     enum class Scope {
         Children,
         Descendants,
     };
-    [[nodiscard]] static JS::NonnullGCPtr<HTMLCollection> create(ParentNode& root, Scope, ESCAPING Function<bool(Element const&)> filter);
+    [[nodiscard]] static GC::Ref<HTMLCollection> create(ParentNode& root, Scope, ESCAPING Function<bool(Element const&)> filter);
 
     virtual ~HTMLCollection() override;
 
@@ -38,7 +38,7 @@ public:
     Element* item(size_t index) const;
     Element* named_item(FlyString const& key) const;
 
-    JS::MarkedVector<JS::NonnullGCPtr<Element>> collect_matching_elements() const;
+    GC::MarkedVector<GC::Ref<Element>> collect_matching_elements() const;
 
     virtual Optional<JS::Value> item_value(size_t index) const override;
     virtual JS::Value named_item_value(FlyString const& name) const override;
@@ -50,8 +50,8 @@ protected:
 
     virtual void initialize(JS::Realm&) override;
 
-    JS::NonnullGCPtr<ParentNode> root() { return *m_root; }
-    JS::NonnullGCPtr<ParentNode const> root() const { return *m_root; }
+    GC::Ref<ParentNode> root() { return *m_root; }
+    GC::Ref<ParentNode const> root() const { return *m_root; }
 
 private:
     virtual void visit_edges(Cell::Visitor&) override;
@@ -60,10 +60,10 @@ private:
     void update_name_to_element_mappings_if_needed() const;
 
     mutable u64 m_cached_dom_tree_version { 0 };
-    mutable Vector<JS::NonnullGCPtr<Element>> m_cached_elements;
-    mutable OwnPtr<OrderedHashMap<FlyString, JS::NonnullGCPtr<Element>>> m_cached_name_to_element_mappings;
+    mutable Vector<GC::Ref<Element>> m_cached_elements;
+    mutable OwnPtr<OrderedHashMap<FlyString, GC::Ref<Element>>> m_cached_name_to_element_mappings;
 
-    JS::NonnullGCPtr<ParentNode> m_root;
+    GC::Ref<ParentNode> m_root;
     Function<bool(Element const&)> m_filter;
 
     Scope m_scope { Scope::Descendants };
diff --git a/Libraries/LibWeb/DOM/IDLEventListener.cpp b/Libraries/LibWeb/DOM/IDLEventListener.cpp
index 45923d2f566..9ea566ab018 100644
--- a/Libraries/LibWeb/DOM/IDLEventListener.cpp
+++ b/Libraries/LibWeb/DOM/IDLEventListener.cpp
@@ -4,20 +4,20 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibWeb/DOM/IDLEventListener.h>
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(IDLEventListener);
+GC_DEFINE_ALLOCATOR(IDLEventListener);
 
-JS::NonnullGCPtr<IDLEventListener> IDLEventListener::create(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::CallbackType> callback)
+GC::Ref<IDLEventListener> IDLEventListener::create(JS::Realm& realm, GC::Ref<WebIDL::CallbackType> callback)
 {
     return realm.create<IDLEventListener>(realm, move(callback));
 }
 
-IDLEventListener::IDLEventListener(JS::Realm& realm, JS::NonnullGCPtr<WebIDL::CallbackType> callback)
+IDLEventListener::IDLEventListener(JS::Realm& realm, GC::Ref<WebIDL::CallbackType> callback)
     : JS::Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
     , m_callback(move(callback))
 {
diff --git a/Libraries/LibWeb/DOM/IDLEventListener.h b/Libraries/LibWeb/DOM/IDLEventListener.h
index bf343835e83..f8bc9b06c50 100644
--- a/Libraries/LibWeb/DOM/IDLEventListener.h
+++ b/Libraries/LibWeb/DOM/IDLEventListener.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/RefCounted.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/AbortSignal.h>
 #include <LibWeb/WebIDL/CallbackType.h>
 
@@ -21,16 +21,16 @@ struct EventListenerOptions {
 struct AddEventListenerOptions : public EventListenerOptions {
     bool passive { false };
     bool once { false };
-    JS::GCPtr<AbortSignal> signal;
+    GC::Ptr<AbortSignal> signal;
 };
 
 class IDLEventListener final : public JS::Object {
     JS_OBJECT(IDLEventListener, JS::Object);
-    JS_DECLARE_ALLOCATOR(IDLEventListener);
+    GC_DECLARE_ALLOCATOR(IDLEventListener);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<IDLEventListener> create(JS::Realm&, JS::NonnullGCPtr<WebIDL::CallbackType>);
-    IDLEventListener(JS::Realm&, JS::NonnullGCPtr<WebIDL::CallbackType>);
+    [[nodiscard]] static GC::Ref<IDLEventListener> create(JS::Realm&, GC::Ref<WebIDL::CallbackType>);
+    IDLEventListener(JS::Realm&, GC::Ref<WebIDL::CallbackType>);
 
     virtual ~IDLEventListener() = default;
 
@@ -39,7 +39,7 @@ public:
 private:
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<WebIDL::CallbackType> m_callback;
+    GC::Ref<WebIDL::CallbackType> m_callback;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/InputEventsTarget.h b/Libraries/LibWeb/DOM/InputEventsTarget.h
index bab2a1b3b62..b3e30a25fa2 100644
--- a/Libraries/LibWeb/DOM/InputEventsTarget.h
+++ b/Libraries/LibWeb/DOM/InputEventsTarget.h
@@ -24,8 +24,8 @@ public:
     virtual void handle_delete(DeleteDirection) = 0;
 
     virtual void select_all() = 0;
-    virtual void set_selection_anchor(JS::NonnullGCPtr<DOM::Node>, size_t offset) = 0;
-    virtual void set_selection_focus(JS::NonnullGCPtr<DOM::Node>, size_t offset) = 0;
+    virtual void set_selection_anchor(GC::Ref<DOM::Node>, size_t offset) = 0;
+    virtual void set_selection_focus(GC::Ref<DOM::Node>, size_t offset) = 0;
     enum class CollapseSelection {
         No,
         Yes,
diff --git a/Libraries/LibWeb/DOM/LiveNodeList.cpp b/Libraries/LibWeb/DOM/LiveNodeList.cpp
index 9d809859cfd..4355fe9d2dd 100644
--- a/Libraries/LibWeb/DOM/LiveNodeList.cpp
+++ b/Libraries/LibWeb/DOM/LiveNodeList.cpp
@@ -5,16 +5,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibWeb/DOM/LiveNodeList.h>
 #include <LibWeb/DOM/Node.h>
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(LiveNodeList);
+GC_DEFINE_ALLOCATOR(LiveNodeList);
 
-JS::NonnullGCPtr<NodeList> LiveNodeList::create(JS::Realm& realm, Node const& root, Scope scope, Function<bool(Node const&)> filter)
+GC::Ref<NodeList> LiveNodeList::create(JS::Realm& realm, Node const& root, Scope scope, Function<bool(Node const&)> filter)
 {
     return realm.create<LiveNodeList>(realm, root, scope, move(filter));
 }
@@ -35,9 +35,9 @@ void LiveNodeList::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_root);
 }
 
-JS::MarkedVector<Node*> LiveNodeList::collection() const
+GC::MarkedVector<Node*> LiveNodeList::collection() const
 {
-    JS::MarkedVector<Node*> nodes(heap());
+    GC::MarkedVector<Node*> nodes(heap());
     if (m_scope == Scope::Descendants) {
         m_root->for_each_in_subtree([&](auto& node) {
             if (m_filter(node))
diff --git a/Libraries/LibWeb/DOM/LiveNodeList.h b/Libraries/LibWeb/DOM/LiveNodeList.h
index e83bf3d6388..466694314b5 100644
--- a/Libraries/LibWeb/DOM/LiveNodeList.h
+++ b/Libraries/LibWeb/DOM/LiveNodeList.h
@@ -16,7 +16,7 @@ namespace Web::DOM {
 
 class LiveNodeList : public NodeList {
     WEB_PLATFORM_OBJECT(LiveNodeList, NodeList);
-    JS_DECLARE_ALLOCATOR(LiveNodeList);
+    GC_DECLARE_ALLOCATOR(LiveNodeList);
 
 public:
     enum class Scope {
@@ -24,7 +24,7 @@ public:
         Descendants,
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<NodeList> create(JS::Realm&, Node const& root, Scope, ESCAPING Function<bool(Node const&)> filter);
+    [[nodiscard]] static GC::Ref<NodeList> create(JS::Realm&, Node const& root, Scope, ESCAPING Function<bool(Node const&)> filter);
     virtual ~LiveNodeList() override;
 
     virtual u32 length() const override;
@@ -38,9 +38,9 @@ protected:
 private:
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::MarkedVector<Node*> collection() const;
+    GC::MarkedVector<Node*> collection() const;
 
-    JS::NonnullGCPtr<Node const> m_root;
+    GC::Ref<Node const> m_root;
     Function<bool(Node const&)> m_filter;
     Scope m_scope { Scope::Descendants };
 };
diff --git a/Libraries/LibWeb/DOM/MutationObserver.cpp b/Libraries/LibWeb/DOM/MutationObserver.cpp
index a51add5c23d..03a95aa830e 100644
--- a/Libraries/LibWeb/DOM/MutationObserver.cpp
+++ b/Libraries/LibWeb/DOM/MutationObserver.cpp
@@ -12,16 +12,16 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(MutationObserver);
-JS_DEFINE_ALLOCATOR(TransientRegisteredObserver);
+GC_DEFINE_ALLOCATOR(MutationObserver);
+GC_DEFINE_ALLOCATOR(TransientRegisteredObserver);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MutationObserver>> MutationObserver::construct_impl(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback)
+WebIDL::ExceptionOr<GC::Ref<MutationObserver>> MutationObserver::construct_impl(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback)
 {
     return realm.create<MutationObserver>(realm, callback);
 }
 
 // https://dom.spec.whatwg.org/#dom-mutationobserver-mutationobserver
-MutationObserver::MutationObserver(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback)
+MutationObserver::MutationObserver(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback)
     : PlatformObject(realm)
     , m_callback(move(callback))
 {
@@ -146,10 +146,10 @@ void MutationObserver::disconnect()
 }
 
 // https://dom.spec.whatwg.org/#dom-mutationobserver-takerecords
-Vector<JS::Handle<MutationRecord>> MutationObserver::take_records()
+Vector<GC::Root<MutationRecord>> MutationObserver::take_records()
 {
     // 1. Let records be a clone of this’s record queue.
-    Vector<JS::Handle<MutationRecord>> records;
+    Vector<GC::Root<MutationRecord>> records;
     for (auto& record : m_record_queue)
         records.append(*record);
 
@@ -160,7 +160,7 @@ Vector<JS::Handle<MutationRecord>> MutationObserver::take_records()
     return records;
 }
 
-JS::NonnullGCPtr<RegisteredObserver> RegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options)
+GC::Ref<RegisteredObserver> RegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options)
 {
     return observer.heap().allocate<RegisteredObserver>(observer, options);
 }
@@ -179,7 +179,7 @@ void RegisteredObserver::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_observer);
 }
 
-JS::NonnullGCPtr<TransientRegisteredObserver> TransientRegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options, RegisteredObserver& source)
+GC::Ref<TransientRegisteredObserver> TransientRegisteredObserver::create(MutationObserver& observer, MutationObserverInit const& options, RegisteredObserver& source)
 {
     return observer.heap().allocate<TransientRegisteredObserver>(observer, options, source);
 }
diff --git a/Libraries/LibWeb/DOM/MutationObserver.h b/Libraries/LibWeb/DOM/MutationObserver.h
index 9605a458498..a00762d5382 100644
--- a/Libraries/LibWeb/DOM/MutationObserver.h
+++ b/Libraries/LibWeb/DOM/MutationObserver.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/RefCounted.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/MutationRecord.h>
 #include <LibWeb/WebIDL/CallbackType.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
@@ -29,34 +29,34 @@ struct MutationObserverInit {
 // https://dom.spec.whatwg.org/#mutationobserver
 class MutationObserver final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MutationObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MutationObserver);
+    GC_DECLARE_ALLOCATOR(MutationObserver);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<MutationObserver>> construct_impl(JS::Realm&, JS::GCPtr<WebIDL::CallbackType>);
+    static WebIDL::ExceptionOr<GC::Ref<MutationObserver>> construct_impl(JS::Realm&, GC::Ptr<WebIDL::CallbackType>);
     virtual ~MutationObserver() override;
 
     WebIDL::ExceptionOr<void> observe(Node& target, MutationObserverInit options = {});
     void disconnect();
-    Vector<JS::Handle<MutationRecord>> take_records();
+    Vector<GC::Root<MutationRecord>> take_records();
 
     Vector<WeakPtr<Node>>& node_list() { return m_node_list; }
     Vector<WeakPtr<Node>> const& node_list() const { return m_node_list; }
 
     WebIDL::CallbackType& callback() { return *m_callback; }
 
-    void enqueue_record(Badge<Node>, JS::NonnullGCPtr<MutationRecord> mutation_record)
+    void enqueue_record(Badge<Node>, GC::Ref<MutationRecord> mutation_record)
     {
         m_record_queue.append(*mutation_record);
     }
 
 private:
-    MutationObserver(JS::Realm&, JS::GCPtr<WebIDL::CallbackType>);
+    MutationObserver(JS::Realm&, GC::Ptr<WebIDL::CallbackType>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://dom.spec.whatwg.org/#concept-mo-callback
-    JS::GCPtr<WebIDL::CallbackType> m_callback;
+    GC::Ptr<WebIDL::CallbackType> m_callback;
 
     // https://dom.spec.whatwg.org/#mutationobserver-node-list
     // NOTE: These are weak, per https://dom.spec.whatwg.org/#garbage-collection
@@ -64,18 +64,18 @@ private:
     Vector<WeakPtr<Node>> m_node_list;
 
     // https://dom.spec.whatwg.org/#concept-mo-queue
-    Vector<JS::NonnullGCPtr<MutationRecord>> m_record_queue;
+    Vector<GC::Ref<MutationRecord>> m_record_queue;
 };
 
 // https://dom.spec.whatwg.org/#registered-observer
 class RegisteredObserver : public JS::Cell {
-    JS_CELL(RegisteredObserver, JS::Cell);
+    GC_CELL(RegisteredObserver, JS::Cell);
 
 public:
-    static JS::NonnullGCPtr<RegisteredObserver> create(MutationObserver&, MutationObserverInit const&);
+    static GC::Ref<RegisteredObserver> create(MutationObserver&, MutationObserverInit const&);
     virtual ~RegisteredObserver() override;
 
-    JS::NonnullGCPtr<MutationObserver> observer() const { return m_observer; }
+    GC::Ref<MutationObserver> observer() const { return m_observer; }
 
     MutationObserverInit const& options() const { return m_options; }
     void set_options(MutationObserverInit options) { m_options = move(options); }
@@ -86,27 +86,27 @@ protected:
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
-    JS::NonnullGCPtr<MutationObserver> m_observer;
+    GC::Ref<MutationObserver> m_observer;
     MutationObserverInit m_options;
 };
 
 // https://dom.spec.whatwg.org/#transient-registered-observer
 class TransientRegisteredObserver final : public RegisteredObserver {
-    JS_CELL(TransientRegisteredObserver, RegisteredObserver);
-    JS_DECLARE_ALLOCATOR(TransientRegisteredObserver);
+    GC_CELL(TransientRegisteredObserver, RegisteredObserver);
+    GC_DECLARE_ALLOCATOR(TransientRegisteredObserver);
 
 public:
-    static JS::NonnullGCPtr<TransientRegisteredObserver> create(MutationObserver&, MutationObserverInit const&, RegisteredObserver& source);
+    static GC::Ref<TransientRegisteredObserver> create(MutationObserver&, MutationObserverInit const&, RegisteredObserver& source);
     virtual ~TransientRegisteredObserver() override;
 
-    JS::NonnullGCPtr<RegisteredObserver> source() const { return m_source; }
+    GC::Ref<RegisteredObserver> source() const { return m_source; }
 
 private:
     TransientRegisteredObserver(MutationObserver& observer, MutationObserverInit const& options, RegisteredObserver& source);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<RegisteredObserver> m_source;
+    GC::Ref<RegisteredObserver> m_source;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/MutationRecord.cpp b/Libraries/LibWeb/DOM/MutationRecord.cpp
index 79b1d7cecb3..f18091020d7 100644
--- a/Libraries/LibWeb/DOM/MutationRecord.cpp
+++ b/Libraries/LibWeb/DOM/MutationRecord.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(MutationRecord);
+GC_DEFINE_ALLOCATOR(MutationRecord);
 
-JS::NonnullGCPtr<MutationRecord> MutationRecord::create(JS::Realm& realm, FlyString const& type, Node const& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, Optional<String> const& attribute_name, Optional<String> const& attribute_namespace, Optional<String> const& old_value)
+GC::Ref<MutationRecord> MutationRecord::create(JS::Realm& realm, FlyString const& type, Node const& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, Optional<String> const& attribute_name, Optional<String> const& attribute_namespace, Optional<String> const& old_value)
 {
     return realm.create<MutationRecord>(realm, type, target, added_nodes, removed_nodes, previous_sibling, next_sibling, attribute_name, attribute_namespace, old_value);
 }
@@ -23,11 +23,11 @@ JS::NonnullGCPtr<MutationRecord> MutationRecord::create(JS::Realm& realm, FlyStr
 MutationRecord::MutationRecord(JS::Realm& realm, FlyString const& type, Node const& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, Optional<String> const& attribute_name, Optional<String> const& attribute_namespace, Optional<String> const& old_value)
     : PlatformObject(realm)
     , m_type(type)
-    , m_target(JS::make_handle(target))
+    , m_target(GC::make_root(target))
     , m_added_nodes(added_nodes)
     , m_removed_nodes(removed_nodes)
-    , m_previous_sibling(JS::make_handle(previous_sibling))
-    , m_next_sibling(JS::make_handle(next_sibling))
+    , m_previous_sibling(GC::make_root(previous_sibling))
+    , m_next_sibling(GC::make_root(next_sibling))
     , m_attribute_name(attribute_name)
     , m_attribute_namespace(attribute_namespace)
     , m_old_value(old_value)
diff --git a/Libraries/LibWeb/DOM/MutationRecord.h b/Libraries/LibWeb/DOM/MutationRecord.h
index aba2333a567..6306f820e7a 100644
--- a/Libraries/LibWeb/DOM/MutationRecord.h
+++ b/Libraries/LibWeb/DOM/MutationRecord.h
@@ -14,10 +14,10 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#mutationrecord
 class MutationRecord : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MutationRecord, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MutationRecord);
+    GC_DECLARE_ALLOCATOR(MutationRecord);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MutationRecord> create(JS::Realm&, FlyString const& type, Node const& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, Optional<String> const& attribute_name, Optional<String> const& attribute_namespace, Optional<String> const& old_value);
+    [[nodiscard]] static GC::Ref<MutationRecord> create(JS::Realm&, FlyString const& type, Node const& target, NodeList& added_nodes, NodeList& removed_nodes, Node* previous_sibling, Node* next_sibling, Optional<String> const& attribute_name, Optional<String> const& attribute_namespace, Optional<String> const& old_value);
 
     virtual ~MutationRecord() override;
 
@@ -38,11 +38,11 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
 
     FlyString m_type;
-    JS::GCPtr<Node const> m_target;
-    JS::GCPtr<NodeList> m_added_nodes;
-    JS::GCPtr<NodeList> m_removed_nodes;
-    JS::GCPtr<Node> m_previous_sibling;
-    JS::GCPtr<Node> m_next_sibling;
+    GC::Ptr<Node const> m_target;
+    GC::Ptr<NodeList> m_added_nodes;
+    GC::Ptr<NodeList> m_removed_nodes;
+    GC::Ptr<Node> m_previous_sibling;
+    GC::Ptr<Node> m_next_sibling;
     Optional<String> m_attribute_name;
     Optional<String> m_attribute_namespace;
     Optional<String> m_old_value;
diff --git a/Libraries/LibWeb/DOM/NamedNodeMap.cpp b/Libraries/LibWeb/DOM/NamedNodeMap.cpp
index 8a09c105fed..11ed46345cf 100644
--- a/Libraries/LibWeb/DOM/NamedNodeMap.cpp
+++ b/Libraries/LibWeb/DOM/NamedNodeMap.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(NamedNodeMap);
+GC_DEFINE_ALLOCATOR(NamedNodeMap);
 
-JS::NonnullGCPtr<NamedNodeMap> NamedNodeMap::create(Element& element)
+GC::Ref<NamedNodeMap> NamedNodeMap::create(Element& element)
 {
     auto& realm = element.realm();
     return realm.create<NamedNodeMap>(element);
@@ -96,13 +96,13 @@ Attr const* NamedNodeMap::get_named_item_ns(Optional<FlyString> const& namespace
 }
 
 // https://dom.spec.whatwg.org/#dom-namednodemap-setnameditem
-WebIDL::ExceptionOr<JS::GCPtr<Attr>> NamedNodeMap::set_named_item(Attr& attribute)
+WebIDL::ExceptionOr<GC::Ptr<Attr>> NamedNodeMap::set_named_item(Attr& attribute)
 {
     return set_attribute(attribute);
 }
 
 // https://dom.spec.whatwg.org/#dom-namednodemap-setnameditemns
-WebIDL::ExceptionOr<JS::GCPtr<Attr>> NamedNodeMap::set_named_item_ns(Attr& attribute)
+WebIDL::ExceptionOr<GC::Ptr<Attr>> NamedNodeMap::set_named_item_ns(Attr& attribute)
 {
     return set_attribute(attribute);
 }
@@ -210,7 +210,7 @@ Attr const* NamedNodeMap::get_attribute_ns(Optional<FlyString> const& namespace_
 }
 
 // https://dom.spec.whatwg.org/#concept-element-attributes-set
-WebIDL::ExceptionOr<JS::GCPtr<Attr>> NamedNodeMap::set_attribute(Attr& attribute)
+WebIDL::ExceptionOr<GC::Ptr<Attr>> NamedNodeMap::set_attribute(Attr& attribute)
 {
     // 1. If attr’s element is neither null nor element, throw an "InUseAttributeError" DOMException.
     if ((attribute.owner_element() != nullptr) && (attribute.owner_element() != &associated_element()))
@@ -272,7 +272,7 @@ void NamedNodeMap::append_attribute(Attr& attribute)
 // https://dom.spec.whatwg.org/#concept-element-attributes-remove
 void NamedNodeMap::remove_attribute_at_index(size_t attribute_index)
 {
-    JS::NonnullGCPtr<Attr> attribute = m_attributes.at(attribute_index);
+    GC::Ref<Attr> attribute = m_attributes.at(attribute_index);
 
     // 1. Let element be attribute’s element.
     auto* element = attribute->owner_element();
@@ -337,7 +337,7 @@ JS::Value NamedNodeMap::named_item_value(FlyString const& name) const
 }
 
 // https://dom.spec.whatwg.org/#dom-element-removeattributenode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> NamedNodeMap::remove_attribute_node(JS::NonnullGCPtr<Attr> attr)
+WebIDL::ExceptionOr<GC::Ref<Attr>> NamedNodeMap::remove_attribute_node(GC::Ref<Attr> attr)
 {
     // 1. If this’s attribute list does not contain attr, then throw a "NotFoundError" DOMException.
     auto index = m_attributes.find_first_index(attr);
diff --git a/Libraries/LibWeb/DOM/NamedNodeMap.h b/Libraries/LibWeb/DOM/NamedNodeMap.h
index ce6c050ae75..27052935f52 100644
--- a/Libraries/LibWeb/DOM/NamedNodeMap.h
+++ b/Libraries/LibWeb/DOM/NamedNodeMap.h
@@ -18,10 +18,10 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#interface-namednodemap
 class NamedNodeMap : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NamedNodeMap, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NamedNodeMap);
+    GC_DECLARE_ALLOCATOR(NamedNodeMap);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NamedNodeMap> create(Element&);
+    [[nodiscard]] static GC::Ref<NamedNodeMap> create(Element&);
     ~NamedNodeMap() = default;
 
     virtual Vector<FlyString> supported_property_names() const override;
@@ -35,15 +35,15 @@ public:
     Attr const* item(u32 index) const;
     Attr const* get_named_item(FlyString const& qualified_name) const;
     Attr const* get_named_item_ns(Optional<FlyString> const& namespace_, FlyString const& local_name) const;
-    WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_named_item(Attr& attribute);
-    WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_named_item_ns(Attr& attribute);
+    WebIDL::ExceptionOr<GC::Ptr<Attr>> set_named_item(Attr& attribute);
+    WebIDL::ExceptionOr<GC::Ptr<Attr>> set_named_item_ns(Attr& attribute);
     WebIDL::ExceptionOr<Attr const*> remove_named_item(FlyString const& qualified_name);
     WebIDL::ExceptionOr<Attr const*> remove_named_item_ns(Optional<FlyString> const& namespace_, FlyString const& local_name);
 
     // Methods defined by the spec for internal use:
     Attr* get_attribute(FlyString const& qualified_name, size_t* item_index = nullptr);
     Attr const* get_attribute(FlyString const& qualified_name, size_t* item_index = nullptr) const;
-    WebIDL::ExceptionOr<JS::GCPtr<Attr>> set_attribute(Attr& attribute);
+    WebIDL::ExceptionOr<GC::Ptr<Attr>> set_attribute(Attr& attribute);
     void replace_attribute(Attr& old_attribute, Attr& new_attribute, size_t old_attribute_index);
     void append_attribute(Attr& attribute);
 
@@ -55,7 +55,7 @@ public:
 
     Attr const* get_attribute_with_lowercase_qualified_name(FlyString const&) const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Attr>> remove_attribute_node(JS::NonnullGCPtr<Attr>);
+    WebIDL::ExceptionOr<GC::Ref<Attr>> remove_attribute_node(GC::Ref<Attr>);
 
 private:
     explicit NamedNodeMap(Element&);
@@ -68,8 +68,8 @@ private:
 
     void remove_attribute_at_index(size_t attribute_index);
 
-    JS::NonnullGCPtr<DOM::Element> m_element;
-    Vector<JS::NonnullGCPtr<Attr>> m_attributes;
+    GC::Ref<DOM::Element> m_element;
+    Vector<GC::Ref<Attr>> m_attributes;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/Node.cpp b/Libraries/LibWeb/DOM/Node.cpp
index f9852f10824..b820b16457b 100644
--- a/Libraries/LibWeb/DOM/Node.cpp
+++ b/Libraries/LibWeb/DOM/Node.cpp
@@ -8,7 +8,7 @@
 
 #include <AK/HashTable.h>
 #include <AK/StringBuilder.h>
-#include <LibJS/Heap/DeferGC.h>
+#include <LibGC/DeferGC.h>
 #include <LibJS/Runtime/FunctionObject.h>
 #include <LibRegex/Regex.h>
 #include <LibURL/Origin.h>
@@ -367,7 +367,7 @@ void Node::set_node_value(Optional<String> const& maybe_value)
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#node-navigable
-JS::GCPtr<HTML::Navigable> Node::navigable() const
+GC::Ptr<HTML::Navigable> Node::navigable() const
 {
     auto& document = const_cast<Document&>(this->document());
     if (auto cached_navigable = document.cached_navigable()) {
@@ -519,7 +519,7 @@ bool Node::is_browsing_context_connected() const
 }
 
 // https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
-WebIDL::ExceptionOr<void> Node::ensure_pre_insertion_validity(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child) const
+WebIDL::ExceptionOr<void> Node::ensure_pre_insertion_validity(GC::Ref<Node> node, GC::Ptr<Node> child) const
 {
     // 1. If parent is not a Document, DocumentFragment, or Element node, then throw a "HierarchyRequestError" DOMException.
     if (!is<Document>(this) && !is<DocumentFragment>(this) && !is<Element>(this))
@@ -570,14 +570,14 @@ WebIDL::ExceptionOr<void> Node::ensure_pre_insertion_validity(JS::NonnullGCPtr<N
 }
 
 // https://dom.spec.whatwg.org/#concept-node-insert
-void Node::insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, bool suppress_observers)
+void Node::insert_before(GC::Ref<Node> node, GC::Ptr<Node> child, bool suppress_observers)
 {
     // 1. Let nodes be node’s children, if node is a DocumentFragment node; otherwise « node ».
-    Vector<JS::Handle<Node>> nodes;
+    Vector<GC::Root<Node>> nodes;
     if (is<DocumentFragment>(*node))
         nodes = node->children_as_vector();
     else
-        nodes.append(JS::make_handle(*node));
+        nodes.append(GC::make_root(*node));
 
     // 2. Let count be nodes’s size.
     auto count = nodes.size();
@@ -612,7 +612,7 @@ void Node::insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, boo
     }
 
     // 6. Let previousSibling be child’s previous sibling or parent’s last child if child is null.
-    JS::GCPtr<Node> previous_sibling;
+    GC::Ptr<Node> previous_sibling;
     if (child)
         previous_sibling = child->previous_sibling();
     else
@@ -670,7 +670,7 @@ void Node::insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, boo
                 // 1. If inclusiveDescendant is custom, then enqueue a custom element callback reaction with inclusiveDescendant,
                 //    callback name "connectedCallback", and an empty argument list.
                 if (element.is_custom()) {
-                    JS::MarkedVector<JS::Value> empty_arguments { vm().heap() };
+                    GC::MarkedVector<JS::Value> empty_arguments { vm().heap() };
                     element.enqueue_a_custom_element_callback_reaction(HTML::CustomElementReactionNames::connectedCallback, move(empty_arguments));
                 }
 
@@ -704,7 +704,7 @@ void Node::insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, boo
 }
 
 // https://dom.spec.whatwg.org/#concept-node-pre-insert
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::pre_insert(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::pre_insert(GC::Ref<Node> node, GC::Ptr<Node> child)
 {
     // 1. Ensure pre-insertion validity of node into parent before child.
     TRY(ensure_pre_insertion_validity(node, child));
@@ -724,14 +724,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::pre_insert(JS::NonnullGCPtr<No
 }
 
 // https://dom.spec.whatwg.org/#dom-node-removechild
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::remove_child(JS::NonnullGCPtr<Node> child)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::remove_child(GC::Ref<Node> child)
 {
     // The removeChild(child) method steps are to return the result of pre-removing child from this.
     return pre_remove(child);
 }
 
 // https://dom.spec.whatwg.org/#concept-node-pre-remove
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::pre_remove(JS::NonnullGCPtr<Node> child)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::pre_remove(GC::Ref<Node> child)
 {
     // 1. If child’s parent is not parent, then throw a "NotFoundError" DOMException.
     if (child->parent() != this)
@@ -745,7 +745,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::pre_remove(JS::NonnullGCPtr<No
 }
 
 // https://dom.spec.whatwg.org/#concept-node-append
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::append_child(JS::NonnullGCPtr<Node> node)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::append_child(GC::Ref<Node> node)
 {
     // To append a node to a parent, pre-insert node into parent before null.
     return pre_insert(node, nullptr);
@@ -793,10 +793,10 @@ void Node::remove(bool suppress_observers)
     });
 
     // 9. Let oldPreviousSibling be node’s previous sibling.
-    JS::GCPtr<Node> old_previous_sibling = previous_sibling();
+    GC::Ptr<Node> old_previous_sibling = previous_sibling();
 
     // 10. Let oldNextSibling be node’s next sibling.
-    JS::GCPtr<Node> old_next_sibling = next_sibling();
+    GC::Ptr<Node> old_next_sibling = next_sibling();
 
     if (is_connected()) {
         // Since the tree structure is about to change, we need to invalidate both style and layout.
@@ -856,7 +856,7 @@ void Node::remove(bool suppress_observers)
         auto& element = static_cast<DOM::Element&>(*this);
 
         if (element.is_custom() && is_parent_connected) {
-            JS::MarkedVector<JS::Value> empty_arguments { vm().heap() };
+            GC::MarkedVector<JS::Value> empty_arguments { vm().heap() };
             element.enqueue_a_custom_element_callback_reaction(HTML::CustomElementReactionNames::disconnectedCallback, move(empty_arguments));
         }
     }
@@ -872,7 +872,7 @@ void Node::remove(bool suppress_observers)
             auto& element = static_cast<DOM::Element&>(descendant);
 
             if (element.is_custom() && is_parent_connected) {
-                JS::MarkedVector<JS::Value> empty_arguments { vm().heap() };
+                GC::MarkedVector<JS::Value> empty_arguments { vm().heap() };
                 element.enqueue_a_custom_element_callback_reaction(HTML::CustomElementReactionNames::disconnectedCallback, move(empty_arguments));
             }
         }
@@ -906,7 +906,7 @@ void Node::remove(bool suppress_observers)
 }
 
 // https://dom.spec.whatwg.org/#concept-node-replace
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::replace_child(JS::NonnullGCPtr<Node> node, JS::NonnullGCPtr<Node> child)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::replace_child(GC::Ref<Node> node, GC::Ref<Node> child)
 {
     // If parent is not a Document, DocumentFragment, or Element node, then throw a "HierarchyRequestError" DOMException.
     if (!is<Document>(this) && !is<DocumentFragment>(this) && !is<Element>(this))
@@ -955,34 +955,34 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::replace_child(JS::NonnullGCPtr
     }
 
     // 7. Let referenceChild be child’s next sibling.
-    JS::GCPtr<Node> reference_child = child->next_sibling();
+    GC::Ptr<Node> reference_child = child->next_sibling();
 
     // 8. If referenceChild is node, then set referenceChild to node’s next sibling.
     if (reference_child == node)
         reference_child = node->next_sibling();
 
     // 9. Let previousSibling be child’s previous sibling.
-    JS::GCPtr<Node> previous_sibling = child->previous_sibling();
+    GC::Ptr<Node> previous_sibling = child->previous_sibling();
 
     // 10. Let removedNodes be the empty set.
-    Vector<JS::Handle<Node>> removed_nodes;
+    Vector<GC::Root<Node>> removed_nodes;
 
     // 11. If child’s parent is non-null, then:
     // NOTE: The above can only be false if child is node.
     if (child->parent()) {
         // 1. Set removedNodes to « child ».
-        removed_nodes.append(JS::make_handle(*child));
+        removed_nodes.append(GC::make_root(*child));
 
         // 2. Remove child with the suppress observers flag set.
         child->remove(true);
     }
 
     // 12. Let nodes be node’s children if node is a DocumentFragment node; otherwise « node ».
-    Vector<JS::Handle<Node>> nodes;
+    Vector<GC::Root<Node>> nodes;
     if (is<DocumentFragment>(*node))
         nodes = node->children_as_vector();
     else
-        nodes.append(JS::make_handle(*node));
+        nodes.append(GC::make_root(*node));
 
     // 13. Insert node into parent before referenceChild with the suppress observers flag set.
     insert_before(node, reference_child, true);
@@ -995,12 +995,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::replace_child(JS::NonnullGCPtr
 }
 
 // https://dom.spec.whatwg.org/#concept-node-clone
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::clone_node(Document* document, bool clone_children)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::clone_node(Document* document, bool clone_children)
 {
     // 1. If document is not given, let document be node’s node document.
     if (!document)
         document = m_document.ptr();
-    JS::GCPtr<Node> copy;
+    GC::Ptr<Node> copy;
 
     // 2. If node is an element, then:
     if (is<Element>(this)) {
@@ -1109,11 +1109,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::clone_node(Document* document,
 
     // 7. Return copy.
     VERIFY(copy);
-    return JS::NonnullGCPtr { *copy };
+    return GC::Ref { *copy };
 }
 
 // https://dom.spec.whatwg.org/#dom-node-clonenode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> Node::clone_node_binding(bool deep)
+WebIDL::ExceptionOr<GC::Ref<Node>> Node::clone_node_binding(bool deep)
 {
     // 1. If this is a shadow root, then throw a "NotSupportedError" DOMException.
     if (is<ShadowRoot>(*this))
@@ -1144,7 +1144,7 @@ bool Node::is_editable() const
     return parent() && parent()->is_editable();
 }
 
-void Node::set_layout_node(Badge<Layout::Node>, JS::NonnullGCPtr<Layout::Node> layout_node)
+void Node::set_layout_node(Badge<Layout::Node>, GC::Ref<Layout::Node> layout_node)
 {
     m_layout_node = layout_node;
 }
@@ -1216,11 +1216,11 @@ Slottable Node::as_slottable()
     VERIFY(is_slottable());
 
     if (is_element())
-        return JS::NonnullGCPtr { static_cast<Element&>(*this) };
-    return JS::NonnullGCPtr { static_cast<Text&>(*this) };
+        return GC::Ref { static_cast<Element&>(*this) };
+    return GC::Ref { static_cast<Text&>(*this) };
 }
 
-JS::NonnullGCPtr<NodeList> Node::child_nodes()
+GC::Ref<NodeList> Node::child_nodes()
 {
     if (!m_child_nodes) {
         m_child_nodes = LiveNodeList::create(realm(), *this, LiveNodeList::Scope::Children, [](auto&) {
@@ -1230,12 +1230,12 @@ JS::NonnullGCPtr<NodeList> Node::child_nodes()
     return *m_child_nodes;
 }
 
-Vector<JS::Handle<Node>> Node::children_as_vector() const
+Vector<GC::Root<Node>> Node::children_as_vector() const
 {
-    Vector<JS::Handle<Node>> nodes;
+    Vector<GC::Root<Node>> nodes;
 
     for_each_child([&](auto& child) {
-        nodes.append(JS::make_handle(child));
+        nodes.append(GC::make_root(child));
         return IterationDecision::Continue;
     });
 
@@ -1244,12 +1244,12 @@ Vector<JS::Handle<Node>> Node::children_as_vector() const
 
 void Node::remove_all_children(bool suppress_observers)
 {
-    while (JS::GCPtr<Node> child = first_child())
+    while (GC::Ptr<Node> child = first_child())
         child->remove(suppress_observers);
 }
 
 // https://dom.spec.whatwg.org/#dom-node-comparedocumentposition
-u16 Node::compare_document_position(JS::GCPtr<Node> other)
+u16 Node::compare_document_position(GC::Ptr<Node> other)
 {
     // 1. If this is other, then return zero.
     if (this == other.ptr())
@@ -1356,7 +1356,7 @@ bool Node::is_host_including_inclusive_ancestor_of(Node const& other) const
 }
 
 // https://dom.spec.whatwg.org/#dom-node-ownerdocument
-JS::GCPtr<Document> Node::owner_document() const
+GC::Ptr<Document> Node::owner_document() const
 {
     // The ownerDocument getter steps are to return null, if this is a document; otherwise this’s node document.
     if (is_document())
@@ -1468,7 +1468,7 @@ bool Node::is_scripting_disabled() const
 }
 
 // https://dom.spec.whatwg.org/#dom-node-contains
-bool Node::contains(JS::GCPtr<Node> other) const
+bool Node::contains(GC::Ptr<Node> other) const
 {
     // The contains(other) method steps are to return true if other is an inclusive descendant of this; otherwise false (including when other is null).
     return other && other->is_inclusive_descendant_of(*this);
@@ -1513,13 +1513,13 @@ bool Node::is_shadow_including_inclusive_ancestor_of(Node const& other) const
 }
 
 // https://dom.spec.whatwg.org/#concept-node-replace-all
-void Node::replace_all(JS::GCPtr<Node> node)
+void Node::replace_all(GC::Ptr<Node> node)
 {
     // 1. Let removedNodes be parent’s children.
     auto removed_nodes = children_as_vector();
 
     // 2. Let addedNodes be the empty set.
-    Vector<JS::Handle<Node>> added_nodes;
+    Vector<GC::Root<Node>> added_nodes;
 
     // 3. If node is a DocumentFragment node, then set addedNodes to node’s children.
     if (node && is<DocumentFragment>(*node)) {
@@ -1527,7 +1527,7 @@ void Node::replace_all(JS::GCPtr<Node> node)
     }
     // 4. Otherwise, if node is non-null, set addedNodes to « node ».
     else if (node) {
-        added_nodes.append(JS::make_handle(*node));
+        added_nodes.append(GC::make_root(*node));
     }
 
     // 5. Remove all parent’s children, in tree order, with the suppress observers flag set.
@@ -1547,7 +1547,7 @@ void Node::replace_all(JS::GCPtr<Node> node)
 void Node::string_replace_all(String const& string)
 {
     // 1. Let node be null.
-    JS::GCPtr<Node> node;
+    GC::Ptr<Node> node;
 
     // 2. If string is not the empty string, then set node to a new Text node whose data is string and node document is parent’s node document.
     if (!string.is_empty())
@@ -1881,7 +1881,7 @@ bool Node::in_a_document_tree() const
 }
 
 // https://dom.spec.whatwg.org/#dom-node-getrootnode
-JS::NonnullGCPtr<Node> Node::get_root_node(GetRootNodeOptions const& options)
+GC::Ref<Node> Node::get_root_node(GetRootNodeOptions const& options)
 {
     // The getRootNode(options) method steps are to return this’s shadow-including root if options["composed"] is true;
     if (options.composed)
@@ -1920,7 +1920,7 @@ size_t Node::length() const
     return child_count();
 }
 
-void Node::set_paintable(JS::GCPtr<Painting::Paintable> paintable)
+void Node::set_paintable(GC::Ptr<Painting::Paintable> paintable)
 {
     m_paintable = paintable;
 }
@@ -1955,11 +1955,11 @@ Painting::PaintableBox* Node::paintable_box()
 }
 
 // https://dom.spec.whatwg.org/#queue-a-mutation-record
-void Node::queue_mutation_record(FlyString const& type, Optional<FlyString> const& attribute_name, Optional<FlyString> const& attribute_namespace, Optional<String> const& old_value, Vector<JS::Handle<Node>> added_nodes, Vector<JS::Handle<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling) const
+void Node::queue_mutation_record(FlyString const& type, Optional<FlyString> const& attribute_name, Optional<FlyString> const& attribute_namespace, Optional<String> const& old_value, Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling) const
 {
     // NOTE: We defer garbage collection until the end of the scope, since we can't safely use MutationObserver* as a hashmap key otherwise.
     // FIXME: This is a total hack.
-    JS::DeferGC defer_gc(heap());
+    GC::DeferGC defer_gc(heap());
 
     // 1. Let interestedObservers be an empty map.
     // mutationObserver -> mappedOldValue
@@ -2030,7 +2030,7 @@ void Node::queue_mutation_record(FlyString const& type, Optional<FlyString> cons
 }
 
 // https://dom.spec.whatwg.org/#queue-a-tree-mutation-record
-void Node::queue_tree_mutation_record(Vector<JS::Handle<Node>> added_nodes, Vector<JS::Handle<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling)
+void Node::queue_tree_mutation_record(Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling)
 {
     // 1. Assert: either addedNodes or removedNodes is not empty.
     VERIFY(added_nodes.size() > 0 || removed_nodes.size() > 0);
@@ -2039,7 +2039,7 @@ void Node::queue_tree_mutation_record(Vector<JS::Handle<Node>> added_nodes, Vect
     queue_mutation_record(MutationType::childList, {}, {}, {}, move(added_nodes), move(removed_nodes), previous_sibling, next_sibling);
 }
 
-void Node::append_child_impl(JS::NonnullGCPtr<Node> node)
+void Node::append_child_impl(GC::Ref<Node> node)
 {
     VERIFY(!node->m_parent);
 
@@ -2055,7 +2055,7 @@ void Node::append_child_impl(JS::NonnullGCPtr<Node> node)
         m_first_child = m_last_child;
 }
 
-void Node::insert_before_impl(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child)
+void Node::insert_before_impl(GC::Ref<Node> node, GC::Ptr<Node> child)
 {
     if (!child)
         return append_child_impl(move(node));
@@ -2077,7 +2077,7 @@ void Node::insert_before_impl(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child
     node->m_parent = this;
 }
 
-void Node::remove_child_impl(JS::NonnullGCPtr<Node> node)
+void Node::remove_child_impl(GC::Ref<Node> node)
 {
     VERIFY(node->m_parent.ptr() == this);
 
@@ -2243,7 +2243,7 @@ ErrorOr<String> Node::name_or_description(NameOrDescription target, Document con
         // another widget, where the user can adjust the embedded control's value, then
         // return the embedded control as part of the text alternative in the following
         // manner:
-        JS::GCPtr<DOM::NodeList> labels;
+        GC::Ptr<DOM::NodeList> labels;
         if (is<HTML::HTMLElement>(this))
             labels = (const_cast<HTML::HTMLElement&>(static_cast<HTML::HTMLElement const&>(*current_node))).labels();
         if (labels != nullptr && labels->length() > 0) {
@@ -2475,7 +2475,7 @@ Optional<StringView> Node::first_valid_id(StringView value, Document const& docu
 void Node::add_registered_observer(RegisteredObserver& registered_observer)
 {
     if (!m_registered_observer_list)
-        m_registered_observer_list = make<Vector<JS::NonnullGCPtr<RegisteredObserver>>>();
+        m_registered_observer_list = make<Vector<GC::Ref<RegisteredObserver>>>();
     m_registered_observer_list->append(registered_observer);
 }
 
diff --git a/Libraries/LibWeb/DOM/Node.h b/Libraries/LibWeb/DOM/Node.h
index 7859b9d6d49..a6c8ec9e69f 100644
--- a/Libraries/LibWeb/DOM/Node.h
+++ b/Libraries/LibWeb/DOM/Node.h
@@ -164,13 +164,13 @@ public:
     virtual bool is_navigable_container() const { return false; }
     virtual bool is_lazy_loading() const { return false; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> pre_insert(JS::NonnullGCPtr<Node>, JS::GCPtr<Node>);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> pre_remove(JS::NonnullGCPtr<Node>);
+    WebIDL::ExceptionOr<GC::Ref<Node>> pre_insert(GC::Ref<Node>, GC::Ptr<Node>);
+    WebIDL::ExceptionOr<GC::Ref<Node>> pre_remove(GC::Ref<Node>);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> append_child(JS::NonnullGCPtr<Node>);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> remove_child(JS::NonnullGCPtr<Node>);
+    WebIDL::ExceptionOr<GC::Ref<Node>> append_child(GC::Ref<Node>);
+    WebIDL::ExceptionOr<GC::Ref<Node>> remove_child(GC::Ref<Node>);
 
-    void insert_before(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child, bool suppress_observers = false);
+    void insert_before(GC::Ref<Node> node, GC::Ptr<Node> child, bool suppress_observers = false);
     void remove(bool suppress_observers = false);
     void remove_all_children(bool suppress_observers = false);
 
@@ -184,17 +184,17 @@ public:
         DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32,
     };
 
-    u16 compare_document_position(JS::GCPtr<Node> other);
+    u16 compare_document_position(GC::Ptr<Node> other);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> replace_child(JS::NonnullGCPtr<Node> node, JS::NonnullGCPtr<Node> child);
+    WebIDL::ExceptionOr<GC::Ref<Node>> replace_child(GC::Ref<Node> node, GC::Ref<Node> child);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> clone_node(Document* document = nullptr, bool clone_children = false);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> clone_node_binding(bool deep);
+    WebIDL::ExceptionOr<GC::Ref<Node>> clone_node(Document* document = nullptr, bool clone_children = false);
+    WebIDL::ExceptionOr<GC::Ref<Node>> clone_node_binding(bool deep);
 
     // NOTE: This is intended for the JS bindings.
     bool has_child_nodes() const { return has_children(); }
-    JS::NonnullGCPtr<NodeList> child_nodes();
-    Vector<JS::Handle<Node>> children_as_vector() const;
+    GC::Ref<NodeList> child_nodes();
+    Vector<GC::Root<Node>> children_as_vector() const;
 
     virtual FlyString node_name() const = 0;
 
@@ -211,12 +211,12 @@ public:
     Optional<String> node_value() const;
     void set_node_value(Optional<String> const&);
 
-    JS::GCPtr<HTML::Navigable> navigable() const;
+    GC::Ptr<HTML::Navigable> navigable() const;
 
     Document& document() { return *m_document; }
     Document const& document() const { return *m_document; }
 
-    JS::GCPtr<Document> owner_document() const;
+    GC::Ptr<Document> owner_document() const;
 
     const HTML::HTMLAnchorElement* enclosing_link_element() const;
     const HTML::HTMLElement* enclosing_html_element() const;
@@ -260,10 +260,10 @@ public:
     Painting::Paintable const* paintable() const;
     Painting::Paintable* paintable();
 
-    void set_paintable(JS::GCPtr<Painting::Paintable>);
+    void set_paintable(GC::Ptr<Painting::Paintable>);
     void clear_paintable();
 
-    void set_layout_node(Badge<Layout::Node>, JS::NonnullGCPtr<Layout::Node>);
+    void set_layout_node(Badge<Layout::Node>, GC::Ref<Layout::Node>);
     void detach_layout_node(Badge<Layout::TreeBuilder>);
 
     virtual bool is_child_allowed(Node const&) const { return true; }
@@ -283,14 +283,14 @@ public:
     template<typename T>
     bool fast_is() const = delete;
 
-    WebIDL::ExceptionOr<void> ensure_pre_insertion_validity(JS::NonnullGCPtr<Node> node, JS::GCPtr<Node> child) const;
+    WebIDL::ExceptionOr<void> ensure_pre_insertion_validity(GC::Ref<Node> node, GC::Ptr<Node> child) const;
 
     bool is_host_including_inclusive_ancestor_of(Node const&) const;
 
     bool is_scripting_enabled() const;
     bool is_scripting_disabled() const;
 
-    bool contains(JS::GCPtr<Node>) const;
+    bool contains(GC::Ptr<Node>) const;
 
     // Used for dumping the DOM Tree
     void serialize_tree_as_json(JsonObjectSerializer<StringBuilder>&) const;
@@ -307,13 +307,13 @@ public:
 
     WebIDL::ExceptionOr<void> unsafely_set_html(Element&, StringView);
 
-    void replace_all(JS::GCPtr<Node>);
+    void replace_all(GC::Ptr<Node>);
     void string_replace_all(String const&);
 
     bool is_same_node(Node const*) const;
     bool is_equal_node(Node const*) const;
 
-    JS::NonnullGCPtr<Node> get_root_node(GetRootNodeOptions const& options = {});
+    GC::Ref<Node> get_root_node(GetRootNodeOptions const& options = {});
 
     bool is_uninteresting_whitespace_node() const;
 
@@ -326,7 +326,7 @@ public:
 
     void add_registered_observer(RegisteredObserver&);
 
-    void queue_mutation_record(FlyString const& type, Optional<FlyString> const& attribute_name, Optional<FlyString> const& attribute_namespace, Optional<String> const& old_value, Vector<JS::Handle<Node>> added_nodes, Vector<JS::Handle<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling) const;
+    void queue_mutation_record(FlyString const& type, Optional<FlyString> const& attribute_name, Optional<FlyString> const& attribute_namespace, Optional<String> const& old_value, Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling) const;
 
     // https://dom.spec.whatwg.org/#concept-shadow-including-inclusive-descendant
     template<typename Callback>
@@ -770,9 +770,9 @@ protected:
     virtual void visit_edges(Cell::Visitor&) override;
     virtual void finalize() override;
 
-    JS::GCPtr<Document> m_document;
-    JS::GCPtr<Layout::Node> m_layout_node;
-    JS::GCPtr<Painting::Paintable> m_paintable;
+    GC::Ptr<Document> m_document;
+    GC::Ptr<Layout::Node> m_layout_node;
+    GC::Ptr<Painting::Paintable> m_paintable;
     NodeType m_type { NodeType::INVALID };
     bool m_needs_style_update { false };
     bool m_child_needs_style_update { false };
@@ -781,28 +781,28 @@ protected:
 
     // https://dom.spec.whatwg.org/#registered-observer-list
     // "Nodes have a strong reference to registered observers in their registered observer list." https://dom.spec.whatwg.org/#garbage-collection
-    OwnPtr<Vector<JS::NonnullGCPtr<RegisteredObserver>>> m_registered_observer_list;
+    OwnPtr<Vector<GC::Ref<RegisteredObserver>>> m_registered_observer_list;
 
     void build_accessibility_tree(AccessibilityTreeNode& parent);
 
     ErrorOr<String> name_or_description(NameOrDescription, Document const&, HashTable<UniqueNodeID>&, IsDescendant = IsDescendant::No) const;
 
 private:
-    void queue_tree_mutation_record(Vector<JS::Handle<Node>> added_nodes, Vector<JS::Handle<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling);
+    void queue_tree_mutation_record(Vector<GC::Root<Node>> added_nodes, Vector<GC::Root<Node>> removed_nodes, Node* previous_sibling, Node* next_sibling);
 
-    void insert_before_impl(JS::NonnullGCPtr<Node>, JS::GCPtr<Node> child);
-    void append_child_impl(JS::NonnullGCPtr<Node>);
-    void remove_child_impl(JS::NonnullGCPtr<Node>);
+    void insert_before_impl(GC::Ref<Node>, GC::Ptr<Node> child);
+    void append_child_impl(GC::Ref<Node>);
+    void remove_child_impl(GC::Ref<Node>);
 
     static Optional<StringView> first_valid_id(StringView, Document const&);
 
-    JS::GCPtr<Node> m_parent;
-    JS::GCPtr<Node> m_first_child;
-    JS::GCPtr<Node> m_last_child;
-    JS::GCPtr<Node> m_next_sibling;
-    JS::GCPtr<Node> m_previous_sibling;
+    GC::Ptr<Node> m_parent;
+    GC::Ptr<Node> m_first_child;
+    GC::Ptr<Node> m_last_child;
+    GC::Ptr<Node> m_next_sibling;
+    GC::Ptr<Node> m_previous_sibling;
 
-    JS::GCPtr<NodeList> m_child_nodes;
+    GC::Ptr<NodeList> m_child_nodes;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/NodeFilter.cpp b/Libraries/LibWeb/DOM/NodeFilter.cpp
index 46fdfa6b249..3e8edb0b5f2 100644
--- a/Libraries/LibWeb/DOM/NodeFilter.cpp
+++ b/Libraries/LibWeb/DOM/NodeFilter.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(NodeFilter);
+GC_DEFINE_ALLOCATOR(NodeFilter);
 
-JS::NonnullGCPtr<NodeFilter> NodeFilter::create(JS::Realm& realm, WebIDL::CallbackType& callback)
+GC::Ref<NodeFilter> NodeFilter::create(JS::Realm& realm, WebIDL::CallbackType& callback)
 {
     return realm.create<NodeFilter>(realm, callback);
 }
diff --git a/Libraries/LibWeb/DOM/NodeFilter.h b/Libraries/LibWeb/DOM/NodeFilter.h
index bde4fb549ec..6d0425e225c 100644
--- a/Libraries/LibWeb/DOM/NodeFilter.h
+++ b/Libraries/LibWeb/DOM/NodeFilter.h
@@ -13,10 +13,10 @@ namespace Web::DOM {
 
 class NodeFilter final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NodeFilter, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NodeFilter);
+    GC_DECLARE_ALLOCATOR(NodeFilter);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NodeFilter> create(JS::Realm&, WebIDL::CallbackType&);
+    [[nodiscard]] static GC::Ref<NodeFilter> create(JS::Realm&, WebIDL::CallbackType&);
 
     virtual ~NodeFilter() = default;
 
@@ -47,7 +47,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<WebIDL::CallbackType> m_callback;
+    GC::Ref<WebIDL::CallbackType> m_callback;
 };
 
 AK_ENUM_BITWISE_OPERATORS(NodeFilter::WhatToShow);
diff --git a/Libraries/LibWeb/DOM/NodeIterator.cpp b/Libraries/LibWeb/DOM/NodeIterator.cpp
index eb04c38a3ec..67498325950 100644
--- a/Libraries/LibWeb/DOM/NodeIterator.cpp
+++ b/Libraries/LibWeb/DOM/NodeIterator.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(NodeIterator);
+GC_DEFINE_ALLOCATOR(NodeIterator);
 
 NodeIterator::NodeIterator(Node& root)
     : PlatformObject(root.realm())
@@ -48,7 +48,7 @@ void NodeIterator::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createnodeiterator
-WebIDL::ExceptionOr<JS::NonnullGCPtr<NodeIterator>> NodeIterator::create(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter> filter)
+WebIDL::ExceptionOr<GC::Ref<NodeIterator>> NodeIterator::create(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter> filter)
 {
     // 1. Let iterator be a new NodeIterator object.
     // 2. Set iterator’s root and iterator’s reference to root.
@@ -74,13 +74,13 @@ void NodeIterator::detach()
 }
 
 // https://dom.spec.whatwg.org/#concept-nodeiterator-traverse
-JS::ThrowCompletionOr<JS::GCPtr<Node>> NodeIterator::traverse(Direction direction)
+JS::ThrowCompletionOr<GC::Ptr<Node>> NodeIterator::traverse(Direction direction)
 {
     // 1. Let node be iterator’s reference.
     // 2. Let beforeNode be iterator’s pointer before reference.
     m_traversal_pointer = m_reference;
 
-    JS::GCPtr<Node> candidate;
+    GC::Ptr<Node> candidate;
 
     // 3. While true:
     while (true) {
@@ -175,13 +175,13 @@ JS::ThrowCompletionOr<NodeFilter::Result> NodeIterator::filter(Node& node)
 }
 
 // https://dom.spec.whatwg.org/#dom-nodeiterator-nextnode
-JS::ThrowCompletionOr<JS::GCPtr<Node>> NodeIterator::next_node()
+JS::ThrowCompletionOr<GC::Ptr<Node>> NodeIterator::next_node()
 {
     return traverse(Direction::Next);
 }
 
 // https://dom.spec.whatwg.org/#dom-nodeiterator-previousnode
-JS::ThrowCompletionOr<JS::GCPtr<Node>> NodeIterator::previous_node()
+JS::ThrowCompletionOr<GC::Ptr<Node>> NodeIterator::previous_node()
 {
     return traverse(Direction::Previous);
 }
diff --git a/Libraries/LibWeb/DOM/NodeIterator.h b/Libraries/LibWeb/DOM/NodeIterator.h
index 61097991b6a..66bb4fcb552 100644
--- a/Libraries/LibWeb/DOM/NodeIterator.h
+++ b/Libraries/LibWeb/DOM/NodeIterator.h
@@ -14,22 +14,22 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#nodeiterator
 class NodeIterator final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NodeIterator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NodeIterator);
+    GC_DECLARE_ALLOCATOR(NodeIterator);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<NodeIterator>> create(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
+    static WebIDL::ExceptionOr<GC::Ref<NodeIterator>> create(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter>);
 
     virtual ~NodeIterator() override;
 
-    JS::NonnullGCPtr<Node> root() { return m_root; }
-    JS::NonnullGCPtr<Node> reference_node() { return m_reference.node; }
+    GC::Ref<Node> root() { return m_root; }
+    GC::Ref<Node> reference_node() { return m_reference.node; }
     bool pointer_before_reference_node() const { return m_reference.is_before_node; }
     unsigned what_to_show() const { return m_what_to_show; }
 
     NodeFilter* filter() { return m_filter.ptr(); }
 
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> next_node();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> previous_node();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> next_node();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> previous_node();
 
     void detach();
 
@@ -47,15 +47,15 @@ private:
         Previous,
     };
 
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> traverse(Direction);
+    JS::ThrowCompletionOr<GC::Ptr<Node>> traverse(Direction);
 
     JS::ThrowCompletionOr<NodeFilter::Result> filter(Node&);
 
     // https://dom.spec.whatwg.org/#concept-traversal-root
-    JS::NonnullGCPtr<Node> m_root;
+    GC::Ref<Node> m_root;
 
     struct NodePointer {
-        JS::NonnullGCPtr<Node> node;
+        GC::Ref<Node> node;
 
         // https://dom.spec.whatwg.org/#nodeiterator-pointer-before-reference
         bool is_before_node { true };
@@ -74,7 +74,7 @@ private:
     unsigned m_what_to_show { 0 };
 
     // https://dom.spec.whatwg.org/#concept-traversal-filter
-    JS::GCPtr<NodeFilter> m_filter;
+    GC::Ptr<NodeFilter> m_filter;
 
     // https://dom.spec.whatwg.org/#concept-traversal-active
     bool m_active { false };
diff --git a/Libraries/LibWeb/DOM/NodeOperations.cpp b/Libraries/LibWeb/DOM/NodeOperations.cpp
index ee16efdc577..b6299660b2f 100644
--- a/Libraries/LibWeb/DOM/NodeOperations.cpp
+++ b/Libraries/LibWeb/DOM/NodeOperations.cpp
@@ -15,7 +15,7 @@
 namespace Web::DOM {
 
 // https://dom.spec.whatwg.org/#converting-nodes-into-a-node
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> convert_nodes_to_single_node(Vector<Variant<JS::Handle<Node>, String>> const& nodes, DOM::Document& document)
+WebIDL::ExceptionOr<GC::Ref<Node>> convert_nodes_to_single_node(Vector<Variant<GC::Root<Node>, String>> const& nodes, DOM::Document& document)
 {
     // 1. Let node be null.
     // 2. Replace each string in nodes with a new Text node whose data is the string and node document is document.
@@ -23,9 +23,9 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> convert_nodes_to_single_node(Vector<
     // 4. Otherwise, set node to a new DocumentFragment node whose node document is document, and then append each node in nodes, if any, to it.
     // 5. Return node.
 
-    auto potentially_convert_string_to_text_node = [&document](Variant<JS::Handle<Node>, String> const& node) -> JS::NonnullGCPtr<Node> {
-        if (node.has<JS::Handle<Node>>())
-            return *node.get<JS::Handle<Node>>();
+    auto potentially_convert_string_to_text_node = [&document](Variant<GC::Root<Node>, String> const& node) -> GC::Ref<Node> {
+        if (node.has<GC::Root<Node>>())
+            return *node.get<GC::Root<Node>>();
 
         return document.realm().create<DOM::Text>(document, node.get<String>());
     };
diff --git a/Libraries/LibWeb/DOM/NodeOperations.h b/Libraries/LibWeb/DOM/NodeOperations.h
index 6d8280c5827..b493e4b09b6 100644
--- a/Libraries/LibWeb/DOM/NodeOperations.h
+++ b/Libraries/LibWeb/DOM/NodeOperations.h
@@ -7,12 +7,12 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::DOM {
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Node>> convert_nodes_to_single_node(Vector<Variant<JS::Handle<Node>, String>> const& nodes, DOM::Document& document);
+WebIDL::ExceptionOr<GC::Ref<Node>> convert_nodes_to_single_node(Vector<Variant<GC::Root<Node>, String>> const& nodes, DOM::Document& document);
 
 }
diff --git a/Libraries/LibWeb/DOM/NonElementParentNode.h b/Libraries/LibWeb/DOM/NonElementParentNode.h
index 3a002a4c188..57268356128 100644
--- a/Libraries/LibWeb/DOM/NonElementParentNode.h
+++ b/Libraries/LibWeb/DOM/NonElementParentNode.h
@@ -8,7 +8,7 @@
 
 #include <AK/FlyString.h>
 #include <AK/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/AttributeNames.h>
 #include <LibWeb/TreeNode.h>
@@ -18,9 +18,9 @@ namespace Web::DOM {
 template<typename NodeType>
 class NonElementParentNode {
 public:
-    JS::GCPtr<Element> get_element_by_id(FlyString const& id) const
+    GC::Ptr<Element> get_element_by_id(FlyString const& id) const
     {
-        JS::GCPtr<Element> found_element;
+        GC::Ptr<Element> found_element;
         const_cast<NodeType*>(static_cast<NodeType const*>(this))->template for_each_in_inclusive_subtree_of_type<Element>([&](auto& element) {
             if (element.id() == id) {
                 found_element = &element;
diff --git a/Libraries/LibWeb/DOM/ParentNode.cpp b/Libraries/LibWeb/DOM/ParentNode.cpp
index 526e74e256c..1932c78c9b8 100644
--- a/Libraries/LibWeb/DOM/ParentNode.cpp
+++ b/Libraries/LibWeb/DOM/ParentNode.cpp
@@ -21,14 +21,14 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(ParentNode);
+GC_DEFINE_ALLOCATOR(ParentNode);
 
 enum class ReturnMatches {
     First,
     All,
 };
 // https://dom.spec.whatwg.org/#scope-match-a-selectors-string
-static WebIDL::ExceptionOr<Variant<JS::GCPtr<Element>, JS::NonnullGCPtr<NodeList>>> scope_match_a_selectors_string(ParentNode& node, StringView selector_text, ReturnMatches return_matches)
+static WebIDL::ExceptionOr<Variant<GC::Ptr<Element>, GC::Ref<NodeList>>> scope_match_a_selectors_string(ParentNode& node, StringView selector_text, ReturnMatches return_matches)
 {
     // To scope-match a selectors string selectors against a node, run these steps:
     // 1. Let s be the result of parse a selector selectors.
@@ -41,8 +41,8 @@ static WebIDL::ExceptionOr<Variant<JS::GCPtr<Element>, JS::NonnullGCPtr<NodeList
     auto selectors = maybe_selectors.value();
 
     // 3. Return the result of match a selector against a tree with s and node’s root using scoping root node.
-    JS::GCPtr<Element> single_result;
-    Vector<JS::Handle<Node>> results;
+    GC::Ptr<Element> single_result;
+    Vector<GC::Root<Node>> results;
     // FIXME: This should be shadow-including. https://drafts.csswg.org/selectors-4/#match-a-selector-against-a-tree
     node.for_each_in_subtree_of_type<Element>([&](auto& element) {
         for (auto& selector : selectors) {
@@ -64,26 +64,26 @@ static WebIDL::ExceptionOr<Variant<JS::GCPtr<Element>, JS::NonnullGCPtr<NodeList
 }
 
 // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
-WebIDL::ExceptionOr<JS::GCPtr<Element>> ParentNode::query_selector(StringView selector_text)
+WebIDL::ExceptionOr<GC::Ptr<Element>> ParentNode::query_selector(StringView selector_text)
 {
     // The querySelector(selectors) method steps are to return the first result of running scope-match a selectors string selectors against this,
     // if the result is not an empty list; otherwise null.
-    return TRY(scope_match_a_selectors_string(*this, selector_text, ReturnMatches::First)).get<JS::GCPtr<Element>>();
+    return TRY(scope_match_a_selectors_string(*this, selector_text, ReturnMatches::First)).get<GC::Ptr<Element>>();
 }
 
 // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
-WebIDL::ExceptionOr<JS::NonnullGCPtr<NodeList>> ParentNode::query_selector_all(StringView selector_text)
+WebIDL::ExceptionOr<GC::Ref<NodeList>> ParentNode::query_selector_all(StringView selector_text)
 {
     // The querySelectorAll(selectors) method steps are to return the static result of running scope-match a selectors string selectors against this.
-    return TRY(scope_match_a_selectors_string(*this, selector_text, ReturnMatches::All)).get<JS::NonnullGCPtr<NodeList>>();
+    return TRY(scope_match_a_selectors_string(*this, selector_text, ReturnMatches::All)).get<GC::Ref<NodeList>>();
 }
 
-JS::GCPtr<Element> ParentNode::first_element_child()
+GC::Ptr<Element> ParentNode::first_element_child()
 {
     return first_child_of_type<Element>();
 }
 
-JS::GCPtr<Element> ParentNode::last_element_child()
+GC::Ptr<Element> ParentNode::last_element_child()
 {
     return last_child_of_type<Element>();
 }
@@ -106,7 +106,7 @@ void ParentNode::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-parentnode-children
-JS::NonnullGCPtr<HTMLCollection> ParentNode::children()
+GC::Ref<HTMLCollection> ParentNode::children()
 {
     // The children getter steps are to return an HTMLCollection collection rooted at this matching only element children.
     if (!m_children) {
@@ -119,7 +119,7 @@ JS::NonnullGCPtr<HTMLCollection> ParentNode::children()
 
 // https://dom.spec.whatwg.org/#concept-getelementsbytagname
 // NOTE: This method is only exposed on Document and Element, but is in ParentNode to prevent code duplication.
-JS::NonnullGCPtr<HTMLCollection> ParentNode::get_elements_by_tag_name(FlyString const& qualified_name)
+GC::Ref<HTMLCollection> ParentNode::get_elements_by_tag_name(FlyString const& qualified_name)
 {
     // 1. If qualifiedName is "*" (U+002A), return a HTMLCollection rooted at root, whose filter matches only descendant elements.
     if (qualified_name == "*") {
@@ -149,7 +149,7 @@ JS::NonnullGCPtr<HTMLCollection> ParentNode::get_elements_by_tag_name(FlyString
 
 // https://dom.spec.whatwg.org/#concept-getelementsbytagnamens
 // NOTE: This method is only exposed on Document and Element, but is in ParentNode to prevent code duplication.
-JS::NonnullGCPtr<HTMLCollection> ParentNode::get_elements_by_tag_name_ns(Optional<FlyString> namespace_, FlyString const& local_name)
+GC::Ref<HTMLCollection> ParentNode::get_elements_by_tag_name_ns(Optional<FlyString> namespace_, FlyString const& local_name)
 {
     // 1. If namespace is the empty string, set it to null.
     if (namespace_ == FlyString {})
@@ -183,7 +183,7 @@ JS::NonnullGCPtr<HTMLCollection> ParentNode::get_elements_by_tag_name_ns(Optiona
 }
 
 // https://dom.spec.whatwg.org/#dom-parentnode-prepend
-WebIDL::ExceptionOr<void> ParentNode::prepend(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+WebIDL::ExceptionOr<void> ParentNode::prepend(Vector<Variant<GC::Root<Node>, String>> const& nodes)
 {
     // 1. Let node be the result of converting nodes into a node given nodes and this’s node document.
     auto node = TRY(convert_nodes_to_single_node(nodes, document()));
@@ -194,7 +194,7 @@ WebIDL::ExceptionOr<void> ParentNode::prepend(Vector<Variant<JS::Handle<Node>, S
     return {};
 }
 
-WebIDL::ExceptionOr<void> ParentNode::append(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+WebIDL::ExceptionOr<void> ParentNode::append(Vector<Variant<GC::Root<Node>, String>> const& nodes)
 {
     // 1. Let node be the result of converting nodes into a node given nodes and this’s node document.
     auto node = TRY(convert_nodes_to_single_node(nodes, document()));
@@ -205,7 +205,7 @@ WebIDL::ExceptionOr<void> ParentNode::append(Vector<Variant<JS::Handle<Node>, St
     return {};
 }
 
-WebIDL::ExceptionOr<void> ParentNode::replace_children(Vector<Variant<JS::Handle<Node>, String>> const& nodes)
+WebIDL::ExceptionOr<void> ParentNode::replace_children(Vector<Variant<GC::Root<Node>, String>> const& nodes)
 {
     // 1. Let node be the result of converting nodes into a node given nodes and this’s node document.
     auto node = TRY(convert_nodes_to_single_node(nodes, document()));
@@ -219,7 +219,7 @@ WebIDL::ExceptionOr<void> ParentNode::replace_children(Vector<Variant<JS::Handle
 }
 
 // https://dom.spec.whatwg.org/#dom-document-getelementsbyclassname
-JS::NonnullGCPtr<HTMLCollection> ParentNode::get_elements_by_class_name(StringView class_names)
+GC::Ref<HTMLCollection> ParentNode::get_elements_by_class_name(StringView class_names)
 {
     Vector<FlyString> list_of_class_names;
     for (auto& name : class_names.split_view_if(Infra::is_ascii_whitespace)) {
diff --git a/Libraries/LibWeb/DOM/ParentNode.h b/Libraries/LibWeb/DOM/ParentNode.h
index 3f0279049fc..e0e2199d865 100644
--- a/Libraries/LibWeb/DOM/ParentNode.h
+++ b/Libraries/LibWeb/DOM/ParentNode.h
@@ -12,7 +12,7 @@ namespace Web::DOM {
 
 class ParentNode : public Node {
     WEB_PLATFORM_OBJECT(ParentNode, Node);
-    JS_DECLARE_ALLOCATOR(ParentNode);
+    GC_DECLARE_ALLOCATOR(ParentNode);
 
 public:
     template<typename F>
@@ -20,23 +20,23 @@ public:
     template<typename F>
     void for_each_child(F);
 
-    JS::GCPtr<Element> first_element_child();
-    JS::GCPtr<Element> last_element_child();
+    GC::Ptr<Element> first_element_child();
+    GC::Ptr<Element> last_element_child();
     u32 child_element_count() const;
 
-    WebIDL::ExceptionOr<JS::GCPtr<Element>> query_selector(StringView);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<NodeList>> query_selector_all(StringView);
+    WebIDL::ExceptionOr<GC::Ptr<Element>> query_selector(StringView);
+    WebIDL::ExceptionOr<GC::Ref<NodeList>> query_selector_all(StringView);
 
-    JS::NonnullGCPtr<HTMLCollection> children();
+    GC::Ref<HTMLCollection> children();
 
-    JS::NonnullGCPtr<HTMLCollection> get_elements_by_tag_name(FlyString const&);
-    JS::NonnullGCPtr<HTMLCollection> get_elements_by_tag_name_ns(Optional<FlyString>, FlyString const&);
+    GC::Ref<HTMLCollection> get_elements_by_tag_name(FlyString const&);
+    GC::Ref<HTMLCollection> get_elements_by_tag_name_ns(Optional<FlyString>, FlyString const&);
 
-    WebIDL::ExceptionOr<void> prepend(Vector<Variant<JS::Handle<Node>, String>> const& nodes);
-    WebIDL::ExceptionOr<void> append(Vector<Variant<JS::Handle<Node>, String>> const& nodes);
-    WebIDL::ExceptionOr<void> replace_children(Vector<Variant<JS::Handle<Node>, String>> const& nodes);
+    WebIDL::ExceptionOr<void> prepend(Vector<Variant<GC::Root<Node>, String>> const& nodes);
+    WebIDL::ExceptionOr<void> append(Vector<Variant<GC::Root<Node>, String>> const& nodes);
+    WebIDL::ExceptionOr<void> replace_children(Vector<Variant<GC::Root<Node>, String>> const& nodes);
 
-    JS::NonnullGCPtr<HTMLCollection> get_elements_by_class_name(StringView);
+    GC::Ref<HTMLCollection> get_elements_by_class_name(StringView);
 
 protected:
     ParentNode(JS::Realm& realm, Document& document, NodeType type)
@@ -52,7 +52,7 @@ protected:
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
-    JS::GCPtr<HTMLCollection> m_children;
+    GC::Ptr<HTMLCollection> m_children;
 };
 
 template<>
diff --git a/Libraries/LibWeb/DOM/Position.cpp b/Libraries/LibWeb/DOM/Position.cpp
index 61d0d774d61..0c8c28840c4 100644
--- a/Libraries/LibWeb/DOM/Position.cpp
+++ b/Libraries/LibWeb/DOM/Position.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Position);
+GC_DEFINE_ALLOCATOR(Position);
 
-Position::Position(JS::GCPtr<Node> node, unsigned offset)
+Position::Position(GC::Ptr<Node> node, unsigned offset)
     : m_node(node)
     , m_offset(offset)
 {
diff --git a/Libraries/LibWeb/DOM/Position.h b/Libraries/LibWeb/DOM/Position.h
index 1ff7b9aa751..9464f695f5b 100644
--- a/Libraries/LibWeb/DOM/Position.h
+++ b/Libraries/LibWeb/DOM/Position.h
@@ -10,28 +10,28 @@
 #include <AK/Error.h>
 #include <AK/RefPtr.h>
 #include <AK/String.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/DOM/Node.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::DOM {
 
 class Position final : public JS::Cell {
-    JS_CELL(Position, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Position);
+    GC_CELL(Position, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Position);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Position> create(JS::Realm& realm, JS::NonnullGCPtr<Node> node, unsigned offset)
+    [[nodiscard]] static GC::Ref<Position> create(JS::Realm& realm, GC::Ref<Node> node, unsigned offset)
     {
         return realm.create<Position>(node, offset);
     }
 
-    JS::GCPtr<Node> node() { return m_node; }
-    JS::GCPtr<Node const> node() const { return m_node; }
+    GC::Ptr<Node> node() { return m_node; }
+    GC::Ptr<Node const> node() const { return m_node; }
 
     unsigned offset() const { return m_offset; }
 
-    bool equals(JS::NonnullGCPtr<Position> other) const
+    bool equals(GC::Ref<Position> other) const
     {
         return m_node.ptr() == other->m_node.ptr() && m_offset == other->m_offset;
     }
@@ -39,11 +39,11 @@ public:
     ErrorOr<String> to_string() const;
 
 private:
-    Position(JS::GCPtr<Node>, unsigned offset);
+    Position(GC::Ptr<Node>, unsigned offset);
 
     virtual void visit_edges(Visitor&) override;
 
-    JS::GCPtr<Node> m_node;
+    GC::Ptr<Node> m_node;
     unsigned m_offset { 0 };
 };
 
diff --git a/Libraries/LibWeb/DOM/ProcessingInstruction.cpp b/Libraries/LibWeb/DOM/ProcessingInstruction.cpp
index ae78db2ee27..7dd87e0b727 100644
--- a/Libraries/LibWeb/DOM/ProcessingInstruction.cpp
+++ b/Libraries/LibWeb/DOM/ProcessingInstruction.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(ProcessingInstruction);
+GC_DEFINE_ALLOCATOR(ProcessingInstruction);
 
 ProcessingInstruction::ProcessingInstruction(Document& document, String const& data, String const& target)
     : CharacterData(document, NodeType::PROCESSING_INSTRUCTION_NODE, data)
diff --git a/Libraries/LibWeb/DOM/ProcessingInstruction.h b/Libraries/LibWeb/DOM/ProcessingInstruction.h
index 9677956e9e3..f559c0ac186 100644
--- a/Libraries/LibWeb/DOM/ProcessingInstruction.h
+++ b/Libraries/LibWeb/DOM/ProcessingInstruction.h
@@ -12,7 +12,7 @@ namespace Web::DOM {
 
 class ProcessingInstruction final : public CharacterData {
     WEB_PLATFORM_OBJECT(ProcessingInstruction, CharacterData);
-    JS_DECLARE_ALLOCATOR(ProcessingInstruction);
+    GC_DECLARE_ALLOCATOR(ProcessingInstruction);
 
 public:
     virtual ~ProcessingInstruction() override = default;
diff --git a/Libraries/LibWeb/DOM/Range.cpp b/Libraries/LibWeb/DOM/Range.cpp
index 9f5507c2860..bb8a626d173 100644
--- a/Libraries/LibWeb/DOM/Range.cpp
+++ b/Libraries/LibWeb/DOM/Range.cpp
@@ -29,7 +29,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Range);
+GC_DEFINE_ALLOCATOR(Range);
 
 HashTable<Range*>& Range::live_ranges()
 {
@@ -37,24 +37,24 @@ HashTable<Range*>& Range::live_ranges()
     return ranges;
 }
 
-JS::NonnullGCPtr<Range> Range::create(HTML::Window& window)
+GC::Ref<Range> Range::create(HTML::Window& window)
 {
     return Range::create(window.associated_document());
 }
 
-JS::NonnullGCPtr<Range> Range::create(Document& document)
+GC::Ref<Range> Range::create(Document& document)
 {
     auto& realm = document.realm();
     return realm.create<Range>(document);
 }
 
-JS::NonnullGCPtr<Range> Range::create(Node& start_container, WebIDL::UnsignedLong start_offset, Node& end_container, WebIDL::UnsignedLong end_offset)
+GC::Ref<Range> Range::create(Node& start_container, WebIDL::UnsignedLong start_offset, Node& end_container, WebIDL::UnsignedLong end_offset)
 {
     auto& realm = start_container.realm();
     return realm.create<Range>(start_container, start_offset, end_container, end_offset);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Range>> Range::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<Range>> Range::construct_impl(JS::Realm& realm)
 {
     auto& window = verify_cast<HTML::Window>(realm.global_object());
     return Range::create(window);
@@ -88,7 +88,7 @@ void Range::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_associated_selection);
 }
 
-void Range::set_associated_selection(Badge<Selection::Selection>, JS::GCPtr<Selection::Selection> selection)
+void Range::set_associated_selection(Badge<Selection::Selection>, GC::Ptr<Selection::Selection> selection)
 {
     m_associated_selection = selection;
     update_associated_selection();
@@ -152,7 +152,7 @@ RelativeBoundaryPointPosition position_of_boundary_point_relative_to_other_bound
     // 4. If nodeA is an ancestor of nodeB:
     if (node_a.is_ancestor_of(node_b)) {
         // 1. Let child be nodeB.
-        JS::NonnullGCPtr<Node const> child = node_b;
+        GC::Ref<Node const> child = node_b;
 
         // 2. While child is not a child of nodeA, set child to its parent.
         while (!node_a.is_parent_of(child)) {
@@ -300,10 +300,10 @@ WebIDL::ExceptionOr<WebIDL::Short> Range::compare_boundary_points(WebIDL::Unsign
     if (&root() != &source_range.root())
         return WebIDL::WrongDocumentError::create(realm(), "This range is not in the same tree as the source range."_string);
 
-    JS::GCPtr<Node> this_point_node;
+    GC::Ptr<Node> this_point_node;
     u32 this_point_offset = 0;
 
-    JS::GCPtr<Node> other_point_node;
+    GC::Ptr<Node> other_point_node;
     u32 other_point_offset = 0;
 
     // 3. If how is:
@@ -439,17 +439,17 @@ WebIDL::ExceptionOr<void> Range::select_node_contents(Node& node)
     return {};
 }
 
-JS::NonnullGCPtr<Range> Range::clone_range() const
+GC::Ref<Range> Range::clone_range() const
 {
     return shape().realm().create<Range>(const_cast<Node&>(*m_start_container), m_start_offset, const_cast<Node&>(*m_end_container), m_end_offset);
 }
 
-JS::NonnullGCPtr<Range> Range::inverted() const
+GC::Ref<Range> Range::inverted() const
 {
     return shape().realm().create<Range>(const_cast<Node&>(*m_end_container), m_end_offset, const_cast<Node&>(*m_start_container), m_start_offset);
 }
 
-JS::NonnullGCPtr<Range> Range::normalized() const
+GC::Ref<Range> Range::normalized() const
 {
     if (m_start_container.ptr() == m_end_container.ptr()) {
         if (m_start_offset <= m_end_offset)
@@ -465,7 +465,7 @@ JS::NonnullGCPtr<Range> Range::normalized() const
 }
 
 // https://dom.spec.whatwg.org/#dom-range-commonancestorcontainer
-JS::NonnullGCPtr<Node> Range::common_ancestor_container() const
+GC::Ref<Node> Range::common_ancestor_container() const
 {
     // 1. Let container be start node.
     auto container = m_start_container;
@@ -597,13 +597,13 @@ String Range::to_string() const
 }
 
 // https://dom.spec.whatwg.org/#dom-range-extractcontents
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract_contents()
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> Range::extract_contents()
 {
     return extract();
 }
 
 // https://dom.spec.whatwg.org/#concept-range-extract
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> Range::extract()
 {
     // 1. Let fragment be a new DocumentFragment node whose node document is range’s start node’s node document.
     auto fragment = realm().create<DOM::DocumentFragment>(const_cast<Document&>(start_container()->document()));
@@ -614,9 +614,9 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
 
     // 3. Let original start node, original start offset, original end node, and original end offset
     //    be range’s start node, start offset, end node, and end offset, respectively.
-    JS::NonnullGCPtr<Node> original_start_node = m_start_container;
+    GC::Ref<Node> original_start_node = m_start_container;
     auto original_start_offset = m_start_offset;
-    JS::NonnullGCPtr<Node> original_end_node = m_end_container;
+    GC::Ref<Node> original_end_node = m_end_container;
     auto original_end_offset = m_end_offset;
 
     // 4. If original start node is original end node and it is a CharacterData node, then:
@@ -640,14 +640,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
     }
 
     // 5. Let common ancestor be original start node.
-    JS::NonnullGCPtr<Node> common_ancestor = original_start_node;
+    GC::Ref<Node> common_ancestor = original_start_node;
 
     // 6. While common ancestor is not an inclusive ancestor of original end node, set common ancestor to its own parent.
     while (!common_ancestor->is_inclusive_ancestor_of(original_end_node))
         common_ancestor = *common_ancestor->parent_node();
 
     // 7. Let first partially contained child be null.
-    JS::GCPtr<Node> first_partially_contained_child;
+    GC::Ptr<Node> first_partially_contained_child;
 
     // 8. If original start node is not an inclusive ancestor of original end node,
     //    set first partially contained child to the first child of common ancestor that is partially contained in range.
@@ -661,7 +661,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
     }
 
     // 9. Let last partially contained child be null.
-    JS::GCPtr<Node> last_partially_contained_child;
+    GC::Ptr<Node> last_partially_contained_child;
 
     // 10. If original end node is not an inclusive ancestor of original start node,
     //     set last partially contained child to the last child of common ancestor that is partially contained in range.
@@ -675,7 +675,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
     }
 
     // 11. Let contained children be a list of all children of common ancestor that are contained in range, in tree order.
-    Vector<JS::NonnullGCPtr<Node>> contained_children;
+    Vector<GC::Ref<Node>> contained_children;
     for (Node* node = common_ancestor->first_child(); node; node = node->next_sibling()) {
         if (contains_node(*node))
             contained_children.append(*node);
@@ -687,7 +687,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
             return WebIDL::HierarchyRequestError::create(realm(), "Contained child is a DocumentType"_string);
     }
 
-    JS::GCPtr<Node> new_node;
+    GC::Ptr<Node> new_node;
     size_t new_offset = 0;
 
     // 13. If original start node is an inclusive ancestor of original end node, set new node to original start node and new offset to original start offset.
@@ -698,7 +698,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::extract()
     // 14. Otherwise:
     else {
         // 1. Let reference node equal original start node.
-        JS::GCPtr<Node> reference_node = original_start_node;
+        GC::Ptr<Node> reference_node = original_start_node;
 
         // 2. While reference node’s parent is not null and is not an inclusive ancestor of original end node, set reference node to its parent.
         while (reference_node->parent_node() && !reference_node->parent_node()->is_inclusive_ancestor_of(original_end_node))
@@ -819,13 +819,13 @@ bool Range::partially_contains_node(Node const& node) const
 }
 
 // https://dom.spec.whatwg.org/#dom-range-insertnode
-WebIDL::ExceptionOr<void> Range::insert_node(JS::NonnullGCPtr<Node> node)
+WebIDL::ExceptionOr<void> Range::insert_node(GC::Ref<Node> node)
 {
     return insert(node);
 }
 
 // https://dom.spec.whatwg.org/#concept-range-insert
-WebIDL::ExceptionOr<void> Range::insert(JS::NonnullGCPtr<Node> node)
+WebIDL::ExceptionOr<void> Range::insert(GC::Ref<Node> node)
 {
     // 1. If range’s start node is a ProcessingInstruction or Comment node, is a Text node whose parent is null, or is node, then throw a "HierarchyRequestError" DOMException.
     if ((is<ProcessingInstruction>(*m_start_container) || is<Comment>(*m_start_container))
@@ -835,7 +835,7 @@ WebIDL::ExceptionOr<void> Range::insert(JS::NonnullGCPtr<Node> node)
     }
 
     // 2. Let referenceNode be null.
-    JS::GCPtr<Node> reference_node;
+    GC::Ptr<Node> reference_node;
 
     // 3. If range’s start node is a Text node, set referenceNode to that Text node.
     if (is<Text>(*m_start_container)) {
@@ -847,7 +847,7 @@ WebIDL::ExceptionOr<void> Range::insert(JS::NonnullGCPtr<Node> node)
     }
 
     // 5. Let parent be range’s start node if referenceNode is null, and referenceNode’s parent otherwise.
-    JS::GCPtr<Node> parent;
+    GC::Ptr<Node> parent;
     if (!reference_node)
         parent = m_start_container;
     else
@@ -892,7 +892,7 @@ WebIDL::ExceptionOr<void> Range::insert(JS::NonnullGCPtr<Node> node)
 }
 
 // https://dom.spec.whatwg.org/#dom-range-surroundcontents
-WebIDL::ExceptionOr<void> Range::surround_contents(JS::NonnullGCPtr<Node> new_parent)
+WebIDL::ExceptionOr<void> Range::surround_contents(GC::Ref<Node> new_parent)
 {
     // 1. If a non-Text node is partially contained in this, then throw an "InvalidStateError" DOMException.
     Node* start_non_text_node = start_container();
@@ -926,13 +926,13 @@ WebIDL::ExceptionOr<void> Range::surround_contents(JS::NonnullGCPtr<Node> new_pa
 }
 
 // https://dom.spec.whatwg.org/#dom-range-clonecontents
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_contents()
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> Range::clone_contents()
 {
     return clone_the_contents();
 }
 
 // https://dom.spec.whatwg.org/#concept-range-clone
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_contents()
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> Range::clone_the_contents()
 {
     // 1. Let fragment be a new DocumentFragment node whose node document is range’s start node’s node document.
     auto fragment = realm().create<DOM::DocumentFragment>(const_cast<Document&>(start_container()->document()));
@@ -943,9 +943,9 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
 
     // 3. Let original start node, original start offset, original end node, and original end offset
     //    be range’s start node, start offset, end node, and end offset, respectively.
-    JS::NonnullGCPtr<Node> original_start_node = m_start_container;
+    GC::Ref<Node> original_start_node = m_start_container;
     auto original_start_offset = m_start_offset;
-    JS::NonnullGCPtr<Node> original_end_node = m_end_container;
+    GC::Ref<Node> original_end_node = m_end_container;
     auto original_end_offset = m_end_offset;
 
     // 4. If original start node is original end node and it is a CharacterData node, then:
@@ -966,14 +966,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
     }
 
     // 5. Let common ancestor be original start node.
-    JS::NonnullGCPtr<Node> common_ancestor = original_start_node;
+    GC::Ref<Node> common_ancestor = original_start_node;
 
     // 6. While common ancestor is not an inclusive ancestor of original end node, set common ancestor to its own parent.
     while (!common_ancestor->is_inclusive_ancestor_of(original_end_node))
         common_ancestor = *common_ancestor->parent_node();
 
     // 7. Let first partially contained child be null.
-    JS::GCPtr<Node> first_partially_contained_child;
+    GC::Ptr<Node> first_partially_contained_child;
 
     // 8. If original start node is not an inclusive ancestor of original end node,
     //    set first partially contained child to the first child of common ancestor that is partially contained in range.
@@ -987,7 +987,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
     }
 
     // 9. Let last partially contained child be null.
-    JS::GCPtr<Node> last_partially_contained_child;
+    GC::Ptr<Node> last_partially_contained_child;
 
     // 10. If original end node is not an inclusive ancestor of original start node,
     //     set last partially contained child to the last child of common ancestor that is partially contained in range.
@@ -1001,7 +1001,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::clone_the_content
     }
 
     // 11. Let contained children be a list of all children of common ancestor that are contained in range, in tree order.
-    Vector<JS::NonnullGCPtr<Node>> contained_children;
+    Vector<GC::Ref<Node>> contained_children;
     for (Node* node = common_ancestor->first_child(); node; node = node->next_sibling()) {
         if (contains_node(*node))
             contained_children.append(*node);
@@ -1095,9 +1095,9 @@ WebIDL::ExceptionOr<void> Range::delete_contents()
         return {};
 
     // 2. Let original start node, original start offset, original end node, and original end offset be this’s start node, start offset, end node, and end offset, respectively.
-    JS::NonnullGCPtr<Node> original_start_node = m_start_container;
+    GC::Ref<Node> original_start_node = m_start_container;
     auto original_start_offset = m_start_offset;
-    JS::NonnullGCPtr<Node> original_end_node = m_end_container;
+    GC::Ref<Node> original_end_node = m_end_container;
     auto original_end_offset = m_end_offset;
 
     // 3. If original start node is original end node and it is a CharacterData node, then replace data with node original start node, offset original start offset,
@@ -1108,13 +1108,13 @@ WebIDL::ExceptionOr<void> Range::delete_contents()
     }
 
     // 4. Let nodes to remove be a list of all the nodes that are contained in this, in tree order, omitting any node whose parent is also contained in this.
-    JS::MarkedVector<Node*> nodes_to_remove(heap());
+    GC::MarkedVector<Node*> nodes_to_remove(heap());
     for (Node const* node = start_container(); node != end_container()->next_sibling(); node = node->next_in_pre_order()) {
         if (contains_node(*node) && (!node->parent_node() || !contains_node(*node->parent_node())))
             nodes_to_remove.append(const_cast<Node*>(node));
     }
 
-    JS::GCPtr<Node> new_node;
+    GC::Ptr<Node> new_node;
     size_t new_offset = 0;
 
     // 5. If original start node is an inclusive ancestor of original end node, set new node to original start node and new offset to original start offset.
@@ -1156,7 +1156,7 @@ WebIDL::ExceptionOr<void> Range::delete_contents()
 
 // https://drafts.csswg.org/cssom-view/#dom-element-getclientrects
 // https://drafts.csswg.org/cssom-view/#extensions-to-the-range-interface
-JS::NonnullGCPtr<Geometry::DOMRectList> Range::get_client_rects()
+GC::Ref<Geometry::DOMRectList> Range::get_client_rects()
 {
     // 1. return an empty DOMRectList object if the range is not in the document
     if (!start_container()->document().navigable())
@@ -1164,7 +1164,7 @@ JS::NonnullGCPtr<Geometry::DOMRectList> Range::get_client_rects()
 
     start_container()->document().update_layout();
     update_associated_selection();
-    Vector<JS::Handle<Geometry::DOMRect>> rects;
+    Vector<GC::Root<Geometry::DOMRect>> rects;
     // FIXME: take Range collapsed into consideration
     // 2. Iterate the node included in Range
     auto start_node = start_container();
@@ -1185,7 +1185,7 @@ JS::NonnullGCPtr<Geometry::DOMRectList> Range::get_client_rects()
             // areas returned by invoking getClientRects() on the element.
             if (contains_node(*node) && !contains_node(*node->parent())) {
                 auto const& element = static_cast<DOM::Element const&>(*node);
-                JS::NonnullGCPtr<Geometry::DOMRectList> const element_rects = element.get_client_rects();
+                GC::Ref<Geometry::DOMRectList> const element_rects = element.get_client_rects();
                 for (u32 i = 0; i < element_rects->length(); i++) {
                     auto rect = element_rects->item(i);
                     rects.append(Geometry::DOMRect::create(realm(),
@@ -1220,7 +1220,7 @@ JS::NonnullGCPtr<Geometry::DOMRectList> Range::get_client_rects()
 }
 
 // https://w3c.github.io/csswg-drafts/cssom-view/#dom-range-getboundingclientrect
-JS::NonnullGCPtr<Geometry::DOMRect> Range::get_bounding_client_rect()
+GC::Ref<Geometry::DOMRect> Range::get_bounding_client_rect()
 {
     // 1. Let list be the result of invoking getClientRects() on element.
     auto list = get_client_rects();
@@ -1239,7 +1239,7 @@ JS::NonnullGCPtr<Geometry::DOMRect> Range::get_bounding_client_rect()
         }
     }
     if (all_rectangle_has_zero_width_or_height)
-        return JS::NonnullGCPtr { *const_cast<Geometry::DOMRect*>(list->item(0)) };
+        return GC::Ref { *const_cast<Geometry::DOMRect*>(list->item(0)) };
 
     // 4. Otherwise, return a DOMRect object describing the smallest rectangle that includes all of the rectangles in
     //    list of which the height or width is not zero.
@@ -1255,15 +1255,15 @@ JS::NonnullGCPtr<Geometry::DOMRect> Range::get_bounding_client_rect()
 }
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-range-createcontextualfragment
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> Range::create_contextual_fragment(String const& string)
+WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> Range::create_contextual_fragment(String const& string)
 {
     // FIXME: 1. Let compliantString be the result of invoking the Get Trusted Type compliant string algorithm with TrustedHTML, this's relevant global object, string, "Range createContextualFragment", and "script".
 
     // 2. Let node be this's start node.
-    JS::NonnullGCPtr<Node> node = *start_container();
+    GC::Ref<Node> node = *start_container();
 
     // 3. Let element be null.
-    JS::GCPtr<Element> element = nullptr;
+    GC::Ptr<Element> element = nullptr;
 
     auto node_type = static_cast<NodeType>(node->node_type());
     // 4. If node implements Element, set element to node.
diff --git a/Libraries/LibWeb/DOM/Range.h b/Libraries/LibWeb/DOM/Range.h
index 33c6c657ab5..6f460da6865 100644
--- a/Libraries/LibWeb/DOM/Range.h
+++ b/Libraries/LibWeb/DOM/Range.h
@@ -25,13 +25,13 @@ RelativeBoundaryPointPosition position_of_boundary_point_relative_to_other_bound
 
 class Range final : public AbstractRange {
     WEB_PLATFORM_OBJECT(Range, AbstractRange);
-    JS_DECLARE_ALLOCATOR(Range);
+    GC_DECLARE_ALLOCATOR(Range);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Range> create(Document&);
-    [[nodiscard]] static JS::NonnullGCPtr<Range> create(HTML::Window&);
-    [[nodiscard]] static JS::NonnullGCPtr<Range> create(Node& start_container, WebIDL::UnsignedLong start_offset, Node& end_container, WebIDL::UnsignedLong end_offset);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Range>> construct_impl(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Range> create(Document&);
+    [[nodiscard]] static GC::Ref<Range> create(HTML::Window&);
+    [[nodiscard]] static GC::Ref<Range> create(Node& start_container, WebIDL::UnsignedLong start_offset, Node& end_container, WebIDL::UnsignedLong end_offset);
+    static WebIDL::ExceptionOr<GC::Ref<Range>> construct_impl(JS::Realm&);
 
     virtual ~Range() override;
 
@@ -60,11 +60,11 @@ public:
 
     WebIDL::ExceptionOr<WebIDL::Short> compare_boundary_points(WebIDL::UnsignedShort how, Range const& source_range) const;
 
-    JS::NonnullGCPtr<Range> inverted() const;
-    JS::NonnullGCPtr<Range> normalized() const;
-    JS::NonnullGCPtr<Range> clone_range() const;
+    GC::Ref<Range> inverted() const;
+    GC::Ref<Range> normalized() const;
+    GC::Ref<Range> clone_range() const;
 
-    JS::NonnullGCPtr<Node> common_ancestor_container() const;
+    GC::Ref<Node> common_ancestor_container() const;
 
     // https://dom.spec.whatwg.org/#dom-range-detach
     void detach() const
@@ -78,24 +78,24 @@ public:
     WebIDL::ExceptionOr<WebIDL::Short> compare_point(Node const&, WebIDL::UnsignedLong offset) const;
 
     WebIDL::ExceptionOr<void> delete_contents();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> extract_contents();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> clone_contents();
+    WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> extract_contents();
+    WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> clone_contents();
 
-    WebIDL::ExceptionOr<void> insert_node(JS::NonnullGCPtr<Node>);
-    WebIDL::ExceptionOr<void> surround_contents(JS::NonnullGCPtr<Node> new_parent);
+    WebIDL::ExceptionOr<void> insert_node(GC::Ref<Node>);
+    WebIDL::ExceptionOr<void> surround_contents(GC::Ref<Node> new_parent);
 
     String to_string() const;
 
     static HashTable<Range*>& live_ranges();
 
-    JS::NonnullGCPtr<Geometry::DOMRectList> get_client_rects();
-    JS::NonnullGCPtr<Geometry::DOMRect> get_bounding_client_rect();
+    GC::Ref<Geometry::DOMRectList> get_client_rects();
+    GC::Ref<Geometry::DOMRect> get_bounding_client_rect();
 
     bool contains_node(Node const&) const;
 
-    void set_associated_selection(Badge<Selection::Selection>, JS::GCPtr<Selection::Selection>);
+    void set_associated_selection(Badge<Selection::Selection>, GC::Ptr<Selection::Selection>);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> create_contextual_fragment(String const& fragment);
+    WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> create_contextual_fragment(String const& fragment);
 
 private:
     explicit Range(Document&);
@@ -117,13 +117,13 @@ private:
     WebIDL::ExceptionOr<void> set_start_or_end(Node& node, u32 offset, StartOrEnd start_or_end);
     WebIDL::ExceptionOr<void> select(Node& node);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> extract();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DocumentFragment>> clone_the_contents();
-    WebIDL::ExceptionOr<void> insert(JS::NonnullGCPtr<Node>);
+    WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> extract();
+    WebIDL::ExceptionOr<GC::Ref<DocumentFragment>> clone_the_contents();
+    WebIDL::ExceptionOr<void> insert(GC::Ref<Node>);
 
     bool partially_contains_node(Node const&) const;
 
-    JS::GCPtr<Selection::Selection> m_associated_selection;
+    GC::Ptr<Selection::Selection> m_associated_selection;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/SelectionchangeEventDispatching.h b/Libraries/LibWeb/DOM/SelectionchangeEventDispatching.h
index 11ab6427557..1657f605ec5 100644
--- a/Libraries/LibWeb/DOM/SelectionchangeEventDispatching.h
+++ b/Libraries/LibWeb/DOM/SelectionchangeEventDispatching.h
@@ -33,7 +33,7 @@ void schedule_a_selectionchange_event(T& target, Document& document)
 
     // 2. Queue a task on the user interaction task source to fire a selectionchange event on
     //    target.
-    queue_global_task(HTML::Task::Source::UserInteraction, relevant_global_object(document), JS::create_heap_function(document.heap(), [&] {
+    queue_global_task(HTML::Task::Source::UserInteraction, relevant_global_object(document), GC::create_function(document.heap(), [&] {
         fire_a_selectionchange_event(target, document);
     }));
 }
diff --git a/Libraries/LibWeb/DOM/ShadowRoot.cpp b/Libraries/LibWeb/DOM/ShadowRoot.cpp
index 22e8a26776d..690630e5501 100644
--- a/Libraries/LibWeb/DOM/ShadowRoot.cpp
+++ b/Libraries/LibWeb/DOM/ShadowRoot.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(ShadowRoot);
+GC_DEFINE_ALLOCATOR(ShadowRoot);
 
 ShadowRoot::ShadowRoot(Document& document, Element& host, Bindings::ShadowRootMode mode)
     : DocumentFragment(document)
@@ -138,7 +138,7 @@ void ShadowRoot::visit_edges(Visitor& visitor)
     visitor.visit(m_adopted_style_sheets);
 }
 
-JS::NonnullGCPtr<WebIDL::ObservableArray> ShadowRoot::adopted_style_sheets() const
+GC::Ref<WebIDL::ObservableArray> ShadowRoot::adopted_style_sheets() const
 {
     if (!m_adopted_style_sheets)
         m_adopted_style_sheets = create_adopted_style_sheets_list(const_cast<Document&>(document()));
@@ -174,9 +174,9 @@ void ShadowRoot::for_each_css_style_sheet(Function<void(CSS::CSSStyleSheet&)>&&
     }
 }
 
-WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animations::Animation>>> ShadowRoot::get_animations()
+WebIDL::ExceptionOr<Vector<GC::Ref<Animations::Animation>>> ShadowRoot::get_animations()
 {
-    Vector<JS::NonnullGCPtr<Animations::Animation>> relevant_animations;
+    Vector<GC::Ref<Animations::Animation>> relevant_animations;
     TRY(for_each_child_of_type_fallible<Element>([&](auto& child) -> WebIDL::ExceptionOr<IterationDecision> {
         relevant_animations.extend(TRY(child.get_animations(Animations::GetAnimationsOptions { .subtree = true })));
         return IterationDecision::Continue;
diff --git a/Libraries/LibWeb/DOM/ShadowRoot.h b/Libraries/LibWeb/DOM/ShadowRoot.h
index dd73fef68f6..ef18117b56a 100644
--- a/Libraries/LibWeb/DOM/ShadowRoot.h
+++ b/Libraries/LibWeb/DOM/ShadowRoot.h
@@ -14,7 +14,7 @@ namespace Web::DOM {
 
 class ShadowRoot final : public DocumentFragment {
     WEB_PLATFORM_OBJECT(ShadowRoot, DocumentFragment);
-    JS_DECLARE_ALLOCATOR(ShadowRoot);
+    GC_DECLARE_ALLOCATOR(ShadowRoot);
 
 public:
     Bindings::ShadowRootMode mode() const { return m_mode; }
@@ -55,12 +55,12 @@ public:
 
     CSS::StyleSheetList* style_sheets_for_bindings() { return &style_sheets(); }
 
-    JS::NonnullGCPtr<WebIDL::ObservableArray> adopted_style_sheets() const;
+    GC::Ref<WebIDL::ObservableArray> adopted_style_sheets() const;
     WebIDL::ExceptionOr<void> set_adopted_style_sheets(JS::Value);
 
     void for_each_css_style_sheet(Function<void(CSS::CSSStyleSheet&)>&& callback) const;
 
-    WebIDL::ExceptionOr<Vector<JS::NonnullGCPtr<Animations::Animation>>> get_animations();
+    WebIDL::ExceptionOr<Vector<GC::Ref<Animations::Animation>>> get_animations();
 
     virtual void finalize() override;
 
@@ -90,8 +90,8 @@ private:
     // https://dom.spec.whatwg.org/#shadowroot-serializable
     bool m_serializable { false };
 
-    JS::GCPtr<CSS::StyleSheetList> m_style_sheets;
-    mutable JS::GCPtr<WebIDL::ObservableArray> m_adopted_style_sheets;
+    GC::Ptr<CSS::StyleSheetList> m_style_sheets;
+    mutable GC::Ptr<WebIDL::ObservableArray> m_adopted_style_sheets;
 };
 
 template<>
diff --git a/Libraries/LibWeb/DOM/Slottable.cpp b/Libraries/LibWeb/DOM/Slottable.cpp
index 5e5ce160e55..41d70c78b01 100644
--- a/Libraries/LibWeb/DOM/Slottable.cpp
+++ b/Libraries/LibWeb/DOM/Slottable.cpp
@@ -23,7 +23,7 @@ void SlottableMixin::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-slotable-assignedslot
-JS::GCPtr<HTML::HTMLSlotElement> SlottableMixin::assigned_slot()
+GC::Ptr<HTML::HTMLSlotElement> SlottableMixin::assigned_slot()
 {
     auto* node = dynamic_cast<DOM::Node*>(this);
     VERIFY(node);
@@ -32,7 +32,7 @@ JS::GCPtr<HTML::HTMLSlotElement> SlottableMixin::assigned_slot()
     return find_a_slot(node->as_slottable(), OpenFlag::Set);
 }
 
-JS::GCPtr<HTML::HTMLSlotElement> assigned_slot_for_node(JS::NonnullGCPtr<Node> node)
+GC::Ptr<HTML::HTMLSlotElement> assigned_slot_for_node(GC::Ref<Node> node)
 {
     if (!node->is_slottable())
         return nullptr;
@@ -43,7 +43,7 @@ JS::GCPtr<HTML::HTMLSlotElement> assigned_slot_for_node(JS::NonnullGCPtr<Node> n
 }
 
 // https://dom.spec.whatwg.org/#slotable-assigned
-bool is_an_assigned_slottable(JS::NonnullGCPtr<Node> node)
+bool is_an_assigned_slottable(GC::Ref<Node> node)
 {
     if (!node->is_slottable())
         return false;
@@ -53,7 +53,7 @@ bool is_an_assigned_slottable(JS::NonnullGCPtr<Node> node)
 }
 
 // https://dom.spec.whatwg.org/#find-a-slot
-JS::GCPtr<HTML::HTMLSlotElement> find_a_slot(Slottable const& slottable, OpenFlag open_flag)
+GC::Ptr<HTML::HTMLSlotElement> find_a_slot(Slottable const& slottable, OpenFlag open_flag)
 {
     // 1. If slottable’s parent is null, then return null.
     auto* parent = slottable.visit([](auto& node) { return node->parent_element(); });
@@ -74,7 +74,7 @@ JS::GCPtr<HTML::HTMLSlotElement> find_a_slot(Slottable const& slottable, OpenFla
     // 5. If shadow’s slot assignment is "manual", then return the slot in shadow’s descendants whose manually assigned
     //    nodes contains slottable, if any; otherwise null.
     if (shadow->slot_assignment() == Bindings::SlotAssignmentMode::Manual) {
-        JS::GCPtr<HTML::HTMLSlotElement> slot;
+        GC::Ptr<HTML::HTMLSlotElement> slot;
 
         shadow->for_each_in_subtree_of_type<HTML::HTMLSlotElement>([&](auto& child) {
             if (!child.manually_assigned_nodes().contains_slow(slottable))
@@ -89,7 +89,7 @@ JS::GCPtr<HTML::HTMLSlotElement> find_a_slot(Slottable const& slottable, OpenFla
 
     // 6. Return the first slot in tree order in shadow’s descendants whose name is slottable’s name, if any; otherwise null.
     auto const& slottable_name = slottable.visit([](auto const& node) { return node->slottable_name(); });
-    JS::GCPtr<HTML::HTMLSlotElement> slot;
+    GC::Ptr<HTML::HTMLSlotElement> slot;
 
     shadow->for_each_in_subtree_of_type<HTML::HTMLSlotElement>([&](auto& child) {
         if (child.slot_name() != slottable_name)
@@ -103,7 +103,7 @@ JS::GCPtr<HTML::HTMLSlotElement> find_a_slot(Slottable const& slottable, OpenFla
 }
 
 // https://dom.spec.whatwg.org/#find-slotables
-Vector<Slottable> find_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement> slot)
+Vector<Slottable> find_slottables(GC::Ref<HTML::HTMLSlotElement> slot)
 {
     // 1. Let result be an empty list.
     Vector<Slottable> result;
@@ -154,7 +154,7 @@ Vector<Slottable> find_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement> slot)
 }
 
 // https://dom.spec.whatwg.org/#assign-slotables
-void assign_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement> slot)
+void assign_slottables(GC::Ref<HTML::HTMLSlotElement> slot)
 {
     // 1. Let slottables be the result of finding slottables for slot.
     auto slottables = find_slottables(slot);
@@ -176,7 +176,7 @@ void assign_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement> slot)
 }
 
 // https://dom.spec.whatwg.org/#assign-slotables-for-a-tree
-void assign_slottables_for_a_tree(JS::NonnullGCPtr<Node> root)
+void assign_slottables_for_a_tree(GC::Ref<Node> root)
 {
     // AD-HOC: This method iterates over the root's entire subtree. That iteration does nothing if the root is not a
     //         shadow root (see `find_slottables`). This iteration can be very expensive as the HTML parser inserts
@@ -204,7 +204,7 @@ void assign_a_slot(Slottable const& slottable)
 }
 
 // https://dom.spec.whatwg.org/#signal-a-slot-change
-void signal_a_slot_change(JS::NonnullGCPtr<HTML::HTMLSlotElement> slottable)
+void signal_a_slot_change(GC::Ref<HTML::HTMLSlotElement> slottable)
 {
     // FIXME: 1. Append slot to slot’s relevant agent’s signal slots.
 
diff --git a/Libraries/LibWeb/DOM/Slottable.h b/Libraries/LibWeb/DOM/Slottable.h
index 81de3e29c10..46a2bfaeb84 100644
--- a/Libraries/LibWeb/DOM/Slottable.h
+++ b/Libraries/LibWeb/DOM/Slottable.h
@@ -8,14 +8,14 @@
 
 #include <AK/String.h>
 #include <AK/Variant.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::DOM {
 
 // https://dom.spec.whatwg.org/#concept-slotable
-using Slottable = Variant<JS::NonnullGCPtr<Element>, JS::NonnullGCPtr<Text>>;
+using Slottable = Variant<GC::Ref<Element>, GC::Ref<Text>>;
 
 // https://dom.spec.whatwg.org/#mixin-slotable
 class SlottableMixin {
@@ -25,13 +25,13 @@ public:
     String const& slottable_name() const { return m_name; } // Not called `name` to distinguish from `Element::name`.
     void set_slottable_name(String name) { m_name = move(name); }
 
-    JS::GCPtr<HTML::HTMLSlotElement> assigned_slot();
+    GC::Ptr<HTML::HTMLSlotElement> assigned_slot();
 
-    JS::GCPtr<HTML::HTMLSlotElement> assigned_slot_internal() const { return m_assigned_slot; }
-    void set_assigned_slot(JS::GCPtr<HTML::HTMLSlotElement> assigned_slot) { m_assigned_slot = assigned_slot; }
+    GC::Ptr<HTML::HTMLSlotElement> assigned_slot_internal() const { return m_assigned_slot; }
+    void set_assigned_slot(GC::Ptr<HTML::HTMLSlotElement> assigned_slot) { m_assigned_slot = assigned_slot; }
 
-    JS::GCPtr<HTML::HTMLSlotElement> manual_slot_assignment() { return m_manual_slot_assignment; }
-    void set_manual_slot_assignment(JS::GCPtr<HTML::HTMLSlotElement> manual_slot_assignment) { m_manual_slot_assignment = manual_slot_assignment; }
+    GC::Ptr<HTML::HTMLSlotElement> manual_slot_assignment() { return m_manual_slot_assignment; }
+    void set_manual_slot_assignment(GC::Ptr<HTML::HTMLSlotElement> manual_slot_assignment) { m_manual_slot_assignment = manual_slot_assignment; }
 
 protected:
     void visit_edges(JS::Cell::Visitor&);
@@ -41,10 +41,10 @@ private:
     String m_name;
 
     // https://dom.spec.whatwg.org/#slotable-assigned-slot
-    JS::GCPtr<HTML::HTMLSlotElement> m_assigned_slot;
+    GC::Ptr<HTML::HTMLSlotElement> m_assigned_slot;
 
     // https://dom.spec.whatwg.org/#slottable-manual-slot-assignment
-    JS::GCPtr<HTML::HTMLSlotElement> m_manual_slot_assignment;
+    GC::Ptr<HTML::HTMLSlotElement> m_manual_slot_assignment;
 };
 
 enum class OpenFlag {
@@ -52,14 +52,14 @@ enum class OpenFlag {
     Unset,
 };
 
-JS::GCPtr<HTML::HTMLSlotElement> assigned_slot_for_node(JS::NonnullGCPtr<Node>);
-bool is_an_assigned_slottable(JS::NonnullGCPtr<Node>);
+GC::Ptr<HTML::HTMLSlotElement> assigned_slot_for_node(GC::Ref<Node>);
+bool is_an_assigned_slottable(GC::Ref<Node>);
 
-JS::GCPtr<HTML::HTMLSlotElement> find_a_slot(Slottable const&, OpenFlag = OpenFlag::Unset);
-Vector<Slottable> find_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement>);
-void assign_slottables(JS::NonnullGCPtr<HTML::HTMLSlotElement>);
-void assign_slottables_for_a_tree(JS::NonnullGCPtr<Node>);
+GC::Ptr<HTML::HTMLSlotElement> find_a_slot(Slottable const&, OpenFlag = OpenFlag::Unset);
+Vector<Slottable> find_slottables(GC::Ref<HTML::HTMLSlotElement>);
+void assign_slottables(GC::Ref<HTML::HTMLSlotElement>);
+void assign_slottables_for_a_tree(GC::Ref<Node>);
 void assign_a_slot(Slottable const&);
-void signal_a_slot_change(JS::NonnullGCPtr<HTML::HTMLSlotElement>);
+void signal_a_slot_change(GC::Ref<HTML::HTMLSlotElement>);
 
 }
diff --git a/Libraries/LibWeb/DOM/StaticNodeList.cpp b/Libraries/LibWeb/DOM/StaticNodeList.cpp
index 03d1812a668..2c59e5e4815 100644
--- a/Libraries/LibWeb/DOM/StaticNodeList.cpp
+++ b/Libraries/LibWeb/DOM/StaticNodeList.cpp
@@ -4,20 +4,20 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibWeb/DOM/StaticNodeList.h>
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(StaticNodeList);
+GC_DEFINE_ALLOCATOR(StaticNodeList);
 
-JS::NonnullGCPtr<NodeList> StaticNodeList::create(JS::Realm& realm, Vector<JS::Handle<Node>> static_nodes)
+GC::Ref<NodeList> StaticNodeList::create(JS::Realm& realm, Vector<GC::Root<Node>> static_nodes)
 {
     return realm.create<StaticNodeList>(realm, move(static_nodes));
 }
 
-StaticNodeList::StaticNodeList(JS::Realm& realm, Vector<JS::Handle<Node>> static_nodes)
+StaticNodeList::StaticNodeList(JS::Realm& realm, Vector<GC::Root<Node>> static_nodes)
     : NodeList(realm)
 {
     for (auto& node : static_nodes)
diff --git a/Libraries/LibWeb/DOM/StaticNodeList.h b/Libraries/LibWeb/DOM/StaticNodeList.h
index 784c354f989..44b6f530e28 100644
--- a/Libraries/LibWeb/DOM/StaticNodeList.h
+++ b/Libraries/LibWeb/DOM/StaticNodeList.h
@@ -13,10 +13,10 @@ namespace Web::DOM {
 
 class StaticNodeList final : public NodeList {
     WEB_PLATFORM_OBJECT(StaticNodeList, NodeList);
-    JS_DECLARE_ALLOCATOR(StaticNodeList);
+    GC_DECLARE_ALLOCATOR(StaticNodeList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NodeList> create(JS::Realm&, Vector<JS::Handle<Node>>);
+    [[nodiscard]] static GC::Ref<NodeList> create(JS::Realm&, Vector<GC::Root<Node>>);
 
     virtual ~StaticNodeList() override;
 
@@ -24,11 +24,11 @@ public:
     virtual Node const* item(u32 index) const override;
 
 private:
-    StaticNodeList(JS::Realm&, Vector<JS::Handle<Node>>);
+    StaticNodeList(JS::Realm&, Vector<GC::Root<Node>>);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<JS::NonnullGCPtr<Node>> m_static_nodes;
+    Vector<GC::Ref<Node>> m_static_nodes;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/StaticRange.cpp b/Libraries/LibWeb/DOM/StaticRange.cpp
index 778bb51c5ed..2b3303ea690 100644
--- a/Libraries/LibWeb/DOM/StaticRange.cpp
+++ b/Libraries/LibWeb/DOM/StaticRange.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(StaticRange);
+GC_DEFINE_ALLOCATOR(StaticRange);
 
 StaticRange::StaticRange(Node& start_container, u32 start_offset, Node& end_container, u32 end_offset)
     : AbstractRange(start_container, start_offset, end_container, end_offset)
@@ -25,7 +25,7 @@ StaticRange::StaticRange(Node& start_container, u32 start_offset, Node& end_cont
 StaticRange::~StaticRange() = default;
 
 // https://dom.spec.whatwg.org/#dom-staticrange-staticrange
-WebIDL::ExceptionOr<JS::NonnullGCPtr<StaticRange>> StaticRange::construct_impl(JS::Realm& realm, StaticRangeInit& init)
+WebIDL::ExceptionOr<GC::Ref<StaticRange>> StaticRange::construct_impl(JS::Realm& realm, StaticRangeInit& init)
 {
     // 1. If init["startContainer"] or init["endContainer"] is a DocumentType or Attr node, then throw an "InvalidNodeTypeError" DOMException.
     if (is<DocumentType>(*init.start_container) || is<Attr>(*init.start_container))
diff --git a/Libraries/LibWeb/DOM/StaticRange.h b/Libraries/LibWeb/DOM/StaticRange.h
index dac3e96cdc3..afb672d179c 100644
--- a/Libraries/LibWeb/DOM/StaticRange.h
+++ b/Libraries/LibWeb/DOM/StaticRange.h
@@ -14,18 +14,18 @@ namespace Web::DOM {
 // NOTE: We must use GCP instead of NNGCP here, otherwise the generated code cannot default initialize this struct.
 //       They will never be null, as they are marked as required and non-null in the dictionary.
 struct StaticRangeInit {
-    JS::GCPtr<Node> start_container;
+    GC::Ptr<Node> start_container;
     u32 start_offset { 0 };
-    JS::GCPtr<Node> end_container;
+    GC::Ptr<Node> end_container;
     u32 end_offset { 0 };
 };
 
 class StaticRange final : public AbstractRange {
     WEB_PLATFORM_OBJECT(StaticRange, AbstractRange);
-    JS_DECLARE_ALLOCATOR(StaticRange);
+    GC_DECLARE_ALLOCATOR(StaticRange);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<StaticRange>> construct_impl(JS::Realm&, StaticRangeInit& init);
+    static WebIDL::ExceptionOr<GC::Ref<StaticRange>> construct_impl(JS::Realm&, StaticRangeInit& init);
 
     StaticRange(Node& start_container, u32 start_offset, Node& end_container, u32 end_offset);
     virtual ~StaticRange() override;
diff --git a/Libraries/LibWeb/DOM/StyleElementUtils.h b/Libraries/LibWeb/DOM/StyleElementUtils.h
index d7e2fa1acd2..5385dca9232 100644
--- a/Libraries/LibWeb/DOM/StyleElementUtils.h
+++ b/Libraries/LibWeb/DOM/StyleElementUtils.h
@@ -19,16 +19,16 @@ public:
     CSS::CSSStyleSheet* sheet() { return m_associated_css_style_sheet; }
     CSS::CSSStyleSheet const* sheet() const { return m_associated_css_style_sheet; }
 
-    [[nodiscard]] JS::GCPtr<CSS::StyleSheetList> style_sheet_list() { return m_style_sheet_list; }
-    [[nodiscard]] JS::GCPtr<CSS::StyleSheetList const> style_sheet_list() const { return m_style_sheet_list; }
+    [[nodiscard]] GC::Ptr<CSS::StyleSheetList> style_sheet_list() { return m_style_sheet_list; }
+    [[nodiscard]] GC::Ptr<CSS::StyleSheetList const> style_sheet_list() const { return m_style_sheet_list; }
 
     void visit_edges(JS::Cell::Visitor&);
 
 private:
     // https://www.w3.org/TR/cssom/#associated-css-style-sheet
-    JS::GCPtr<CSS::CSSStyleSheet> m_associated_css_style_sheet;
+    GC::Ptr<CSS::CSSStyleSheet> m_associated_css_style_sheet;
 
-    JS::GCPtr<CSS::StyleSheetList> m_style_sheet_list;
+    GC::Ptr<CSS::StyleSheetList> m_style_sheet_list;
 };
 
 }
diff --git a/Libraries/LibWeb/DOM/Text.cpp b/Libraries/LibWeb/DOM/Text.cpp
index fe96a856cf3..569b866ab41 100644
--- a/Libraries/LibWeb/DOM/Text.cpp
+++ b/Libraries/LibWeb/DOM/Text.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(Text);
+GC_DEFINE_ALLOCATOR(Text);
 
 Text::Text(Document& document, String const& data)
     : CharacterData(document, NodeType::TEXT_NODE, data)
@@ -41,7 +41,7 @@ void Text::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-text-text
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> Text::construct_impl(JS::Realm& realm, String const& data)
+WebIDL::ExceptionOr<GC::Ref<Text>> Text::construct_impl(JS::Realm& realm, String const& data)
 {
     // The new Text(data) constructor steps are to set this’s data to data and this’s node document to current global object’s associated Document.
     auto& window = verify_cast<HTML::Window>(HTML::current_principal_global_object());
@@ -50,7 +50,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> Text::construct_impl(JS::Realm& real
 
 // https://dom.spec.whatwg.org/#dom-text-splittext
 // https://dom.spec.whatwg.org/#concept-text-split
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> Text::split_text(size_t offset)
+WebIDL::ExceptionOr<GC::Ref<Text>> Text::split_text(size_t offset)
 {
     // 1. Let length be node’s length.
     auto length = this->length();
@@ -69,7 +69,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> Text::split_text(size_t offset)
     auto new_node = realm().create<Text>(document(), new_data);
 
     // 6. Let parent be node’s parent.
-    JS::GCPtr<Node> parent = this->parent();
+    GC::Ptr<Node> parent = this->parent();
 
     // 7. If parent is not null, then:
     if (parent) {
diff --git a/Libraries/LibWeb/DOM/Text.h b/Libraries/LibWeb/DOM/Text.h
index f081fa2b1bd..1010858777b 100644
--- a/Libraries/LibWeb/DOM/Text.h
+++ b/Libraries/LibWeb/DOM/Text.h
@@ -17,12 +17,12 @@ class Text
     : public CharacterData
     , public SlottableMixin {
     WEB_PLATFORM_OBJECT(Text, CharacterData);
-    JS_DECLARE_ALLOCATOR(Text);
+    GC_DECLARE_ALLOCATOR(Text);
 
 public:
     virtual ~Text() override = default;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> construct_impl(JS::Realm& realm, String const& data);
+    static WebIDL::ExceptionOr<GC::Ref<Text>> construct_impl(JS::Realm& realm, String const& data);
 
     // ^Node
     virtual FlyString node_name() const override { return "#text"_fly_string; }
@@ -33,7 +33,7 @@ public:
     Optional<size_t> max_length() const { return m_max_length; }
     void set_max_length(Optional<size_t> max_length) { m_max_length = move(max_length); }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Text>> split_text(size_t offset);
+    WebIDL::ExceptionOr<GC::Ref<Text>> split_text(size_t offset);
     String whole_text();
 
     bool is_password_input() const { return m_is_password_input; }
@@ -49,7 +49,7 @@ protected:
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
-    JS::GCPtr<Element> m_owner;
+    GC::Ptr<Element> m_owner;
 
     bool m_always_editable { false };
     Optional<size_t> m_max_length {};
diff --git a/Libraries/LibWeb/DOM/TreeWalker.cpp b/Libraries/LibWeb/DOM/TreeWalker.cpp
index 697cedd3c9f..82def91c128 100644
--- a/Libraries/LibWeb/DOM/TreeWalker.cpp
+++ b/Libraries/LibWeb/DOM/TreeWalker.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(TreeWalker);
+GC_DEFINE_ALLOCATOR(TreeWalker);
 
 TreeWalker::TreeWalker(Node& root)
     : PlatformObject(root.realm())
@@ -40,7 +40,7 @@ void TreeWalker::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://dom.spec.whatwg.org/#dom-document-createtreewalker
-JS::NonnullGCPtr<TreeWalker> TreeWalker::create(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter> filter)
+GC::Ref<TreeWalker> TreeWalker::create(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter> filter)
 {
     // 1. Let walker be a new TreeWalker object.
     // 2. Set walker’s root and walker’s current to root.
@@ -58,7 +58,7 @@ JS::NonnullGCPtr<TreeWalker> TreeWalker::create(Node& root, unsigned what_to_sho
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-currentnode
-JS::NonnullGCPtr<Node> TreeWalker::current_node() const
+GC::Ref<Node> TreeWalker::current_node() const
 {
     return *m_current;
 }
@@ -70,10 +70,10 @@ void TreeWalker::set_current_node(Node& node)
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-parentnode
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::parent_node()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::parent_node()
 {
     // 1. Let node be this’s current.
-    JS::GCPtr<Node> node = m_current;
+    GC::Ptr<Node> node = m_current;
 
     // 2. While node is non-null and is not this’s root:
     while (node && node != m_root) {
@@ -95,39 +95,39 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::parent_node()
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-firstchild
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::first_child()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::first_child()
 {
     return traverse_children(ChildTraversalType::First);
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-lastchild
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::last_child()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::last_child()
 {
     return traverse_children(ChildTraversalType::Last);
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-previoussibling
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::previous_sibling()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::previous_sibling()
 {
     return traverse_siblings(SiblingTraversalType::Previous);
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-nextsibling
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::next_sibling()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::next_sibling()
 {
     return traverse_siblings(SiblingTraversalType::Next);
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-previousnode
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::previous_node()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::previous_node()
 {
     // 1. Let node be this’s current.
-    JS::NonnullGCPtr<Node> node = m_current;
+    GC::Ref<Node> node = m_current;
 
     // 2. While node is not this’s root:
     while (node != m_root) {
         // 1. Let sibling be node’s previous sibling.
-        JS::GCPtr<Node> sibling = node->previous_sibling();
+        GC::Ptr<Node> sibling = node->previous_sibling();
 
         // 2. While sibling is non-null:
         while (sibling) {
@@ -174,10 +174,10 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::previous_node()
 }
 
 // https://dom.spec.whatwg.org/#dom-treewalker-nextnode
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::next_node()
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::next_node()
 {
     // 1. Let node be this’s current.
-    JS::NonnullGCPtr<Node> node = m_current;
+    GC::Ref<Node> node = m_current;
 
     // 2. Let result be FILTER_ACCEPT.
     auto result = NodeFilter::Result::FILTER_ACCEPT;
@@ -200,10 +200,10 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::next_node()
         }
 
         // 2. Let sibling be null.
-        JS::GCPtr<Node> sibling = nullptr;
+        GC::Ptr<Node> sibling = nullptr;
 
         // 3. Let temporary be node.
-        JS::GCPtr<Node> temporary = node;
+        GC::Ptr<Node> temporary = node;
 
         // 4. While temporary is non-null:
         while (temporary) {
@@ -280,10 +280,10 @@ JS::ThrowCompletionOr<NodeFilter::Result> TreeWalker::filter(Node& node)
 }
 
 // https://dom.spec.whatwg.org/#concept-traverse-children
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_children(ChildTraversalType type)
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::traverse_children(ChildTraversalType type)
 {
     // 1. Let node be walker’s current.
-    JS::GCPtr<Node> node = m_current;
+    GC::Ptr<Node> node = m_current;
 
     // 2. Set node to node’s first child if type is first, and node’s last child if type is last.
     node = type == ChildTraversalType::First ? node->first_child() : node->last_child();
@@ -302,7 +302,7 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_children(ChildTraver
         // 3. If result is FILTER_SKIP, then:
         if (result == NodeFilter::Result::FILTER_SKIP) {
             // 1. Let child be node’s first child if type is first, and node’s last child if type is last.
-            JS::GCPtr<Node> child = type == ChildTraversalType::First ? node->first_child() : node->last_child();
+            GC::Ptr<Node> child = type == ChildTraversalType::First ? node->first_child() : node->last_child();
 
             // 2. If child is non-null, then set node to child and continue.
             if (child) {
@@ -314,7 +314,7 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_children(ChildTraver
         // 4. While node is non-null:
         while (node) {
             // 1. Let sibling be node’s next sibling if type is first, and node’s previous sibling if type is last.
-            JS::GCPtr<Node> sibling = type == ChildTraversalType::First ? node->next_sibling() : node->previous_sibling();
+            GC::Ptr<Node> sibling = type == ChildTraversalType::First ? node->next_sibling() : node->previous_sibling();
 
             // 2. If sibling is non-null, then set node to sibling and break.
             if (sibling) {
@@ -323,7 +323,7 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_children(ChildTraver
             }
 
             // 3. Let parent be node’s parent.
-            JS::GCPtr<Node> parent = node->parent();
+            GC::Ptr<Node> parent = node->parent();
 
             // 4. If parent is null, walker’s root, or walker’s current, then return null.
             if (!parent || parent == m_root || parent == m_current)
@@ -339,10 +339,10 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_children(ChildTraver
 }
 
 // https://dom.spec.whatwg.org/#concept-traverse-siblings
-JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_siblings(SiblingTraversalType type)
+JS::ThrowCompletionOr<GC::Ptr<Node>> TreeWalker::traverse_siblings(SiblingTraversalType type)
 {
     // 1. Let node be walker’s current.
-    JS::GCPtr<Node> node = m_current;
+    GC::Ptr<Node> node = m_current;
 
     // 2. If node is root, then return null.
     if (node == m_root)
@@ -351,7 +351,7 @@ JS::ThrowCompletionOr<JS::GCPtr<Node>> TreeWalker::traverse_siblings(SiblingTrav
     // 3. While true:
     while (true) {
         // 1. Let sibling be node’s next sibling if type is next, and node’s previous sibling if type is previous.
-        JS::GCPtr<Node> sibling = type == SiblingTraversalType::Next ? node->next_sibling() : node->previous_sibling();
+        GC::Ptr<Node> sibling = type == SiblingTraversalType::Next ? node->next_sibling() : node->previous_sibling();
 
         // 2. While sibling is non-null:
         while (sibling) {
diff --git a/Libraries/LibWeb/DOM/TreeWalker.h b/Libraries/LibWeb/DOM/TreeWalker.h
index e313e716593..b97dfeb89fc 100644
--- a/Libraries/LibWeb/DOM/TreeWalker.h
+++ b/Libraries/LibWeb/DOM/TreeWalker.h
@@ -13,25 +13,25 @@ namespace Web::DOM {
 // https://dom.spec.whatwg.org/#treewalker
 class TreeWalker final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TreeWalker, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TreeWalker);
+    GC_DECLARE_ALLOCATOR(TreeWalker);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<TreeWalker> create(Node& root, unsigned what_to_show, JS::GCPtr<NodeFilter>);
+    [[nodiscard]] static GC::Ref<TreeWalker> create(Node& root, unsigned what_to_show, GC::Ptr<NodeFilter>);
 
     virtual ~TreeWalker() override;
 
-    JS::NonnullGCPtr<Node> current_node() const;
+    GC::Ref<Node> current_node() const;
     void set_current_node(Node&);
 
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> parent_node();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> first_child();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> last_child();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> previous_sibling();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> next_sibling();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> previous_node();
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> next_node();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> parent_node();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> first_child();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> last_child();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> previous_sibling();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> next_sibling();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> previous_node();
+    JS::ThrowCompletionOr<GC::Ptr<Node>> next_node();
 
-    JS::NonnullGCPtr<Node> root() { return m_root; }
+    GC::Ref<Node> root() { return m_root; }
 
     NodeFilter* filter() { return m_filter.ptr(); }
 
@@ -47,27 +47,27 @@ private:
         First,
         Last,
     };
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> traverse_children(ChildTraversalType);
+    JS::ThrowCompletionOr<GC::Ptr<Node>> traverse_children(ChildTraversalType);
 
     enum class SiblingTraversalType {
         Next,
         Previous,
     };
-    JS::ThrowCompletionOr<JS::GCPtr<Node>> traverse_siblings(SiblingTraversalType);
+    JS::ThrowCompletionOr<GC::Ptr<Node>> traverse_siblings(SiblingTraversalType);
 
     JS::ThrowCompletionOr<NodeFilter::Result> filter(Node&);
 
     // https://dom.spec.whatwg.org/#concept-traversal-root
-    JS::NonnullGCPtr<Node> m_root;
+    GC::Ref<Node> m_root;
 
     // https://dom.spec.whatwg.org/#treewalker-current
-    JS::NonnullGCPtr<Node> m_current;
+    GC::Ref<Node> m_current;
 
     // https://dom.spec.whatwg.org/#concept-traversal-whattoshow
     unsigned m_what_to_show { 0 };
 
     // https://dom.spec.whatwg.org/#concept-traversal-filter
-    JS::GCPtr<NodeFilter> m_filter;
+    GC::Ptr<NodeFilter> m_filter;
 
     // https://dom.spec.whatwg.org/#concept-traversal-active
     bool m_active { false };
diff --git a/Libraries/LibWeb/DOM/XMLDocument.cpp b/Libraries/LibWeb/DOM/XMLDocument.cpp
index a18a68a1016..c757ae2eb4c 100644
--- a/Libraries/LibWeb/DOM/XMLDocument.cpp
+++ b/Libraries/LibWeb/DOM/XMLDocument.cpp
@@ -9,9 +9,9 @@
 
 namespace Web::DOM {
 
-JS_DEFINE_ALLOCATOR(XMLDocument);
+GC_DEFINE_ALLOCATOR(XMLDocument);
 
-JS::NonnullGCPtr<XMLDocument> XMLDocument::create(JS::Realm& realm, URL::URL const& url)
+GC::Ref<XMLDocument> XMLDocument::create(JS::Realm& realm, URL::URL const& url)
 {
     return realm.create<XMLDocument>(realm, url);
 }
diff --git a/Libraries/LibWeb/DOM/XMLDocument.h b/Libraries/LibWeb/DOM/XMLDocument.h
index e1b2000cdb9..b305de265b7 100644
--- a/Libraries/LibWeb/DOM/XMLDocument.h
+++ b/Libraries/LibWeb/DOM/XMLDocument.h
@@ -12,10 +12,10 @@ namespace Web::DOM {
 
 class XMLDocument final : public Document {
     WEB_PLATFORM_OBJECT(XMLDocument, Document);
-    JS_DECLARE_ALLOCATOR(XMLDocument);
+    GC_DECLARE_ALLOCATOR(XMLDocument);
 
 public:
-    static JS::NonnullGCPtr<XMLDocument> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
+    static GC::Ref<XMLDocument> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
     virtual ~XMLDocument() override = default;
 
 private:
diff --git a/Libraries/LibWeb/DOMParsing/XMLSerializer.cpp b/Libraries/LibWeb/DOMParsing/XMLSerializer.cpp
index ad4c5b0aef2..588b41f7c4a 100644
--- a/Libraries/LibWeb/DOMParsing/XMLSerializer.cpp
+++ b/Libraries/LibWeb/DOMParsing/XMLSerializer.cpp
@@ -24,9 +24,9 @@
 
 namespace Web::DOMParsing {
 
-JS_DEFINE_ALLOCATOR(XMLSerializer);
+GC_DEFINE_ALLOCATOR(XMLSerializer);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLSerializer>> XMLSerializer::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<XMLSerializer>> XMLSerializer::construct_impl(JS::Realm& realm)
 {
     return realm.create<XMLSerializer>(realm);
 }
@@ -45,7 +45,7 @@ void XMLSerializer::initialize(JS::Realm& realm)
 }
 
 // https://w3c.github.io/DOM-Parsing/#dom-xmlserializer-serializetostring
-WebIDL::ExceptionOr<String> XMLSerializer::serialize_to_string(JS::NonnullGCPtr<DOM::Node const> root)
+WebIDL::ExceptionOr<String> XMLSerializer::serialize_to_string(GC::Ref<DOM::Node const> root)
 {
     // The serializeToString(root) method must produce an XML serialization of root passing a value of false for the require well-formed parameter, and return the result.
     return serialize_node_to_xml_string(root, RequireWellFormed::No);
@@ -128,10 +128,10 @@ static bool prefix_is_in_prefix_map(FlyString const& prefix, HashMap<FlyString,
     return candidates_list_iterator->value.contains_slow(prefix);
 }
 
-WebIDL::ExceptionOr<String> serialize_node_to_xml_string_impl(JS::NonnullGCPtr<DOM::Node const> root, Optional<FlyString>& namespace_, HashMap<FlyString, Vector<Optional<FlyString>>>& namespace_prefix_map, u64& prefix_index, RequireWellFormed require_well_formed);
+WebIDL::ExceptionOr<String> serialize_node_to_xml_string_impl(GC::Ref<DOM::Node const> root, Optional<FlyString>& namespace_, HashMap<FlyString, Vector<Optional<FlyString>>>& namespace_prefix_map, u64& prefix_index, RequireWellFormed require_well_formed);
 
 // https://w3c.github.io/DOM-Parsing/#dfn-xml-serialization
-WebIDL::ExceptionOr<String> serialize_node_to_xml_string(JS::NonnullGCPtr<DOM::Node const> root, RequireWellFormed require_well_formed)
+WebIDL::ExceptionOr<String> serialize_node_to_xml_string(GC::Ref<DOM::Node const> root, RequireWellFormed require_well_formed)
 {
     // 1. Let namespace be a context namespace with value null. The context namespace tracks the XML serialization algorithm's current default namespace.
     //    The context namespace is changed when either an Element Node has a default namespace declaration, or the algorithm generates a default namespace declaration
@@ -165,7 +165,7 @@ static WebIDL::ExceptionOr<String> serialize_processing_instruction(DOM::Process
 static WebIDL::ExceptionOr<String> serialize_cdata_section(DOM::CDATASection const& cdata_section, RequireWellFormed require_well_formed);
 
 // https://w3c.github.io/DOM-Parsing/#dfn-xml-serialization-algorithm
-WebIDL::ExceptionOr<String> serialize_node_to_xml_string_impl(JS::NonnullGCPtr<DOM::Node const> root, Optional<FlyString>& namespace_, HashMap<FlyString, Vector<Optional<FlyString>>>& namespace_prefix_map, u64& prefix_index, RequireWellFormed require_well_formed)
+WebIDL::ExceptionOr<String> serialize_node_to_xml_string_impl(GC::Ref<DOM::Node const> root, Optional<FlyString>& namespace_, HashMap<FlyString, Vector<Optional<FlyString>>>& namespace_prefix_map, u64& prefix_index, RequireWellFormed require_well_formed)
 {
     // Each of the following algorithms for producing an XML serialization of a DOM node take as input a node to serialize and the following arguments:
     // - A context namespace namespace
diff --git a/Libraries/LibWeb/DOMParsing/XMLSerializer.h b/Libraries/LibWeb/DOMParsing/XMLSerializer.h
index 85ac29daabc..16be0bdb255 100644
--- a/Libraries/LibWeb/DOMParsing/XMLSerializer.h
+++ b/Libraries/LibWeb/DOMParsing/XMLSerializer.h
@@ -12,14 +12,14 @@ namespace Web::DOMParsing {
 
 class XMLSerializer final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(XMLSerializer, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(XMLSerializer);
+    GC_DECLARE_ALLOCATOR(XMLSerializer);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLSerializer>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<XMLSerializer>> construct_impl(JS::Realm&);
 
     virtual ~XMLSerializer() override;
 
-    WebIDL::ExceptionOr<String> serialize_to_string(JS::NonnullGCPtr<DOM::Node const> root);
+    WebIDL::ExceptionOr<String> serialize_to_string(GC::Ref<DOM::Node const> root);
 
 private:
     explicit XMLSerializer(JS::Realm&);
@@ -32,5 +32,5 @@ enum class RequireWellFormed {
     Yes,
 };
 
-WebIDL::ExceptionOr<String> serialize_node_to_xml_string(JS::NonnullGCPtr<DOM::Node const> root, RequireWellFormed require_well_formed);
+WebIDL::ExceptionOr<String> serialize_node_to_xml_string(GC::Ref<DOM::Node const> root, RequireWellFormed require_well_formed);
 }
diff --git a/Libraries/LibWeb/DOMURL/DOMURL.cpp b/Libraries/LibWeb/DOMURL/DOMURL.cpp
index d008fd21371..cf09682e70a 100644
--- a/Libraries/LibWeb/DOMURL/DOMURL.cpp
+++ b/Libraries/LibWeb/DOMURL/DOMURL.cpp
@@ -18,9 +18,9 @@
 
 namespace Web::DOMURL {
 
-JS_DEFINE_ALLOCATOR(DOMURL);
+GC_DEFINE_ALLOCATOR(DOMURL);
 
-JS::NonnullGCPtr<DOMURL> DOMURL::create(JS::Realm& realm, URL::URL url, JS::NonnullGCPtr<URLSearchParams> query)
+GC::Ref<DOMURL> DOMURL::create(JS::Realm& realm, URL::URL url, GC::Ref<URLSearchParams> query)
 {
     return realm.create<DOMURL>(realm, move(url), query);
 }
@@ -52,7 +52,7 @@ static Optional<URL::URL> parse_api_url(String const& url, Optional<String> cons
 }
 
 // https://url.spec.whatwg.org/#url-initialize
-JS::NonnullGCPtr<DOMURL> DOMURL::initialize_a_url(JS::Realm& realm, URL::URL const& url_record)
+GC::Ref<DOMURL> DOMURL::initialize_a_url(JS::Realm& realm, URL::URL const& url_record)
 {
     // 1. Let query be urlRecord’s query, if that is non-null; otherwise the empty string.
     auto query = url_record.query().value_or(String {});
@@ -71,7 +71,7 @@ JS::NonnullGCPtr<DOMURL> DOMURL::initialize_a_url(JS::Realm& realm, URL::URL con
 }
 
 // https://url.spec.whatwg.org/#dom-url-parse
-JS::GCPtr<DOMURL> DOMURL::parse_for_bindings(JS::VM& vm, String const& url, Optional<String> const& base)
+GC::Ptr<DOMURL> DOMURL::parse_for_bindings(JS::VM& vm, String const& url, Optional<String> const& base)
 {
     auto& realm = *vm.current_realm();
 
@@ -89,7 +89,7 @@ JS::GCPtr<DOMURL> DOMURL::parse_for_bindings(JS::VM& vm, String const& url, Opti
 }
 
 // https://url.spec.whatwg.org/#dom-url-url
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMURL>> DOMURL::construct_impl(JS::Realm& realm, String const& url, Optional<String> const& base)
+WebIDL::ExceptionOr<GC::Ref<DOMURL>> DOMURL::construct_impl(JS::Realm& realm, String const& url, Optional<String> const& base)
 {
     // 1. Let parsedURL be the result of running the API URL parser on url with base, if given.
     auto parsed_url = parse_api_url(url, base);
@@ -102,7 +102,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMURL>> DOMURL::construct_impl(JS::Realm&
     return initialize_a_url(realm, parsed_url.value());
 }
 
-DOMURL::DOMURL(JS::Realm& realm, URL::URL url, JS::NonnullGCPtr<URLSearchParams> query)
+DOMURL::DOMURL(JS::Realm& realm, URL::URL url, GC::Ref<URLSearchParams> query)
     : PlatformObject(realm)
     , m_url(move(url))
     , m_query(move(query))
@@ -124,7 +124,7 @@ void DOMURL::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://w3c.github.io/FileAPI/#dfn-createObjectURL
-WebIDL::ExceptionOr<String> DOMURL::create_object_url(JS::VM& vm, JS::NonnullGCPtr<FileAPI::Blob> object)
+WebIDL::ExceptionOr<String> DOMURL::create_object_url(JS::VM& vm, GC::Ref<FileAPI::Blob> object)
 {
     // The createObjectURL(obj) static method must return the result of adding an entry to the blob URL store for obj.
     return TRY_OR_THROW_OOM(vm, FileAPI::add_entry_to_blob_url_store(object));
@@ -433,7 +433,7 @@ void DOMURL::set_search(String const& search)
 }
 
 // https://url.spec.whatwg.org/#dom-url-searchparams
-JS::NonnullGCPtr<URLSearchParams const> DOMURL::search_params() const
+GC::Ref<URLSearchParams const> DOMURL::search_params() const
 {
     // The searchParams getter steps are to return this’s query object.
     return m_query;
diff --git a/Libraries/LibWeb/DOMURL/DOMURL.h b/Libraries/LibWeb/DOMURL/DOMURL.h
index 011d0972f22..bb58d569d62 100644
--- a/Libraries/LibWeb/DOMURL/DOMURL.h
+++ b/Libraries/LibWeb/DOMURL/DOMURL.h
@@ -18,18 +18,18 @@ namespace Web::DOMURL {
 
 class DOMURL : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMURL, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMURL);
+    GC_DECLARE_ALLOCATOR(DOMURL);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DOMURL> create(JS::Realm&, URL::URL, JS::NonnullGCPtr<URLSearchParams> query);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMURL>> construct_impl(JS::Realm&, String const& url, Optional<String> const& base = {});
+    [[nodiscard]] static GC::Ref<DOMURL> create(JS::Realm&, URL::URL, GC::Ref<URLSearchParams> query);
+    static WebIDL::ExceptionOr<GC::Ref<DOMURL>> construct_impl(JS::Realm&, String const& url, Optional<String> const& base = {});
 
     virtual ~DOMURL() override;
 
-    static WebIDL::ExceptionOr<String> create_object_url(JS::VM&, JS::NonnullGCPtr<FileAPI::Blob> object);
+    static WebIDL::ExceptionOr<String> create_object_url(JS::VM&, GC::Ref<FileAPI::Blob> object);
     static WebIDL::ExceptionOr<void> revoke_object_url(JS::VM&, StringView url);
 
-    static JS::GCPtr<DOMURL> parse_for_bindings(JS::VM&, String const& url, Optional<String> const& base = {});
+    static GC::Ptr<DOMURL> parse_for_bindings(JS::VM&, String const& url, Optional<String> const& base = {});
     static bool can_parse(JS::VM&, String const& url, Optional<String> const& base = {});
 
     WebIDL::ExceptionOr<String> href() const;
@@ -70,7 +70,7 @@ public:
     WebIDL::ExceptionOr<String> search() const;
     void set_search(String const&);
 
-    JS::NonnullGCPtr<URLSearchParams const> search_params() const;
+    GC::Ref<URLSearchParams const> search_params() const;
 
     WebIDL::ExceptionOr<String> hash() const;
     void set_hash(String const&);
@@ -81,15 +81,15 @@ public:
     void set_query(Badge<URLSearchParams>, Optional<String> query) { m_url.set_query(move(query)); }
 
 private:
-    DOMURL(JS::Realm&, URL::URL, JS::NonnullGCPtr<URLSearchParams> query);
+    DOMURL(JS::Realm&, URL::URL, GC::Ref<URLSearchParams> query);
 
-    static JS::NonnullGCPtr<DOMURL> initialize_a_url(JS::Realm&, URL::URL const&);
+    static GC::Ref<DOMURL> initialize_a_url(JS::Realm&, URL::URL const&);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     URL::URL m_url;
-    JS::NonnullGCPtr<URLSearchParams> m_query;
+    GC::Ref<URLSearchParams> m_query;
 };
 
 bool host_is_domain(URL::Host const&);
diff --git a/Libraries/LibWeb/DOMURL/URLSearchParams.cpp b/Libraries/LibWeb/DOMURL/URLSearchParams.cpp
index 6cd520a364f..d2d8ce07ed7 100644
--- a/Libraries/LibWeb/DOMURL/URLSearchParams.cpp
+++ b/Libraries/LibWeb/DOMURL/URLSearchParams.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::DOMURL {
 
-JS_DEFINE_ALLOCATOR(URLSearchParams);
+GC_DEFINE_ALLOCATOR(URLSearchParams);
 
 URLSearchParams::URLSearchParams(JS::Realm& realm, Vector<QueryParam> list)
     : PlatformObject(realm)
@@ -125,13 +125,13 @@ Vector<QueryParam> url_decode(StringView input)
     return output;
 }
 
-JS::NonnullGCPtr<URLSearchParams> URLSearchParams::create(JS::Realm& realm, Vector<QueryParam> list)
+GC::Ref<URLSearchParams> URLSearchParams::create(JS::Realm& realm, Vector<QueryParam> list)
 {
     return realm.create<URLSearchParams>(realm, move(list));
 }
 
 // https://url.spec.whatwg.org/#urlsearchparams-initialize
-JS::NonnullGCPtr<URLSearchParams> URLSearchParams::create(JS::Realm& realm, StringView init)
+GC::Ref<URLSearchParams> URLSearchParams::create(JS::Realm& realm, StringView init)
 {
     // NOTE: We skip the other steps since we know it is a string at this point.
     // b. Set query’s list to the result of parsing init.
@@ -140,7 +140,7 @@ JS::NonnullGCPtr<URLSearchParams> URLSearchParams::create(JS::Realm& realm, Stri
 
 // https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams
 // https://url.spec.whatwg.org/#urlsearchparams-initialize
-WebIDL::ExceptionOr<JS::NonnullGCPtr<URLSearchParams>> URLSearchParams::construct_impl(JS::Realm& realm, Variant<Vector<Vector<String>>, OrderedHashMap<String, String>, String> const& init)
+WebIDL::ExceptionOr<GC::Ref<URLSearchParams>> URLSearchParams::construct_impl(JS::Realm& realm, Variant<Vector<Vector<String>>, OrderedHashMap<String, String>, String> const& init)
 {
     auto& vm = realm.vm();
 
diff --git a/Libraries/LibWeb/DOMURL/URLSearchParams.h b/Libraries/LibWeb/DOMURL/URLSearchParams.h
index 47cb5deeef9..b886aa94fee 100644
--- a/Libraries/LibWeb/DOMURL/URLSearchParams.h
+++ b/Libraries/LibWeb/DOMURL/URLSearchParams.h
@@ -21,12 +21,12 @@ Vector<QueryParam> url_decode(StringView);
 
 class URLSearchParams : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(URLSearchParams, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(URLSearchParams);
+    GC_DECLARE_ALLOCATOR(URLSearchParams);
 
 public:
-    static JS::NonnullGCPtr<URLSearchParams> create(JS::Realm&, StringView);
-    static JS::NonnullGCPtr<URLSearchParams> create(JS::Realm&, Vector<QueryParam> list);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<URLSearchParams>> construct_impl(JS::Realm&, Variant<Vector<Vector<String>>, OrderedHashMap<String, String>, String> const& init);
+    static GC::Ref<URLSearchParams> create(JS::Realm&, StringView);
+    static GC::Ref<URLSearchParams> create(JS::Realm&, Vector<QueryParam> list);
+    static WebIDL::ExceptionOr<GC::Ref<URLSearchParams>> construct_impl(JS::Realm&, Variant<Vector<Vector<String>>, OrderedHashMap<String, String>, String> const& init);
 
     virtual ~URLSearchParams() override;
 
@@ -57,7 +57,7 @@ private:
     void update();
 
     Vector<QueryParam> m_list;
-    JS::GCPtr<DOMURL> m_url;
+    GC::Ptr<DOMURL> m_url;
 };
 
 }
diff --git a/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.cpp b/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.cpp
index 9f030334e38..a530736301c 100644
--- a/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.cpp
+++ b/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.cpp
@@ -23,9 +23,9 @@ void Intrinsics::create_web_prototype_and_constructor<URLSearchParamsIteratorPro
 
 namespace Web::DOMURL {
 
-JS_DEFINE_ALLOCATOR(URLSearchParamsIterator);
+GC_DEFINE_ALLOCATOR(URLSearchParamsIterator);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<URLSearchParamsIterator>> URLSearchParamsIterator::create(URLSearchParams const& url_search_params, JS::Object::PropertyKind iteration_kind)
+WebIDL::ExceptionOr<GC::Ref<URLSearchParamsIterator>> URLSearchParamsIterator::create(URLSearchParams const& url_search_params, JS::Object::PropertyKind iteration_kind)
 {
     return url_search_params.realm().create<URLSearchParamsIterator>(url_search_params, iteration_kind);
 }
diff --git a/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.h b/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.h
index 9d6957c1c77..9f10aebbc75 100644
--- a/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.h
+++ b/Libraries/LibWeb/DOMURL/URLSearchParamsIterator.h
@@ -13,10 +13,10 @@ namespace Web::DOMURL {
 
 class URLSearchParamsIterator : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(URLSearchParamsIterator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(URLSearchParamsIterator);
+    GC_DECLARE_ALLOCATOR(URLSearchParamsIterator);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<URLSearchParamsIterator>> create(URLSearchParams const&, JS::Object::PropertyKind iteration_kind);
+    static WebIDL::ExceptionOr<GC::Ref<URLSearchParamsIterator>> create(URLSearchParams const&, JS::Object::PropertyKind iteration_kind);
 
     virtual ~URLSearchParamsIterator() override;
 
@@ -28,7 +28,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<URLSearchParams const> m_url_search_params;
+    GC::Ref<URLSearchParams const> m_url_search_params;
     JS::Object::PropertyKind m_iteration_kind;
     size_t m_index { 0 };
 };
diff --git a/Libraries/LibWeb/Encoding/TextDecoder.cpp b/Libraries/LibWeb/Encoding/TextDecoder.cpp
index 97b036e6f9d..9b86efb5b11 100644
--- a/Libraries/LibWeb/Encoding/TextDecoder.cpp
+++ b/Libraries/LibWeb/Encoding/TextDecoder.cpp
@@ -15,10 +15,10 @@
 
 namespace Web::Encoding {
 
-JS_DEFINE_ALLOCATOR(TextDecoder);
+GC_DEFINE_ALLOCATOR(TextDecoder);
 
 // https://encoding.spec.whatwg.org/#dom-textdecoder
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TextDecoder>> TextDecoder::construct_impl(JS::Realm& realm, FlyString label, Optional<TextDecoderOptions> const& options)
+WebIDL::ExceptionOr<GC::Ref<TextDecoder>> TextDecoder::construct_impl(JS::Realm& realm, FlyString label, Optional<TextDecoderOptions> const& options)
 {
     auto& vm = realm.vm();
 
@@ -66,7 +66,7 @@ void TextDecoder::initialize(JS::Realm& realm)
 }
 
 // https://encoding.spec.whatwg.org/#dom-textdecoder-decode
-WebIDL::ExceptionOr<String> TextDecoder::decode(Optional<JS::Handle<WebIDL::BufferSource>> const& input, Optional<TextDecodeOptions> const&) const
+WebIDL::ExceptionOr<String> TextDecoder::decode(Optional<GC::Root<WebIDL::BufferSource>> const& input, Optional<TextDecodeOptions> const&) const
 {
     if (!input.has_value())
         return TRY_OR_THROW_OOM(vm(), m_decoder.to_utf8({}));
diff --git a/Libraries/LibWeb/Encoding/TextDecoder.h b/Libraries/LibWeb/Encoding/TextDecoder.h
index 72659873add..025fb0b0e34 100644
--- a/Libraries/LibWeb/Encoding/TextDecoder.h
+++ b/Libraries/LibWeb/Encoding/TextDecoder.h
@@ -30,14 +30,14 @@ struct TextDecodeOptions {
 // https://encoding.spec.whatwg.org/#textdecoder
 class TextDecoder : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TextDecoder, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TextDecoder);
+    GC_DECLARE_ALLOCATOR(TextDecoder);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TextDecoder>> construct_impl(JS::Realm&, FlyString encoding, Optional<TextDecoderOptions> const& options = {});
+    static WebIDL::ExceptionOr<GC::Ref<TextDecoder>> construct_impl(JS::Realm&, FlyString encoding, Optional<TextDecoderOptions> const& options = {});
 
     virtual ~TextDecoder() override;
 
-    WebIDL::ExceptionOr<String> decode(Optional<JS::Handle<WebIDL::BufferSource>> const&, Optional<TextDecodeOptions> const& options = {}) const;
+    WebIDL::ExceptionOr<String> decode(Optional<GC::Root<WebIDL::BufferSource>> const&, Optional<TextDecodeOptions> const& options = {}) const;
 
     FlyString const& encoding() const { return m_encoding; }
     bool fatal() const { return m_fatal; }
diff --git a/Libraries/LibWeb/Encoding/TextEncoder.cpp b/Libraries/LibWeb/Encoding/TextEncoder.cpp
index 22b34c8917f..2d574ea5312 100644
--- a/Libraries/LibWeb/Encoding/TextEncoder.cpp
+++ b/Libraries/LibWeb/Encoding/TextEncoder.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::Encoding {
 
-JS_DEFINE_ALLOCATOR(TextEncoder);
+GC_DEFINE_ALLOCATOR(TextEncoder);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TextEncoder>> TextEncoder::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<TextEncoder>> TextEncoder::construct_impl(JS::Realm& realm)
 {
     return realm.create<TextEncoder>(realm);
 }
@@ -33,7 +33,7 @@ void TextEncoder::initialize(JS::Realm& realm)
 }
 
 // https://encoding.spec.whatwg.org/#dom-textencoder-encode
-JS::NonnullGCPtr<JS::Uint8Array> TextEncoder::encode(String const& input) const
+GC::Ref<JS::Uint8Array> TextEncoder::encode(String const& input) const
 {
     // NOTE: The AK::String is always UTF-8, so most of these steps are no-ops.
     // 1. Convert input to an I/O queue of scalar values.
@@ -51,7 +51,7 @@ JS::NonnullGCPtr<JS::Uint8Array> TextEncoder::encode(String const& input) const
 }
 
 // https://encoding.spec.whatwg.org/#dom-textencoder-encodeinto
-TextEncoderEncodeIntoResult TextEncoder::encode_into(String const& source, JS::Handle<WebIDL::BufferSource> const& destination) const
+TextEncoderEncodeIntoResult TextEncoder::encode_into(String const& source, GC::Root<WebIDL::BufferSource> const& destination) const
 {
     auto& data = destination->viewed_array_buffer()->buffer();
 
diff --git a/Libraries/LibWeb/Encoding/TextEncoder.h b/Libraries/LibWeb/Encoding/TextEncoder.h
index 463cd6033a7..a82337686f6 100644
--- a/Libraries/LibWeb/Encoding/TextEncoder.h
+++ b/Libraries/LibWeb/Encoding/TextEncoder.h
@@ -26,15 +26,15 @@ struct TextEncoderEncodeIntoResult {
 // https://encoding.spec.whatwg.org/#textencoder
 class TextEncoder final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TextEncoder, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TextEncoder);
+    GC_DECLARE_ALLOCATOR(TextEncoder);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TextEncoder>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<TextEncoder>> construct_impl(JS::Realm&);
 
     virtual ~TextEncoder() override;
 
-    JS::NonnullGCPtr<JS::Uint8Array> encode(String const& input) const;
-    TextEncoderEncodeIntoResult encode_into(String const& source, JS::Handle<WebIDL::BufferSource> const& destination) const;
+    GC::Ref<JS::Uint8Array> encode(String const& input) const;
+    TextEncoderEncodeIntoResult encode_into(String const& source, GC::Root<WebIDL::BufferSource> const& destination) const;
 
     static FlyString const& encoding();
 
diff --git a/Libraries/LibWeb/EntriesAPI/FileSystemEntry.cpp b/Libraries/LibWeb/EntriesAPI/FileSystemEntry.cpp
index ac8dafe1923..ed450a2a93e 100644
--- a/Libraries/LibWeb/EntriesAPI/FileSystemEntry.cpp
+++ b/Libraries/LibWeb/EntriesAPI/FileSystemEntry.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::EntriesAPI {
 
-JS_DEFINE_ALLOCATOR(FileSystemEntry);
+GC_DEFINE_ALLOCATOR(FileSystemEntry);
 
-JS::NonnullGCPtr<FileSystemEntry> FileSystemEntry::create(JS::Realm& realm, EntryType entry_type, ByteString name)
+GC::Ref<FileSystemEntry> FileSystemEntry::create(JS::Realm& realm, EntryType entry_type, ByteString name)
 {
     return realm.create<FileSystemEntry>(realm, entry_type, name);
 }
diff --git a/Libraries/LibWeb/EntriesAPI/FileSystemEntry.h b/Libraries/LibWeb/EntriesAPI/FileSystemEntry.h
index d01cfa32902..5054e550678 100644
--- a/Libraries/LibWeb/EntriesAPI/FileSystemEntry.h
+++ b/Libraries/LibWeb/EntriesAPI/FileSystemEntry.h
@@ -17,10 +17,10 @@ enum class EntryType {
 
 class FileSystemEntry final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(FileSystemEntry, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(FileSystemEntry);
+    GC_DECLARE_ALLOCATOR(FileSystemEntry);
 
 public:
-    static JS::NonnullGCPtr<FileSystemEntry> create(JS::Realm&, EntryType entry_type, ByteString name);
+    static GC::Ref<FileSystemEntry> create(JS::Realm&, EntryType entry_type, ByteString name);
     virtual ~FileSystemEntry() override = default;
 
     bool is_file() const;
diff --git a/Libraries/LibWeb/EventTiming/PerformanceEventTiming.cpp b/Libraries/LibWeb/EventTiming/PerformanceEventTiming.cpp
index 4380c88dba7..95e1f25f50b 100644
--- a/Libraries/LibWeb/EventTiming/PerformanceEventTiming.cpp
+++ b/Libraries/LibWeb/EventTiming/PerformanceEventTiming.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::EventTiming {
 
-JS_DEFINE_ALLOCATOR(PerformanceEventTiming);
+GC_DEFINE_ALLOCATOR(PerformanceEventTiming);
 
 // https://www.w3.org/TR/event-timing/#sec-init-event-timing
 PerformanceEventTiming::PerformanceEventTiming(JS::Realm& realm, String const& name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration,
@@ -51,7 +51,7 @@ bool PerformanceEventTiming::cancelable() const
     return m_cancelable;
 }
 
-JS::ThrowCompletionOr<JS::GCPtr<DOM::Node>> PerformanceEventTiming::target()
+JS::ThrowCompletionOr<GC::Ptr<DOM::Node>> PerformanceEventTiming::target()
 {
     dbgln("FIXME: Implement PerformanceEventTiming::PeformanceEventTiming target()");
     return nullptr;
diff --git a/Libraries/LibWeb/EventTiming/PerformanceEventTiming.h b/Libraries/LibWeb/EventTiming/PerformanceEventTiming.h
index d0f06341915..4a34d9d4e11 100644
--- a/Libraries/LibWeb/EventTiming/PerformanceEventTiming.h
+++ b/Libraries/LibWeb/EventTiming/PerformanceEventTiming.h
@@ -15,7 +15,7 @@ namespace Web::EventTiming {
 // https://www.w3.org/TR/event-timing/#sec-performance-event-timing
 class PerformanceEventTiming final : public PerformanceTimeline::PerformanceEntry {
     WEB_PLATFORM_OBJECT(PerformanceEventTiming, PerformanceTimeline::PerformanceEntry);
-    JS_DECLARE_ALLOCATOR(PerformanceEventTiming);
+    GC_DECLARE_ALLOCATOR(PerformanceEventTiming);
 
 public:
     virtual ~PerformanceEventTiming();
@@ -23,7 +23,7 @@ public:
     HighResolutionTime::DOMHighResTimeStamp processing_start() const;
     HighResolutionTime::DOMHighResTimeStamp processing_end() const;
     bool cancelable() const;
-    JS::ThrowCompletionOr<JS::GCPtr<DOM::Node>> target();
+    JS::ThrowCompletionOr<GC::Ptr<DOM::Node>> target();
     unsigned long long interaction_id();
 
     // from the registry:
@@ -44,13 +44,13 @@ private:
     // this is the only PerformanceEntry that has two event types it could represent
     // That complicates implementing the registry functions if they remain static
     FlyString m_entry_type;
-    JS::GCPtr<DOM::EventTarget> m_event_target;
+    GC::Ptr<DOM::EventTarget> m_event_target;
     HighResolutionTime::DOMHighResTimeStamp m_start_time;
     HighResolutionTime::DOMHighResTimeStamp m_processing_start;
     bool m_cancelable;
     unsigned long long m_interaction_id;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PerformanceEventTiming>> construct_impl(DOM::Event const&, HighResolutionTime::DOMHighResTimeStamp, unsigned long long);
+    static WebIDL::ExceptionOr<GC::Ref<PerformanceEventTiming>> construct_impl(DOM::Event const&, HighResolutionTime::DOMHighResTimeStamp, unsigned long long);
     virtual void initialize(JS::Realm&) override;
 
     PerformanceTimeline::ShouldAddEntry should_add_performance_event_timing() const;
diff --git a/Libraries/LibWeb/Fetch/Body.cpp b/Libraries/LibWeb/Fetch/Body.cpp
index 76bd196e2e9..36374998156 100644
--- a/Libraries/LibWeb/Fetch/Body.cpp
+++ b/Libraries/LibWeb/Fetch/Body.cpp
@@ -38,7 +38,7 @@ bool BodyMixin::is_unusable() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-body
-JS::GCPtr<Streams::ReadableStream> BodyMixin::body() const
+GC::Ptr<Streams::ReadableStream> BodyMixin::body() const
 {
     // The body getter steps are to return null if this’s body is null; otherwise this’s body’s stream.
     auto const& body = body_impl();
@@ -54,7 +54,7 @@ bool BodyMixin::body_used() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::array_buffer() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::array_buffer() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -64,7 +64,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::array_buffer()
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-blob
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::blob() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::blob() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -74,7 +74,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::blob() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-bytes
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::bytes() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::bytes() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -84,7 +84,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::bytes() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-formdata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::form_data() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::form_data() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -94,7 +94,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::form_data() co
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-json
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::json() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::json() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -104,7 +104,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::json() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-body-text
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> BodyMixin::text() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> BodyMixin::text() const
 {
     auto& vm = Bindings::main_thread_vm();
     auto& realm = *vm.current_realm();
@@ -174,7 +174,7 @@ WebIDL::ExceptionOr<JS::Value> package_data(JS::Realm& realm, ByteBuffer bytes,
 }
 
 // https://fetch.spec.whatwg.org/#concept-body-consume-body
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> consume_body(JS::Realm& realm, BodyMixin const& object, PackageDataType type)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> consume_body(JS::Realm& realm, BodyMixin const& object, PackageDataType type)
 {
     // 1. If object is unusable, then return a promise rejected with a TypeError.
     if (object.is_unusable()) {
@@ -186,8 +186,8 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> consume_body(JS::Realm& r
     auto promise = WebIDL::create_promise(realm);
 
     // 3. Let errorSteps given error be to reject promise with error.
-    // NOTE: `promise` and `realm` is protected by JS::HeapFunction.
-    auto error_steps = JS::create_heap_function(realm.heap(), [promise, &realm](JS::Value error) {
+    // NOTE: `promise` and `realm` is protected by GC::HeapFunction.
+    auto error_steps = GC::create_function(realm.heap(), [promise, &realm](JS::Value error) {
         // AD-HOC: An execution context is required for Promise's reject function.
         HTML::TemporaryExecutionContext execution_context { realm };
         WebIDL::reject_promise(realm, promise, error);
@@ -195,9 +195,9 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> consume_body(JS::Realm& r
 
     // 4. Let successSteps given a byte sequence data be to resolve promise with the result of running convertBytesToJSValue
     //    with data. If that threw an exception, then run errorSteps with that exception.
-    // NOTE: `promise`, `realm` and `object` is protected by JS::HeapFunction.
+    // NOTE: `promise`, `realm` and `object` is protected by GC::HeapFunction.
     // FIXME: Refactor this to the new version of the spec introduced with https://github.com/whatwg/fetch/commit/464326e8eb6a602122c030cd40042480a3c0e265
-    auto success_steps = JS::create_heap_function(realm.heap(), [promise, &realm, &object, type](ByteBuffer data) {
+    auto success_steps = GC::create_function(realm.heap(), [promise, &realm, &object, type](ByteBuffer data) {
         auto& vm = realm.vm();
 
         // AD-HOC: An execution context is required for Promise's reject function and JSON.parse.
@@ -224,7 +224,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> consume_body(JS::Realm& r
     }
     // 6. Otherwise, fully read object’s body given successSteps, errorSteps, and object’s relevant global object.
     else {
-        body->fully_read(realm, success_steps, error_steps, JS::NonnullGCPtr { HTML::relevant_global_object(object.as_platform_object()) });
+        body->fully_read(realm, success_steps, error_steps, GC::Ref { HTML::relevant_global_object(object.as_platform_object()) });
     }
 
     // 7. Return promise.
diff --git a/Libraries/LibWeb/Fetch/Body.h b/Libraries/LibWeb/Fetch/Body.h
index f78a35c903e..6cef9d04a0d 100644
--- a/Libraries/LibWeb/Fetch/Body.h
+++ b/Libraries/LibWeb/Fetch/Body.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Fetch {
@@ -29,25 +29,25 @@ public:
     virtual ~BodyMixin();
 
     virtual Optional<MimeSniff::MimeType> mime_type_impl() const = 0;
-    virtual JS::GCPtr<Infrastructure::Body> body_impl() = 0;
-    virtual JS::GCPtr<Infrastructure::Body const> body_impl() const = 0;
+    virtual GC::Ptr<Infrastructure::Body> body_impl() = 0;
+    virtual GC::Ptr<Infrastructure::Body const> body_impl() const = 0;
     virtual Bindings::PlatformObject& as_platform_object() = 0;
     virtual Bindings::PlatformObject const& as_platform_object() const = 0;
 
     [[nodiscard]] bool is_unusable() const;
-    [[nodiscard]] JS::GCPtr<Streams::ReadableStream> body() const;
+    [[nodiscard]] GC::Ptr<Streams::ReadableStream> body() const;
     [[nodiscard]] bool body_used() const;
 
     // JS API functions
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> array_buffer() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> blob() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> bytes() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> form_data() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> json() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> text() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> array_buffer() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> blob() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> bytes() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> form_data() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> json() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> text() const;
 };
 
 [[nodiscard]] WebIDL::ExceptionOr<JS::Value> package_data(JS::Realm&, ByteBuffer, PackageDataType, Optional<MimeSniff::MimeType> const&);
-[[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> consume_body(JS::Realm&, BodyMixin const&, PackageDataType);
+[[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> consume_body(JS::Realm&, BodyMixin const&, PackageDataType);
 
 }
diff --git a/Libraries/LibWeb/Fetch/BodyInit.cpp b/Libraries/LibWeb/Fetch/BodyInit.cpp
index 30c4ae10aac..7fc993cdbdc 100644
--- a/Libraries/LibWeb/Fetch/BodyInit.cpp
+++ b/Libraries/LibWeb/Fetch/BodyInit.cpp
@@ -26,7 +26,7 @@ namespace Web::Fetch {
 WebIDL::ExceptionOr<Infrastructure::BodyWithType> safely_extract_body(JS::Realm& realm, BodyInitOrReadableBytes const& object)
 {
     // 1. If object is a ReadableStream object, then:
-    if (auto const* stream = object.get_pointer<JS::Handle<Streams::ReadableStream>>()) {
+    if (auto const* stream = object.get_pointer<GC::Root<Streams::ReadableStream>>()) {
         // 1. Assert: object is neither disturbed nor locked.
         VERIFY(!((*stream)->is_disturbed() || (*stream)->is_locked()));
     }
@@ -43,14 +43,14 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
     auto& vm = realm.vm();
 
     // 1. Let stream be null.
-    JS::GCPtr<Streams::ReadableStream> stream;
+    GC::Ptr<Streams::ReadableStream> stream;
 
     // 2. If object is a ReadableStream object, then set stream to object.
-    if (auto const* stream_handle = object.get_pointer<JS::Handle<Streams::ReadableStream>>()) {
+    if (auto const* stream_handle = object.get_pointer<GC::Root<Streams::ReadableStream>>()) {
         stream = const_cast<Streams::ReadableStream*>(stream_handle->cell());
     }
     // 3. Otherwise, if object is a Blob object, set stream to the result of running object’s get stream.
-    else if (auto const* blob_handle = object.get_pointer<JS::Handle<FileAPI::Blob>>()) {
+    else if (auto const* blob_handle = object.get_pointer<GC::Root<FileAPI::Blob>>()) {
         stream = blob_handle->cell()->get_stream();
     }
     // 4. Otherwise, set stream to a new ReadableStream object, and set up stream with byte reading support.
@@ -76,7 +76,7 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
 
     // 10. Switch on object.
     TRY(object.visit(
-        [&](JS::Handle<FileAPI::Blob> const& blob) -> WebIDL::ExceptionOr<void> {
+        [&](GC::Root<FileAPI::Blob> const& blob) -> WebIDL::ExceptionOr<void> {
             // Set source to object.
             source = blob;
             // Set length to object’s size.
@@ -91,12 +91,12 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
             source = MUST(ByteBuffer::copy(bytes));
             return {};
         },
-        [&](JS::Handle<WebIDL::BufferSource> const& buffer_source) -> WebIDL::ExceptionOr<void> {
+        [&](GC::Root<WebIDL::BufferSource> const& buffer_source) -> WebIDL::ExceptionOr<void> {
             // Set source to a copy of the bytes held by object.
             source = MUST(WebIDL::get_buffer_source_copy(*buffer_source->raw_object()));
             return {};
         },
-        [&](JS::Handle<XHR::FormData> const& form_data) -> WebIDL::ExceptionOr<void> {
+        [&](GC::Root<XHR::FormData> const& form_data) -> WebIDL::ExceptionOr<void> {
             // Set action to this step: run the multipart/form-data encoding algorithm, with object’s entry list and UTF-8.
             auto serialized_form_data = MUST(HTML::serialize_to_multipart_form_data(form_data->entry_list()));
             // Set source to object.
@@ -106,7 +106,7 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
             type = MUST(ByteBuffer::copy(MUST(String::formatted("multipart/form-data; boundary={}"sv, serialized_form_data.boundary)).bytes()));
             return {};
         },
-        [&](JS::Handle<DOMURL::URLSearchParams> const& url_search_params) -> WebIDL::ExceptionOr<void> {
+        [&](GC::Root<DOMURL::URLSearchParams> const& url_search_params) -> WebIDL::ExceptionOr<void> {
             // Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list.
             auto search_params_string = url_search_params->to_string();
             source = MUST(ByteBuffer::copy(search_params_string.bytes()));
@@ -122,7 +122,7 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
             type = MUST(ByteBuffer::copy("text/plain;charset=UTF-8"sv.bytes()));
             return {};
         },
-        [&](JS::Handle<Streams::ReadableStream> const& stream) -> WebIDL::ExceptionOr<void> {
+        [&](GC::Root<Streams::ReadableStream> const& stream) -> WebIDL::ExceptionOr<void> {
             // If keepalive is true, then throw a TypeError.
             if (keepalive)
                 return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Cannot extract body from stream when keepalive is set"sv };
@@ -145,7 +145,7 @@ WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm& realm,
 
     // 12. If action is non-null, then run these steps in parallel:
     if (action) {
-        Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, stream, action = move(action)] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, stream, action = move(action)] {
             HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
             // 1. Run action.
diff --git a/Libraries/LibWeb/Fetch/BodyInit.h b/Libraries/LibWeb/Fetch/BodyInit.h
index 851661c94a6..2b49913e821 100644
--- a/Libraries/LibWeb/Fetch/BodyInit.h
+++ b/Libraries/LibWeb/Fetch/BodyInit.h
@@ -14,9 +14,9 @@
 namespace Web::Fetch {
 
 // https://fetch.spec.whatwg.org/#bodyinit
-using BodyInit = Variant<JS::Handle<Streams::ReadableStream>, JS::Handle<FileAPI::Blob>, JS::Handle<WebIDL::BufferSource>, JS::Handle<XHR::FormData>, JS::Handle<DOMURL::URLSearchParams>, String>;
+using BodyInit = Variant<GC::Root<Streams::ReadableStream>, GC::Root<FileAPI::Blob>, GC::Root<WebIDL::BufferSource>, GC::Root<XHR::FormData>, GC::Root<DOMURL::URLSearchParams>, String>;
 
-using BodyInitOrReadableBytes = Variant<JS::Handle<Streams::ReadableStream>, JS::Handle<FileAPI::Blob>, JS::Handle<WebIDL::BufferSource>, JS::Handle<XHR::FormData>, JS::Handle<DOMURL::URLSearchParams>, String, ReadonlyBytes>;
+using BodyInitOrReadableBytes = Variant<GC::Root<Streams::ReadableStream>, GC::Root<FileAPI::Blob>, GC::Root<WebIDL::BufferSource>, GC::Root<XHR::FormData>, GC::Root<DOMURL::URLSearchParams>, String, ReadonlyBytes>;
 WebIDL::ExceptionOr<Infrastructure::BodyWithType> safely_extract_body(JS::Realm&, BodyInitOrReadableBytes const&);
 WebIDL::ExceptionOr<Infrastructure::BodyWithType> extract_body(JS::Realm&, BodyInitOrReadableBytes const&, bool keepalive = false);
 
diff --git a/Libraries/LibWeb/Fetch/FetchMethod.cpp b/Libraries/LibWeb/Fetch/FetchMethod.cpp
index 05067f95d35..dea073940ce 100644
--- a/Libraries/LibWeb/Fetch/FetchMethod.cpp
+++ b/Libraries/LibWeb/Fetch/FetchMethod.cpp
@@ -25,7 +25,7 @@
 namespace Web::Fetch {
 
 // https://fetch.spec.whatwg.org/#dom-global-fetch
-JS::NonnullGCPtr<WebIDL::Promise> fetch(JS::VM& vm, RequestInfo const& input, RequestInit const& init)
+GC::Ref<WebIDL::Promise> fetch(JS::VM& vm, RequestInfo const& input, RequestInit const& init)
 {
     auto& realm = *vm.current_realm();
 
@@ -61,7 +61,7 @@ JS::NonnullGCPtr<WebIDL::Promise> fetch(JS::VM& vm, RequestInfo const& input, Re
     (void)global_object;
 
     // 7. Let responseObject be null.
-    JS::GCPtr<Response> response_object;
+    GC::Ptr<Response> response_object;
 
     // 8. Let relevantRealm be this’s relevant Realm.
     // NOTE: This assumes that the running execution context is for the fetch() function call.
@@ -73,14 +73,14 @@ JS::NonnullGCPtr<WebIDL::Promise> fetch(JS::VM& vm, RequestInfo const& input, Re
     auto locally_aborted = Fetching::RefCountedFlag::create(false);
 
     // 10. Let controller be null.
-    JS::GCPtr<Infrastructure::FetchController> controller;
+    GC::Ptr<Infrastructure::FetchController> controller;
 
     // NOTE: Step 11 is done out of order so that the controller is non-null when we capture the GCPtr by copy in the abort algorithm lambda.
     //       This is not observable, AFAICT.
 
     // 12. Set controller to the result of calling fetch given request and processResponse given response being these
     //     steps:
-    auto process_response = [locally_aborted, promise_capability, request, response_object, &relevant_realm](JS::NonnullGCPtr<Infrastructure::Response> response) mutable {
+    auto process_response = [locally_aborted, promise_capability, request, response_object, &relevant_realm](GC::Ref<Infrastructure::Response> response) mutable {
         // 1. If locallyAborted is true, then abort these steps.
         if (locally_aborted->value())
             return;
@@ -153,7 +153,7 @@ JS::NonnullGCPtr<WebIDL::Promise> fetch(JS::VM& vm, RequestInfo const& input, Re
 }
 
 // https://fetch.spec.whatwg.org/#abort-fetch
-void abort_fetch(JS::Realm& realm, WebIDL::Promise const& promise, JS::NonnullGCPtr<Infrastructure::Request> request, JS::GCPtr<Response> response_object, JS::Value error)
+void abort_fetch(JS::Realm& realm, WebIDL::Promise const& promise, GC::Ref<Infrastructure::Request> request, GC::Ptr<Response> response_object, JS::Value error)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Aborting fetch with: request @ {}, error = {}", request.ptr(), error);
 
@@ -162,7 +162,7 @@ void abort_fetch(JS::Realm& realm, WebIDL::Promise const& promise, JS::NonnullGC
     WebIDL::reject_promise(realm, promise, error);
 
     // 2. If request’s body is non-null and is readable, then cancel request’s body with error.
-    if (auto* body = request->body().get_pointer<JS::NonnullGCPtr<Infrastructure::Body>>(); body != nullptr && (*body)->stream()->is_readable()) {
+    if (auto* body = request->body().get_pointer<GC::Ref<Infrastructure::Body>>(); body != nullptr && (*body)->stream()->is_readable()) {
         // TODO: Implement cancelling streams
         (void)error;
     }
diff --git a/Libraries/LibWeb/Fetch/FetchMethod.h b/Libraries/LibWeb/Fetch/FetchMethod.h
index f6e27dd614c..9b83f7e47a9 100644
--- a/Libraries/LibWeb/Fetch/FetchMethod.h
+++ b/Libraries/LibWeb/Fetch/FetchMethod.h
@@ -7,14 +7,14 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Fetch/Request.h>
 #include <LibWeb/WebIDL/Promise.h>
 
 namespace Web::Fetch {
 
-JS::NonnullGCPtr<WebIDL::Promise> fetch(JS::VM&, RequestInfo const& input, RequestInit const& init = {});
-void abort_fetch(JS::Realm&, WebIDL::Promise const&, JS::NonnullGCPtr<Infrastructure::Request>, JS::GCPtr<Response>, JS::Value error);
+GC::Ref<WebIDL::Promise> fetch(JS::VM&, RequestInfo const& input, RequestInit const& init = {});
+void abort_fetch(JS::Realm&, WebIDL::Promise const&, GC::Ref<Infrastructure::Request>, GC::Ptr<Response>, JS::Value error);
 
 }
diff --git a/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.cpp b/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.cpp
index c8b98d4c252..9521b9c5bea 100644
--- a/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.cpp
+++ b/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Fetch/Fetching/FetchedDataReceiver.h>
 #include <LibWeb/Fetch/Infrastructure/FetchParams.h>
@@ -16,9 +16,9 @@
 
 namespace Web::Fetch::Fetching {
 
-JS_DEFINE_ALLOCATOR(FetchedDataReceiver);
+GC_DEFINE_ALLOCATOR(FetchedDataReceiver);
 
-FetchedDataReceiver::FetchedDataReceiver(JS::NonnullGCPtr<Infrastructure::FetchParams const> fetch_params, JS::NonnullGCPtr<Streams::ReadableStream> stream)
+FetchedDataReceiver::FetchedDataReceiver(GC::Ref<Infrastructure::FetchParams const> fetch_params, GC::Ref<Streams::ReadableStream> stream)
     : m_fetch_params(fetch_params)
     , m_stream(stream)
 {
@@ -34,7 +34,7 @@ void FetchedDataReceiver::visit_edges(Visitor& visitor)
     visitor.visit(m_pending_promise);
 }
 
-void FetchedDataReceiver::set_pending_promise(JS::NonnullGCPtr<WebIDL::Promise> promise)
+void FetchedDataReceiver::set_pending_promise(GC::Ref<WebIDL::Promise> promise)
 {
     auto had_pending_promise = m_pending_promise != nullptr;
     m_pending_promise = promise;
@@ -63,8 +63,8 @@ void FetchedDataReceiver::on_data_received(ReadonlyBytes bytes)
     // 3. Queue a fetch task to run the following steps, with fetchParams’s task destination.
     Infrastructure::queue_fetch_task(
         m_fetch_params->controller(),
-        m_fetch_params->task_destination().get<JS::NonnullGCPtr<JS::Object>>(),
-        JS::create_heap_function(heap(), [this, bytes = MUST(ByteBuffer::copy(bytes))]() mutable {
+        m_fetch_params->task_destination().get<GC::Ref<JS::Object>>(),
+        GC::create_function(heap(), [this, bytes = MUST(ByteBuffer::copy(bytes))]() mutable {
             HTML::TemporaryExecutionContext execution_context { m_stream->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
             // 1. Pull from bytes buffer into stream.
diff --git a/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.h b/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.h
index 604baa1f152..87095827190 100644
--- a/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.h
+++ b/Libraries/LibWeb/Fetch/Fetching/FetchedDataReceiver.h
@@ -7,30 +7,30 @@
 #pragma once
 
 #include <AK/ByteBuffer.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Fetch::Fetching {
 
 class FetchedDataReceiver final : public JS::Cell {
-    JS_CELL(FetchedDataReceiver, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchedDataReceiver);
+    GC_CELL(FetchedDataReceiver, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchedDataReceiver);
 
 public:
     virtual ~FetchedDataReceiver() override;
 
-    void set_pending_promise(JS::NonnullGCPtr<WebIDL::Promise>);
+    void set_pending_promise(GC::Ref<WebIDL::Promise>);
     void on_data_received(ReadonlyBytes);
 
 private:
-    FetchedDataReceiver(JS::NonnullGCPtr<Infrastructure::FetchParams const>, JS::NonnullGCPtr<Streams::ReadableStream>);
+    FetchedDataReceiver(GC::Ref<Infrastructure::FetchParams const>, GC::Ref<Streams::ReadableStream>);
 
     virtual void visit_edges(Visitor& visitor) override;
 
-    JS::NonnullGCPtr<Infrastructure::FetchParams const> m_fetch_params;
-    JS::NonnullGCPtr<Streams::ReadableStream> m_stream;
-    JS::GCPtr<WebIDL::Promise> m_pending_promise;
+    GC::Ref<Infrastructure::FetchParams const> m_fetch_params;
+    GC::Ref<Streams::ReadableStream> m_stream;
+    GC::Ptr<WebIDL::Promise> m_pending_promise;
     ByteBuffer m_buffer;
 };
 
diff --git a/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp b/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp
index a3df8c1f536..8b647c1a1d8 100644
--- a/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp
+++ b/Libraries/LibWeb/Fetch/Fetching/Fetching.cpp
@@ -73,7 +73,7 @@ bool g_http_cache_enabled;
     })
 
 // https://fetch.spec.whatwg.org/#concept-fetch
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS::Realm& realm, Infrastructure::Request& request, Infrastructure::FetchAlgorithms const& algorithms, UseParallelQueue use_parallel_queue)
+WebIDL::ExceptionOr<GC::Ref<Infrastructure::FetchController>> fetch(JS::Realm& realm, Infrastructure::Request& request, Infrastructure::FetchAlgorithms const& algorithms, UseParallelQueue use_parallel_queue)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'fetch' with: request @ {}", &request);
 
@@ -83,7 +83,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS:
     VERIFY(request.mode() == Infrastructure::Request::Mode::Navigate || !algorithms.process_early_hints_response());
 
     // 2. Let taskDestination be null.
-    JS::GCPtr<JS::Object> task_destination;
+    GC::Ptr<JS::Object> task_destination;
 
     // 3. Let crossOriginIsolatedCapability be false.
     auto cross_origin_isolated_capability = HTML::CanUseCrossOriginIsolatedAPIs::No;
@@ -147,7 +147,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS:
         // - request’s mode is "same-origin", "cors", or "no-cors"
         && (request.mode() == Infrastructure::Request::Mode::SameOrigin || request.mode() == Infrastructure::Request::Mode::CORS || request.mode() == Infrastructure::Request::Mode::NoCORS)
         // - request’s window is an environment settings object
-        && request.window().has<JS::GCPtr<HTML::EnvironmentSettingsObject>>()
+        && request.window().has<GC::Ptr<HTML::EnvironmentSettingsObject>>()
         // - request’s method is `GET`
         && StringView { request.method() }.equals_ignoring_ascii_case("GET"sv)
         // - request’s unsafe-request flag is not set or request’s header list is empty
@@ -157,7 +157,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS:
 
         // 2. Let onPreloadedResponseAvailable be an algorithm that runs the following step given a response
         //    response: set fetchParams’s preloaded response candidate to response.
-        auto on_preloaded_response_available = JS::create_heap_function(realm.heap(), [fetch_params](JS::NonnullGCPtr<Infrastructure::Response> response) {
+        auto on_preloaded_response_available = GC::create_function(realm.heap(), [fetch_params](GC::Ref<Infrastructure::Response> response) {
             fetch_params->set_preloaded_response_candidate(response);
         });
 
@@ -265,7 +265,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS:
 }
 
 // https://fetch.spec.whatwg.org/#concept-main-fetch
-WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, Recursive recursive)
+WebIDL::ExceptionOr<GC::Ptr<PendingResponse>> main_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, Recursive recursive)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'main fetch' with: fetch_params @ {}", &fetch_params);
 
@@ -275,7 +275,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
     auto request = fetch_params.request();
 
     // 2. Let response be null.
-    JS::GCPtr<Infrastructure::Response> response;
+    GC::Ptr<Infrastructure::Response> response;
 
     // 3. If request’s local-URLs-only flag is set and request’s current URL is not local, then set response to a
     //    network error.
@@ -333,21 +333,21 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
         request->current_url().set_scheme("https"_string);
     }
 
-    auto get_response = JS::create_heap_function(vm.heap(), [&realm, &vm, &fetch_params, request]() -> WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> {
+    auto get_response = GC::create_function(vm.heap(), [&realm, &vm, &fetch_params, request]() -> WebIDL::ExceptionOr<GC::Ref<PendingResponse>> {
         dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'main fetch' get_response() function");
 
         // -> fetchParams’s preloaded response candidate is not null
         if (!fetch_params.preloaded_response_candidate().has<Empty>()) {
             // 1. Wait until fetchParams’s preloaded response candidate is not "pending".
-            HTML::main_thread_event_loop().spin_until(JS::create_heap_function(vm.heap(), [&] {
+            HTML::main_thread_event_loop().spin_until(GC::create_function(vm.heap(), [&] {
                 return !fetch_params.preloaded_response_candidate().has<Infrastructure::FetchParams::PreloadedResponseCandidatePendingTag>();
             }));
 
             // 2. Assert: fetchParams’s preloaded response candidate is a response.
-            VERIFY(fetch_params.preloaded_response_candidate().has<JS::NonnullGCPtr<Infrastructure::Response>>());
+            VERIFY(fetch_params.preloaded_response_candidate().has<GC::Ref<Infrastructure::Response>>());
 
             // 3. Return fetchParams’s preloaded response candidate.
-            return PendingResponse::create(vm, request, fetch_params.preloaded_response_candidate().get<JS::NonnullGCPtr<Infrastructure::Response>>());
+            return PendingResponse::create(vm, request, fetch_params.preloaded_response_candidate().get<GC::Ref<Infrastructure::Response>>());
         }
         // -> request’s current URL’s origin is same origin with request’s origin, and request’s response tainting
         //    is "basic"
@@ -406,7 +406,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
 
             // 2. Let corsWithPreflightResponse be the result of running HTTP fetch given fetchParams and true.
             auto cors_with_preflight_response = TRY(http_fetch(realm, fetch_params, MakeCORSPreflight::Yes));
-            cors_with_preflight_response->when_loaded([returned_pending_response](JS::NonnullGCPtr<Infrastructure::Response> cors_with_preflight_response) {
+            cors_with_preflight_response->when_loaded([returned_pending_response](GC::Ref<Infrastructure::Response> cors_with_preflight_response) {
                 dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'main fetch' cors_with_preflight_response load callback");
                 // 3. If corsWithPreflightResponse is a network error, then clear cache entries using request.
                 if (cors_with_preflight_response->is_network_error()) {
@@ -441,7 +441,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
     }
 
     // 11. If recursive is false, then run the remaining steps in parallel.
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, &vm, &fetch_params, request, response, get_response] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, &vm, &fetch_params, request, response, get_response] {
         // 12. If response is null, then set response to the result of running the steps corresponding to the first
         //     matching statement:
         auto pending_response = PendingResponse::create(vm, request, Infrastructure::Response::create(vm));
@@ -451,7 +451,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
                 return;
             pending_response = pending_response_or_error.release_value();
         }
-        pending_response->when_loaded([&realm, &vm, &fetch_params, request, response, response_was_null = !response](JS::NonnullGCPtr<Infrastructure::Response> resolved_response) mutable {
+        pending_response->when_loaded([&realm, &vm, &fetch_params, request, response, response_was_null = !response](GC::Ref<Infrastructure::Response> resolved_response) mutable {
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'main fetch' pending_response load callback");
             if (response_was_null)
                 response = resolved_response;
@@ -480,7 +480,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
 
                 // 2. Set response to the following filtered response with response as its internal response, depending
                 //    on request’s response tainting:
-                response = [&]() -> JS::NonnullGCPtr<Infrastructure::Response> {
+                response = [&]() -> GC::Ref<Infrastructure::Response> {
                     switch (request->response_tainting()) {
                     // -> "basic"
                     case Infrastructure::Request::ResponseTainting::Basic:
@@ -503,7 +503,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
             // 15. Let internalResponse be response, if response is a network error, and response’s internal response
             //     otherwise.
             auto internal_response = response->is_network_error()
-                ? JS::NonnullGCPtr { *response }
+                ? GC::Ref { *response }
                 : static_cast<Infrastructure::FilteredResponse&>(*response).internal_response();
 
             // 16. If internalResponse’s URL list is empty, then set it to a clone of request’s URL list.
@@ -557,7 +557,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
             if (!request->integrity_metadata().is_empty()) {
                 // 1. Let processBodyError be this step: run fetch response handover given fetchParams and a network
                 //    error.
-                auto process_body_error = JS::create_heap_function(vm.heap(), [&realm, &vm, &fetch_params](JS::Value) {
+                auto process_body_error = GC::create_function(vm.heap(), [&realm, &vm, &fetch_params](JS::Value) {
                     fetch_response_handover(realm, fetch_params, Infrastructure::Response::network_error(vm, "Response body could not be processed"sv));
                 });
 
@@ -568,7 +568,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
                 }
 
                 // 3. Let processBody given bytes be these steps:
-                auto process_body = JS::create_heap_function(vm.heap(), [&realm, request, response, &fetch_params, process_body_error = move(process_body_error)](ByteBuffer bytes) {
+                auto process_body = GC::create_function(vm.heap(), [&realm, request, response, &fetch_params, process_body_error = move(process_body_error)](ByteBuffer bytes) {
                     // 1. If bytes do not match request’s integrity metadata, then run processBodyError and abort these steps.
                     if (!TRY_OR_IGNORE(SRI::do_bytes_match_metadata_list(bytes, request->integrity_metadata()))) {
                         process_body_error->function()({});
@@ -592,7 +592,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm& realm, Inf
         });
     }));
 
-    return JS::GCPtr<PendingResponse> {};
+    return GC::Ptr<PendingResponse> {};
 }
 
 // https://fetch.spec.whatwg.org/#fetch-finale
@@ -677,7 +677,7 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
         });
 
         // 4. Let processResponseEndOfBodyTask be the following steps:
-        auto process_response_end_of_body_task = JS::create_heap_function(vm.heap(), [&fetch_params, &response] {
+        auto process_response_end_of_body_task = GC::create_function(vm.heap(), [&fetch_params, &response] {
             // 1. Set fetchParams’s request’s done flag.
             fetch_params.request()->set_done(true);
 
@@ -690,7 +690,7 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
             //    object is fetchParams’s task destination, then run fetchParams’s controller’s report timing steps
             //    given fetchParams’s request’s client’s global object.
             auto client = fetch_params.request()->client();
-            auto const* task_destination_global_object = fetch_params.task_destination().get_pointer<JS::NonnullGCPtr<JS::Object>>();
+            auto const* task_destination_global_object = fetch_params.task_destination().get_pointer<GC::Ref<JS::Object>>();
             if (client != nullptr && task_destination_global_object != nullptr) {
                 if (fetch_params.request()->initiator_type().has_value() && &client->global_object() == task_destination_global_object->ptr())
                     fetch_params.controller()->report_timing(client->global_object());
@@ -698,25 +698,25 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
         });
 
         // FIXME: Handle 'parallel queue' task destination
-        auto task_destination = fetch_params.task_destination().get<JS::NonnullGCPtr<JS::Object>>();
+        auto task_destination = fetch_params.task_destination().get<GC::Ref<JS::Object>>();
 
         // 5. Queue a fetch task to run processResponseEndOfBodyTask with fetchParams’s task destination.
         Infrastructure::queue_fetch_task(fetch_params.controller(), task_destination, move(process_response_end_of_body_task));
     };
 
     // FIXME: Handle 'parallel queue' task destination
-    auto task_destination = fetch_params.task_destination().get<JS::NonnullGCPtr<JS::Object>>();
+    auto task_destination = fetch_params.task_destination().get<GC::Ref<JS::Object>>();
 
     // 4. If fetchParams’s process response is non-null, then queue a fetch task to run fetchParams’s process response
     //    given response, with fetchParams’s task destination.
     if (fetch_params.algorithms()->process_response()) {
-        Infrastructure::queue_fetch_task(fetch_params.controller(), task_destination, JS::create_heap_function(vm.heap(), [&fetch_params, &response]() {
+        Infrastructure::queue_fetch_task(fetch_params.controller(), task_destination, GC::create_function(vm.heap(), [&fetch_params, &response]() {
             fetch_params.algorithms()->process_response()(response);
         }));
     }
 
     // 5. Let internalResponse be response, if response is a network error; otherwise response’s internal response.
-    auto internal_response = response.is_network_error() ? JS::NonnullGCPtr { response } : response.unsafe_response();
+    auto internal_response = response.is_network_error() ? GC::Ref { response } : response.unsafe_response();
 
     // 6. If internalResponse’s body is null, then run processResponseEndOfBody.
     if (!internal_response->body()) {
@@ -730,14 +730,14 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
         auto transform_stream = realm.create<Streams::TransformStream>(realm);
 
         // 2. Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
-        auto identity_transform_algorithm = JS::create_heap_function(realm.heap(), [&realm, transform_stream](JS::Value chunk) -> JS::NonnullGCPtr<WebIDL::Promise> {
+        auto identity_transform_algorithm = GC::create_function(realm.heap(), [&realm, transform_stream](JS::Value chunk) -> GC::Ref<WebIDL::Promise> {
             MUST(Streams::transform_stream_default_controller_enqueue(*transform_stream->controller(), chunk));
             return WebIDL::create_resolved_promise(realm, JS::js_undefined());
         });
 
         // 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm set
         //    to processResponseEndOfBody.
-        auto flush_algorithm = JS::create_heap_function(realm.heap(), [&realm, process_response_end_of_body]() -> JS::NonnullGCPtr<WebIDL::Promise> {
+        auto flush_algorithm = GC::create_function(realm.heap(), [&realm, process_response_end_of_body]() -> GC::Ref<WebIDL::Promise> {
             process_response_end_of_body();
             return WebIDL::create_resolved_promise(realm, JS::js_undefined());
         });
@@ -753,20 +753,20 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
     if (fetch_params.algorithms()->process_response_consume_body()) {
         // 1. Let processBody given nullOrBytes be this step: run fetchParams’s process response consume body given
         //    response and nullOrBytes.
-        auto process_body = JS::create_heap_function(vm.heap(), [&fetch_params, &response](ByteBuffer null_or_bytes) {
+        auto process_body = GC::create_function(vm.heap(), [&fetch_params, &response](ByteBuffer null_or_bytes) {
             (fetch_params.algorithms()->process_response_consume_body())(response, null_or_bytes);
         });
 
         // 2. Let processBodyError be this step: run fetchParams’s process response consume body given response and
         //    failure.
-        auto process_body_error = JS::create_heap_function(vm.heap(), [&fetch_params, &response](JS::Value) {
+        auto process_body_error = GC::create_function(vm.heap(), [&fetch_params, &response](JS::Value) {
             (fetch_params.algorithms()->process_response_consume_body())(response, Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag {});
         });
 
         // 3. If internalResponse's body is null, then queue a fetch task to run processBody given null, with
         //    fetchParams’s task destination.
         if (!internal_response->body()) {
-            Infrastructure::queue_fetch_task(fetch_params.controller(), task_destination, JS::create_heap_function(vm.heap(), [process_body = move(process_body)]() {
+            Infrastructure::queue_fetch_task(fetch_params.controller(), task_destination, GC::create_function(vm.heap(), [process_body = move(process_body)]() {
                 process_body->function()({});
             }));
         }
@@ -779,7 +779,7 @@ void fetch_response_handover(JS::Realm& realm, Infrastructure::FetchParams const
 }
 
 // https://fetch.spec.whatwg.org/#concept-scheme-fetch
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> scheme_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params)
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> scheme_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'scheme fetch' with: fetch_params @ {}", &fetch_params);
 
@@ -939,7 +939,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> scheme_fetch(JS::Realm& r
 }
 
 // https://fetch.spec.whatwg.org/#concept-http-fetch
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, MakeCORSPreflight make_cors_preflight)
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> http_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, MakeCORSPreflight make_cors_preflight)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP fetch' with: fetch_params @ {}, make_cors_preflight = {}",
         &fetch_params, make_cors_preflight == MakeCORSPreflight::Yes ? "Yes"sv : "No"sv);
@@ -950,8 +950,8 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
     auto request = fetch_params.request();
 
     // 2. Let response and internalResponse be null.
-    JS::GCPtr<Infrastructure::Response> response;
-    JS::GCPtr<Infrastructure::Response> internal_response;
+    GC::Ptr<Infrastructure::Response> response;
+    GC::Ptr<Infrastructure::Response> internal_response;
 
     // 3. If request’s service-workers mode is "all", then:
     if (request->service_workers_mode() == Infrastructure::Request::ServiceWorkersMode::All) {
@@ -987,7 +987,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
             // 3. Set internalResponse to response, if response is not a filtered response; otherwise to response’s
             //    internal response.
             internal_response = !is<Infrastructure::FilteredResponse>(*response)
-                ? JS::NonnullGCPtr { *response }
+                ? GC::Ref { *response }
                 : static_cast<Infrastructure::FilteredResponse const&>(*response).internal_response();
 
             // 4. If one of the following is true
@@ -1008,7 +1008,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
         }
     }
 
-    JS::GCPtr<PendingResponse> pending_actual_response;
+    GC::Ptr<PendingResponse> pending_actual_response;
 
     auto returned_pending_response = PendingResponse::create(vm, request);
 
@@ -1019,7 +1019,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
         //       CORS-preflight fetch which, if successful, populates the cache. The purpose of the CORS-preflight
         //       fetch is to ensure the fetched resource is familiar with the CORS protocol. The cache is there to
         //       minimize the number of CORS-preflight fetches.
-        JS::GCPtr<PendingResponse> pending_preflight_response;
+        GC::Ptr<PendingResponse> pending_preflight_response;
         if (make_cors_preflight == MakeCORSPreflight::Yes && (
                 // - There is no method cache entry match for request’s method using request, and either request’s
                 //   method is not a CORS-safelisted method or request’s use-CORS-preflight flag is set.
@@ -1035,7 +1035,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
             // NOTE: Step 2 is performed in pending_preflight_response's load callback below.
         }
 
-        auto fetch_main_content = [request = JS::make_handle(request), realm = JS::make_handle(realm), fetch_params = JS::make_handle(fetch_params)]() -> WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> {
+        auto fetch_main_content = [request = GC::make_root(request), realm = GC::make_root(realm), fetch_params = GC::make_root(fetch_params)]() -> WebIDL::ExceptionOr<GC::Ref<PendingResponse>> {
             // 2. If request’s redirect mode is "follow", then set request’s service-workers mode to "none".
             // NOTE: Redirects coming from the network (as opposed to from a service worker) are not to be exposed to a
             //       service worker.
@@ -1048,7 +1048,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
 
         if (pending_preflight_response) {
             pending_actual_response = PendingResponse::create(vm, request);
-            pending_preflight_response->when_loaded([returned_pending_response, pending_actual_response, fetch_main_content = move(fetch_main_content)](JS::NonnullGCPtr<Infrastructure::Response> preflight_response) {
+            pending_preflight_response->when_loaded([returned_pending_response, pending_actual_response, fetch_main_content = move(fetch_main_content)](GC::Ref<Infrastructure::Response> preflight_response) {
                 dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP fetch' pending_preflight_response load callback");
 
                 // 2. If preflightResponse is a network error, then return preflightResponse.
@@ -1058,7 +1058,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
                 }
 
                 auto pending_main_content_response = TRY_OR_IGNORE(fetch_main_content());
-                pending_main_content_response->when_loaded([pending_actual_response](JS::NonnullGCPtr<Infrastructure::Response> main_content_response) {
+                pending_main_content_response->when_loaded([pending_actual_response](GC::Ref<Infrastructure::Response> main_content_response) {
                     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP fetch' pending_main_content_response load callback");
                     pending_actual_response->resolve(main_content_response);
                 });
@@ -1070,7 +1070,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
         pending_actual_response = PendingResponse::create(vm, request, Infrastructure::Response::create(vm));
     }
 
-    pending_actual_response->when_loaded([&realm, &vm, &fetch_params, request, response, internal_response, returned_pending_response, response_was_null = !response](JS::NonnullGCPtr<Infrastructure::Response> resolved_actual_response) mutable {
+    pending_actual_response->when_loaded([&realm, &vm, &fetch_params, request, response, internal_response, returned_pending_response, response_was_null = !response](GC::Ref<Infrastructure::Response> resolved_actual_response) mutable {
         dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP fetch' pending_actual_response load callback");
         if (response_was_null) {
             response = internal_response = resolved_actual_response;
@@ -1102,7 +1102,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
             return;
         }
 
-        JS::GCPtr<PendingResponse> inner_pending_response;
+        GC::Ptr<PendingResponse> inner_pending_response;
 
         // 6. If internalResponse’s status is a redirect status:
         if (Infrastructure::is_redirect_status(internal_response->status())) {
@@ -1143,7 +1143,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
         }
 
         if (inner_pending_response) {
-            inner_pending_response->when_loaded([returned_pending_response](JS::NonnullGCPtr<Infrastructure::Response> response) {
+            inner_pending_response->when_loaded([returned_pending_response](GC::Ref<Infrastructure::Response> response) {
                 dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP fetch' inner_pending_response load callback");
                 returned_pending_response->resolve(response);
             });
@@ -1158,7 +1158,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm& rea
 }
 
 // https://fetch.spec.whatwg.org/#concept-http-redirect-fetch
-WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, Infrastructure::Response& response)
+WebIDL::ExceptionOr<GC::Ptr<PendingResponse>> http_redirect_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, Infrastructure::Response& response)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP-redirect fetch' with: fetch_params @ {}, response = {}", &fetch_params, &response);
 
@@ -1170,7 +1170,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm& r
     // 2. Let internalResponse be response, if response is not a filtered response; otherwise response’s internal
     //    response.
     auto internal_response = !is<Infrastructure::FilteredResponse>(response)
-        ? JS::NonnullGCPtr { response }
+        ? GC::Ref { response }
         : static_cast<Infrastructure::FilteredResponse const&>(response).internal_response();
 
     // 3. Let locationURL be internalResponse’s location URL given request’s current URL’s fragment.
@@ -1215,7 +1215,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm& r
     //     return a network error.
     if (internal_response->status() != 303
         && !request->body().has<Empty>()
-        && request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->source().has<Empty>()) {
+        && request->body().get<GC::Ref<Infrastructure::Body>>()->source().has<Empty>()) {
         return PendingResponse::create(vm, request, Infrastructure::Response::network_error(vm, "Request has body but no body source"sv));
     }
 
@@ -1257,11 +1257,11 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm& r
     //     request’s body’s source.
     // NOTE: request’s body’s source’s nullity has already been checked.
     if (!request->body().has<Empty>()) {
-        auto const& source = request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->source();
+        auto const& source = request->body().get<GC::Ref<Infrastructure::Body>>()->source();
         // NOTE: BodyInitOrReadableBytes is a superset of Body::SourceType
         auto converted_source = source.has<ByteBuffer>()
             ? BodyInitOrReadableBytes { source.get<ByteBuffer>() }
-            : BodyInitOrReadableBytes { source.get<JS::Handle<FileAPI::Blob>>() };
+            : BodyInitOrReadableBytes { source.get<GC::Root<FileAPI::Blob>>() };
         auto [body, _] = TRY(safely_extract_body(realm, converted_source));
         request->set_body(move(body));
     }
@@ -1305,7 +1305,7 @@ WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm& r
 class CachePartition : public RefCounted<CachePartition> {
 public:
     // https://httpwg.org/specs/rfc9111.html#constructing.responses.from.caches
-    JS::GCPtr<Infrastructure::Response> select_response(URL::URL const& url, ReadonlyBytes method, Vector<Infrastructure::Header> const& headers, Vector<JS::GCPtr<Infrastructure::Response>>& initial_set_of_stored_responses) const
+    GC::Ptr<Infrastructure::Response> select_response(URL::URL const& url, ReadonlyBytes method, Vector<Infrastructure::Header> const& headers, Vector<GC::Ptr<Infrastructure::Response>>& initial_set_of_stored_responses) const
     {
         // When presented with a request, a cache MUST NOT reuse a stored response unless:
 
@@ -1357,7 +1357,7 @@ public:
     }
 
     // https://httpwg.org/specs/rfc9111.html#freshening.responses
-    void freshen_stored_responses_upon_validation(Infrastructure::Response const& response, Vector<JS::GCPtr<Infrastructure::Response>>& initial_set_of_stored_responses)
+    void freshen_stored_responses_upon_validation(Infrastructure::Response const& response, Vector<GC::Ptr<Infrastructure::Response>>& initial_set_of_stored_responses)
     {
         // When a cache receives a 304 (Not Modified) response, it needs to identify stored
         // responses that are suitable for updating with the new information provided, and then do so.
@@ -1538,7 +1538,7 @@ private:
         return true;
     }
 
-    HashMap<URL::URL, JS::GCPtr<Infrastructure::Response>> m_cache;
+    HashMap<URL::URL, GC::Ptr<Infrastructure::Response>> m_cache;
 };
 
 class HTTPCache {
@@ -1578,7 +1578,7 @@ static RefPtr<CachePartition> determine_the_http_cache_partition(Infrastructure:
 }
 
 // https://fetch.spec.whatwg.org/#concept-http-network-or-cache-fetch
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, IsAuthenticationFetch is_authentication_fetch, IsNewConnectionFetch is_new_connection_fetch)
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> http_network_or_cache_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, IsAuthenticationFetch is_authentication_fetch, IsNewConnectionFetch is_new_connection_fetch)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP-network-or-cache fetch' with: fetch_params @ {}, is_authentication_fetch = {}, is_new_connection_fetch = {}",
         &fetch_params, is_authentication_fetch == IsAuthenticationFetch::Yes ? "Yes"sv : "No"sv, is_new_connection_fetch == IsNewConnectionFetch::Yes ? "Yes"sv : "No"sv);
@@ -1589,17 +1589,17 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
     auto request = fetch_params.request();
 
     // 2. Let httpFetchParams be null.
-    JS::GCPtr<Infrastructure::FetchParams const> http_fetch_params;
+    GC::Ptr<Infrastructure::FetchParams const> http_fetch_params;
 
     // 3. Let httpRequest be null.
-    JS::GCPtr<Infrastructure::Request> http_request;
+    GC::Ptr<Infrastructure::Request> http_request;
 
     // 4. Let response be null.
-    JS::GCPtr<Infrastructure::Response> response;
+    GC::Ptr<Infrastructure::Response> response;
 
     // 5. Let storedResponse be null.
-    JS::GCPtr<Infrastructure::Response> stored_response;
-    Vector<JS::GCPtr<Infrastructure::Response>> initial_set_of_stored_responses;
+    GC::Ptr<Infrastructure::Response> stored_response;
+    Vector<GC::Ptr<Infrastructure::Response>> initial_set_of_stored_responses;
 
     // 6. Let httpCache be null.
     // (Typeless until we actually implement it, needed for checks below)
@@ -1666,8 +1666,8 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
             include_credentials = IncludeCredentials::No;
 
         // 5. Let contentLength be httpRequest’s body’s length, if httpRequest’s body is non-null; otherwise null.
-        auto content_length = http_request->body().has<JS::NonnullGCPtr<Infrastructure::Body>>()
-            ? http_request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->length()
+        auto content_length = http_request->body().has<GC::Ref<Infrastructure::Body>>()
+            ? http_request->body().get<GC::Ref<Infrastructure::Body>>()->length()
             : Optional<u64> {};
 
         // 6. Let contentLengthHeaderValue be null.
@@ -1702,7 +1702,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
             auto& group = http_request->client()->fetch_group();
 
             // 3. Let inflightRecords be the set of fetch records in group whose request’s keepalive is true and done flag is unset.
-            Vector<JS::NonnullGCPtr<Infrastructure::FetchRecord>> in_flight_records;
+            Vector<GC::Ref<Infrastructure::FetchRecord>> in_flight_records;
             for (auto const& fetch_record : group) {
                 if (fetch_record->request()->keepalive() && !fetch_record->request()->done())
                     in_flight_records.append(fetch_record);
@@ -1717,7 +1717,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
                 inflight_keep_alive_bytes += in_flight_request->body().visit(
                     [](Empty) -> u64 { return 0; },
                     [](ByteBuffer const& buffer) -> u64 { return buffer.size(); },
-                    [](JS::NonnullGCPtr<Infrastructure::Body> body) -> u64 {
+                    [](GC::Ref<Infrastructure::Body> body) -> u64 {
                         return body->length().has_value() ? body->length().value() : 0;
                     });
             }
@@ -1921,7 +1921,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
                     revalidate_request->set_service_workers_mode(Infrastructure::Request::ServiceWorkersMode::None);
 
                     // 7. In parallel, run main fetch given a new fetch params whose request is revalidateRequest.
-                    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&vm, &realm, revalidate_request, fetch_params = JS::NonnullGCPtr(fetch_params)] {
+                    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&vm, &realm, revalidate_request, fetch_params = GC::Ref(fetch_params)] {
                         (void)main_fetch(realm, Infrastructure::FetchParams::create(vm, revalidate_request, fetch_params->timing_info()));
                     }));
                 }
@@ -1960,7 +1960,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
     if (aborted)
         return PendingResponse::create(vm, request, Infrastructure::Response::appropriate_network_error(vm, fetch_params));
 
-    JS::GCPtr<PendingResponse> pending_forward_response;
+    GC::Ptr<PendingResponse> pending_forward_response;
 
     // 10. If response is null, then:
     if (!response) {
@@ -1977,7 +1977,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
 
     auto returned_pending_response = PendingResponse::create(vm, request);
 
-    pending_forward_response->when_loaded([&realm, &vm, &fetch_params, request, response, stored_response, initial_set_of_stored_responses, http_request, returned_pending_response, is_authentication_fetch, is_new_connection_fetch, revalidating_flag, include_credentials, response_was_null = !response, http_cache](JS::NonnullGCPtr<Infrastructure::Response> resolved_forward_response) mutable {
+    pending_forward_response->when_loaded([&realm, &vm, &fetch_params, request, response, stored_response, initial_set_of_stored_responses, http_request, returned_pending_response, is_authentication_fetch, is_new_connection_fetch, revalidating_flag, include_credentials, response_was_null = !response, http_cache](GC::Ref<Infrastructure::Response> resolved_forward_response) mutable {
         dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP-network-or-cache fetch' pending_forward_response load callback");
         if (response_was_null) {
             auto forward_response = resolved_forward_response;
@@ -2040,7 +2040,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
         if (response->status() == 401
             && http_request->response_tainting() != Infrastructure::Request::ResponseTainting::CORS
             && include_credentials == IncludeCredentials::Yes
-            && request->window().has<JS::GCPtr<HTML::EnvironmentSettingsObject>>()
+            && request->window().has<GC::Ptr<HTML::EnvironmentSettingsObject>>()
             // AD-HOC: Require at least one WWW-Authenticate header to be set before automatically retrying an authenticated
             //         request (see rule 1 below). See: https://github.com/whatwg/fetch/issues/1766
             && request->header_list()->contains("WWW-Authenticate"sv.bytes())) {
@@ -2050,17 +2050,17 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
             // 2. If request’s body is non-null, then:
             if (!request->body().has<Empty>()) {
                 // 1. If request’s body’s source is null, then return a network error.
-                if (request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->source().has<Empty>()) {
+                if (request->body().get<GC::Ref<Infrastructure::Body>>()->source().has<Empty>()) {
                     returned_pending_response->resolve(Infrastructure::Response::network_error(vm, "Request has body but no body source"_string));
                     return;
                 }
 
                 // 2. Set request’s body to the body of the result of safely extracting request’s body’s source.
-                auto const& source = request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->source();
+                auto const& source = request->body().get<GC::Ref<Infrastructure::Body>>()->source();
                 // NOTE: BodyInitOrReadableBytes is a superset of Body::SourceType
                 auto converted_source = source.has<ByteBuffer>()
                     ? BodyInitOrReadableBytes { source.get<ByteBuffer>() }
-                    : BodyInitOrReadableBytes { source.get<JS::Handle<FileAPI::Blob>>() };
+                    : BodyInitOrReadableBytes { source.get<GC::Root<FileAPI::Blob>>() };
                 auto [body, _] = TRY_OR_IGNORE(safely_extract_body(realm, converted_source));
                 request->set_body(move(body));
             }
@@ -2090,7 +2090,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
             inner_pending_response = TRY_OR_IGNORE(http_network_or_cache_fetch(realm, fetch_params, IsAuthenticationFetch::Yes));
         }
 
-        inner_pending_response->when_loaded([&realm, &vm, &fetch_params, request, returned_pending_response, is_authentication_fetch, is_new_connection_fetch](JS::NonnullGCPtr<Infrastructure::Response> response) {
+        inner_pending_response->when_loaded([&realm, &vm, &fetch_params, request, returned_pending_response, is_authentication_fetch, is_new_connection_fetch](GC::Ref<Infrastructure::Response> response) {
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'HTTP network-or-cache fetch' inner_pending_response load callback");
             // 15. If response’s status is 407, then:
             if (response->status() == 407) {
@@ -2127,7 +2127,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
                 // - isNewConnectionFetch is false
                 && is_new_connection_fetch == IsNewConnectionFetch::No
                 // - request’s body is null, or request’s body is non-null and request’s body’s source is non-null
-                && (request->body().has<Empty>() || !request->body().get<JS::NonnullGCPtr<Infrastructure::Body>>()->source().has<Empty>())
+                && (request->body().has<Empty>() || !request->body().get<GC::Ref<Infrastructure::Body>>()->source().has<Empty>())
                 // then:
             ) {
                 // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
@@ -2140,7 +2140,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fet
                 inner_pending_response = TRY_OR_IGNORE(http_network_or_cache_fetch(realm, fetch_params, is_authentication_fetch, IsNewConnectionFetch::Yes));
             }
 
-            inner_pending_response->when_loaded([returned_pending_response, is_authentication_fetch](JS::NonnullGCPtr<Infrastructure::Response> response) {
+            inner_pending_response->when_loaded([returned_pending_response, is_authentication_fetch](GC::Ref<Infrastructure::Response> response) {
                 // 17. If isAuthenticationFetch is true, then create an authentication entry for request and the given
                 //     realm.
                 if (is_authentication_fetch == IsAuthenticationFetch::Yes) {
@@ -2183,7 +2183,7 @@ static void log_response(auto const& status_code, auto const& headers, auto cons
 // https://fetch.spec.whatwg.org/#concept-http-network-fetch
 // Drop-in replacement for 'HTTP-network fetch', but obviously non-standard :^)
 // It also handles file:// URLs since those can also go through ResourceLoader.
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_loader_file_or_http_network_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, IncludeCredentials include_credentials, IsNewConnectionFetch is_new_connection_fetch)
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_or_http_network_fetch(JS::Realm& realm, Infrastructure::FetchParams const& fetch_params, IncludeCredentials include_credentials, IsNewConnectionFetch is_new_connection_fetch)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'non-standard HTTP-network fetch' with: fetch_params @ {}", &fetch_params);
 
@@ -2206,13 +2206,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
     for (auto const& header : *request->header_list())
         load_request.set_header(ByteString::copy(header.name), ByteString::copy(header.value));
 
-    if (auto const* body = request->body().get_pointer<JS::NonnullGCPtr<Infrastructure::Body>>()) {
+    if (auto const* body = request->body().get_pointer<GC::Ref<Infrastructure::Body>>()) {
         TRY((*body)->source().visit(
             [&](ByteBuffer const& byte_buffer) -> WebIDL::ExceptionOr<void> {
                 load_request.set_body(TRY_OR_THROW_OOM(vm, ByteBuffer::copy(byte_buffer)));
                 return {};
             },
-            [&](JS::Handle<FileAPI::Blob> const& blob_handle) -> WebIDL::ExceptionOr<void> {
+            [&](GC::Root<FileAPI::Blob> const& blob_handle) -> WebIDL::ExceptionOr<void> {
                 load_request.set_body(TRY_OR_THROW_OOM(vm, ByteBuffer::copy(blob_handle->raw_bytes())));
                 return {};
             },
@@ -2240,7 +2240,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
         auto fetched_data_receiver = realm.create<FetchedDataReceiver>(fetch_params, stream);
 
         // 10. Let pullAlgorithm be the followings steps:
-        auto pull_algorithm = JS::create_heap_function(realm.heap(), [&realm, fetched_data_receiver]() {
+        auto pull_algorithm = GC::create_function(realm.heap(), [&realm, fetched_data_receiver]() {
             // 1. Let promise be a new promise.
             auto promise = WebIDL::create_promise(realm);
 
@@ -2253,7 +2253,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
         });
 
         // 11. Let cancelAlgorithm be an algorithm that aborts fetchParams’s controller with reason, given reason.
-        auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm, &fetch_params](JS::Value reason) {
+        auto cancel_algorithm = GC::create_function(realm.heap(), [&realm, &fetch_params](JS::Value reason) {
             fetch_params.controller()->abort(realm, reason);
             return WebIDL::create_resolved_promise(realm, JS::js_undefined());
         });
@@ -2261,7 +2261,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
         // 13. Set up stream with byte reading support with pullAlgorithm set to pullAlgorithm, cancelAlgorithm set to cancelAlgorithm.
         Streams::set_up_readable_stream_controller_with_byte_reading_support(stream, pull_algorithm, cancel_algorithm);
 
-        auto on_headers_received = JS::create_heap_function(vm.heap(), [&vm, request, pending_response, stream](HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
+        auto on_headers_received = GC::create_function(vm.heap(), [&vm, request, pending_response, stream](HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
             (void)request;
             if (pending_response->is_resolved()) {
                 // RequestServer will send us the response headers twice, the second time being for HTTP trailers. This
@@ -2298,7 +2298,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
 
         // 16. Run these steps in parallel:
         //    FIXME: 1. Run these steps, but abort when fetchParams is canceled:
-        auto on_data_received = JS::create_heap_function(vm.heap(), [fetched_data_receiver](ReadonlyBytes bytes) {
+        auto on_data_received = GC::create_function(vm.heap(), [fetched_data_receiver](ReadonlyBytes bytes) {
             // 1. If one or more bytes have been transmitted from response’s message body, then:
             if (!bytes.is_empty()) {
                 // 1. Let bytes be the transmitted bytes.
@@ -2317,7 +2317,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
             }
         });
 
-        auto on_complete = JS::create_heap_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Optional<StringView> error_message) {
+        auto on_complete = GC::create_function(vm.heap(), [&vm, &realm, pending_response, stream](bool success, Optional<StringView> error_message) {
             HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
             // 16.1.1.2. Otherwise, if the bytes transmission for response’s message body is done normally and stream is readable,
@@ -2340,7 +2340,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
 
         ResourceLoader::the().load_unbuffered(load_request, on_headers_received, on_data_received, on_complete);
     } else {
-        auto on_load_success = JS::create_heap_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
+        auto on_load_success = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ReadonlyBytes data, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase) {
             (void)request;
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' complete", request->url());
             if constexpr (WEB_FETCH_DEBUG)
@@ -2360,7 +2360,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
             pending_response->resolve(response);
         });
 
-        auto on_load_error = JS::create_heap_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
+        auto on_load_error = GC::create_function(vm.heap(), [&realm, &vm, request, pending_response](ByteString const& error, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes data, HTTP::HeaderMap const& response_headers) {
             (void)request;
             dbgln_if(WEB_FETCH_DEBUG, "Fetch: ResourceLoader load for '{}' failed: {} (status {})", request->url(), error, status_code.value_or(0));
             if constexpr (WEB_FETCH_DEBUG)
@@ -2392,7 +2392,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_load
 }
 
 // https://fetch.spec.whatwg.org/#cors-preflight-fetch-0
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> cors_preflight_fetch(JS::Realm& realm, Infrastructure::Request& request)
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> cors_preflight_fetch(JS::Realm& realm, Infrastructure::Request& request)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'CORS-preflight fetch' with request @ {}", &request);
 
@@ -2455,7 +2455,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> cors_preflight_fetch(JS::
 
     auto preflight_response = TRY(http_network_or_cache_fetch(realm, fetch_params));
 
-    preflight_response->when_loaded([&vm, &request, returned_pending_response](JS::NonnullGCPtr<Infrastructure::Response> response) {
+    preflight_response->when_loaded([&vm, &request, returned_pending_response](GC::Ref<Infrastructure::Response> response) {
         dbgln_if(WEB_FETCH_DEBUG, "Fetch: Running 'CORS-preflight fetch' preflight_response load callback");
 
         // 7. If a CORS check for request and response returns success and response’s status is an ok status, then:
diff --git a/Libraries/LibWeb/Fetch/Fetching/Fetching.h b/Libraries/LibWeb/Fetch/Fetching/Fetching.h
index 57e28b4783e..7ab44e40476 100644
--- a/Libraries/LibWeb/Fetch/Fetching/Fetching.h
+++ b/Libraries/LibWeb/Fetch/Fetching/Fetching.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Fetch::Fetching {
@@ -38,15 +38,15 @@ constexpr auto keepalive_maximum_size = 64 * KiB;
 ENUMERATE_BOOL_PARAMS
 #undef __ENUMERATE_BOOL_PARAM
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Infrastructure::FetchController>> fetch(JS::Realm&, Infrastructure::Request&, Infrastructure::FetchAlgorithms const&, UseParallelQueue use_parallel_queue = UseParallelQueue::No);
-WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> main_fetch(JS::Realm&, Infrastructure::FetchParams const&, Recursive recursive = Recursive::No);
+WebIDL::ExceptionOr<GC::Ref<Infrastructure::FetchController>> fetch(JS::Realm&, Infrastructure::Request&, Infrastructure::FetchAlgorithms const&, UseParallelQueue use_parallel_queue = UseParallelQueue::No);
+WebIDL::ExceptionOr<GC::Ptr<PendingResponse>> main_fetch(JS::Realm&, Infrastructure::FetchParams const&, Recursive recursive = Recursive::No);
 void fetch_response_handover(JS::Realm&, Infrastructure::FetchParams const&, Infrastructure::Response&);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> scheme_fetch(JS::Realm&, Infrastructure::FetchParams const&);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_fetch(JS::Realm&, Infrastructure::FetchParams const&, MakeCORSPreflight make_cors_preflight = MakeCORSPreflight::No);
-WebIDL::ExceptionOr<JS::GCPtr<PendingResponse>> http_redirect_fetch(JS::Realm&, Infrastructure::FetchParams const&, Infrastructure::Response&);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> http_network_or_cache_fetch(JS::Realm&, Infrastructure::FetchParams const&, IsAuthenticationFetch is_authentication_fetch = IsAuthenticationFetch::No, IsNewConnectionFetch is_new_connection_fetch = IsNewConnectionFetch::No);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> nonstandard_resource_loader_file_or_http_network_fetch(JS::Realm&, Infrastructure::FetchParams const&, IncludeCredentials include_credentials = IncludeCredentials::No, IsNewConnectionFetch is_new_connection_fetch = IsNewConnectionFetch::No);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PendingResponse>> cors_preflight_fetch(JS::Realm&, Infrastructure::Request&);
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> scheme_fetch(JS::Realm&, Infrastructure::FetchParams const&);
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> http_fetch(JS::Realm&, Infrastructure::FetchParams const&, MakeCORSPreflight make_cors_preflight = MakeCORSPreflight::No);
+WebIDL::ExceptionOr<GC::Ptr<PendingResponse>> http_redirect_fetch(JS::Realm&, Infrastructure::FetchParams const&, Infrastructure::Response&);
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> http_network_or_cache_fetch(JS::Realm&, Infrastructure::FetchParams const&, IsAuthenticationFetch is_authentication_fetch = IsAuthenticationFetch::No, IsNewConnectionFetch is_new_connection_fetch = IsNewConnectionFetch::No);
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> nonstandard_resource_loader_file_or_http_network_fetch(JS::Realm&, Infrastructure::FetchParams const&, IncludeCredentials include_credentials = IncludeCredentials::No, IsNewConnectionFetch is_new_connection_fetch = IsNewConnectionFetch::No);
+WebIDL::ExceptionOr<GC::Ref<PendingResponse>> cors_preflight_fetch(JS::Realm&, Infrastructure::Request&);
 void set_sec_fetch_dest_header(Infrastructure::Request&);
 void set_sec_fetch_mode_header(Infrastructure::Request&);
 void set_sec_fetch_site_header(Infrastructure::Request&);
diff --git a/Libraries/LibWeb/Fetch/Fetching/PendingResponse.cpp b/Libraries/LibWeb/Fetch/Fetching/PendingResponse.cpp
index 85cd0e41e1c..b72831e6e7d 100644
--- a/Libraries/LibWeb/Fetch/Fetching/PendingResponse.cpp
+++ b/Libraries/LibWeb/Fetch/Fetching/PendingResponse.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Fetching/PendingResponse.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
@@ -12,19 +12,19 @@
 
 namespace Web::Fetch::Fetching {
 
-JS_DEFINE_ALLOCATOR(PendingResponse);
+GC_DEFINE_ALLOCATOR(PendingResponse);
 
-JS::NonnullGCPtr<PendingResponse> PendingResponse::create(JS::VM& vm, JS::NonnullGCPtr<Infrastructure::Request> request)
+GC::Ref<PendingResponse> PendingResponse::create(JS::VM& vm, GC::Ref<Infrastructure::Request> request)
 {
     return vm.heap().allocate<PendingResponse>(request);
 }
 
-JS::NonnullGCPtr<PendingResponse> PendingResponse::create(JS::VM& vm, JS::NonnullGCPtr<Infrastructure::Request> request, JS::NonnullGCPtr<Infrastructure::Response> response)
+GC::Ref<PendingResponse> PendingResponse::create(JS::VM& vm, GC::Ref<Infrastructure::Request> request, GC::Ref<Infrastructure::Response> response)
 {
     return vm.heap().allocate<PendingResponse>(request, response);
 }
 
-PendingResponse::PendingResponse(JS::NonnullGCPtr<Infrastructure::Request> request, JS::GCPtr<Infrastructure::Response> response)
+PendingResponse::PendingResponse(GC::Ref<Infrastructure::Request> request, GC::Ptr<Infrastructure::Response> response)
     : m_request(request)
     , m_response(response)
 {
@@ -42,12 +42,12 @@ void PendingResponse::visit_edges(JS::Cell::Visitor& visitor)
 void PendingResponse::when_loaded(Callback callback)
 {
     VERIFY(!m_callback);
-    m_callback = JS::create_heap_function(heap(), move(callback));
+    m_callback = GC::create_function(heap(), move(callback));
     if (m_response)
         run_callback();
 }
 
-void PendingResponse::resolve(JS::NonnullGCPtr<Infrastructure::Response> response)
+void PendingResponse::resolve(GC::Ref<Infrastructure::Response> response)
 {
     VERIFY(!m_response);
     m_response = response;
@@ -59,7 +59,7 @@ void PendingResponse::run_callback()
 {
     VERIFY(m_callback);
     VERIFY(m_response);
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [this] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this] {
         VERIFY(m_callback);
         VERIFY(m_response);
         m_callback->function()(*m_response);
diff --git a/Libraries/LibWeb/Fetch/Fetching/PendingResponse.h b/Libraries/LibWeb/Fetch/Fetching/PendingResponse.h
index 96e586f8795..3299fc83ea8 100644
--- a/Libraries/LibWeb/Fetch/Fetching/PendingResponse.h
+++ b/Libraries/LibWeb/Fetch/Fetching/PendingResponse.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
 
 namespace Web::Fetch::Fetching {
@@ -18,29 +18,29 @@ namespace Web::Fetch::Fetching {
 // of the Fetch spec - we run 'in parallel' as a deferred_invoke(), which is still on the main thread;
 // therefore we use callbacks to run portions of the spec that require waiting for an HTTP load.
 class PendingResponse : public JS::Cell {
-    JS_CELL(PendingResponse, JS::Cell);
-    JS_DECLARE_ALLOCATOR(PendingResponse);
+    GC_CELL(PendingResponse, JS::Cell);
+    GC_DECLARE_ALLOCATOR(PendingResponse);
 
 public:
-    using Callback = Function<void(JS::NonnullGCPtr<Infrastructure::Response>)>;
+    using Callback = Function<void(GC::Ref<Infrastructure::Response>)>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<PendingResponse> create(JS::VM&, JS::NonnullGCPtr<Infrastructure::Request>);
-    [[nodiscard]] static JS::NonnullGCPtr<PendingResponse> create(JS::VM&, JS::NonnullGCPtr<Infrastructure::Request>, JS::NonnullGCPtr<Infrastructure::Response>);
+    [[nodiscard]] static GC::Ref<PendingResponse> create(JS::VM&, GC::Ref<Infrastructure::Request>);
+    [[nodiscard]] static GC::Ref<PendingResponse> create(JS::VM&, GC::Ref<Infrastructure::Request>, GC::Ref<Infrastructure::Response>);
 
     void when_loaded(Callback);
-    void resolve(JS::NonnullGCPtr<Infrastructure::Response>);
+    void resolve(GC::Ref<Infrastructure::Response>);
     bool is_resolved() const { return m_response != nullptr; }
 
 private:
-    PendingResponse(JS::NonnullGCPtr<Infrastructure::Request>, JS::GCPtr<Infrastructure::Response> = {});
+    PendingResponse(GC::Ref<Infrastructure::Request>, GC::Ptr<Infrastructure::Response> = {});
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     void run_callback();
 
-    JS::GCPtr<JS::HeapFunction<void(JS::NonnullGCPtr<Infrastructure::Response>)>> m_callback;
-    JS::NonnullGCPtr<Infrastructure::Request> m_request;
-    JS::GCPtr<Infrastructure::Response> m_response;
+    GC::Ptr<GC::Function<void(GC::Ref<Infrastructure::Response>)>> m_callback;
+    GC::Ref<Infrastructure::Request> m_request;
+    GC::Ptr<Infrastructure::Response> m_response;
 };
 
 }
diff --git a/Libraries/LibWeb/Fetch/Headers.cpp b/Libraries/LibWeb/Fetch/Headers.cpp
index 5915a7f9c5d..1d4dbf31a7e 100644
--- a/Libraries/LibWeb/Fetch/Headers.cpp
+++ b/Libraries/LibWeb/Fetch/Headers.cpp
@@ -12,10 +12,10 @@
 
 namespace Web::Fetch {
 
-JS_DEFINE_ALLOCATOR(Headers);
+GC_DEFINE_ALLOCATOR(Headers);
 
 // https://fetch.spec.whatwg.org/#dom-headers
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Headers>> Headers::construct_impl(JS::Realm& realm, Optional<HeadersInit> const& init)
+WebIDL::ExceptionOr<GC::Ref<Headers>> Headers::construct_impl(JS::Realm& realm, Optional<HeadersInit> const& init)
 {
     auto& vm = realm.vm();
 
@@ -32,7 +32,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Headers>> Headers::construct_impl(JS::Realm
     return headers;
 }
 
-Headers::Headers(JS::Realm& realm, JS::NonnullGCPtr<Infrastructure::HeaderList> header_list)
+Headers::Headers(JS::Realm& realm, GC::Ref<Infrastructure::HeaderList> header_list)
     : PlatformObject(realm)
     , m_header_list(header_list)
 {
diff --git a/Libraries/LibWeb/Fetch/Headers.h b/Libraries/LibWeb/Fetch/Headers.h
index f0cbc91222a..7e4ba3d7bd5 100644
--- a/Libraries/LibWeb/Fetch/Headers.h
+++ b/Libraries/LibWeb/Fetch/Headers.h
@@ -10,8 +10,8 @@
 #include <AK/String.h>
 #include <AK/Variant.h>
 #include <AK/Vector.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Headers.h>
 #include <LibWeb/WebIDL/ExceptionOr.h>
@@ -23,7 +23,7 @@ using HeadersInit = Variant<Vector<Vector<String>>, OrderedHashMap<String, Strin
 // https://fetch.spec.whatwg.org/#headers-class
 class Headers final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Headers, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Headers);
+    GC_DECLARE_ALLOCATOR(Headers);
 
 public:
     enum class Guard {
@@ -34,12 +34,12 @@ public:
         None,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Headers>> construct_impl(JS::Realm& realm, Optional<HeadersInit> const& init);
+    static WebIDL::ExceptionOr<GC::Ref<Headers>> construct_impl(JS::Realm& realm, Optional<HeadersInit> const& init);
 
     virtual ~Headers() override;
 
-    [[nodiscard]] JS::NonnullGCPtr<Infrastructure::HeaderList> header_list() const { return m_header_list; }
-    void set_header_list(JS::NonnullGCPtr<Infrastructure::HeaderList> header_list) { m_header_list = header_list; }
+    [[nodiscard]] GC::Ref<Infrastructure::HeaderList> header_list() const { return m_header_list; }
+    void set_header_list(GC::Ref<Infrastructure::HeaderList> header_list) { m_header_list = header_list; }
 
     [[nodiscard]] Guard guard() const { return m_guard; }
     void set_guard(Guard guard) { m_guard = guard; }
@@ -61,7 +61,7 @@ public:
 private:
     friend class HeadersIterator;
 
-    Headers(JS::Realm&, JS::NonnullGCPtr<Infrastructure::HeaderList>);
+    Headers(JS::Realm&, GC::Ref<Infrastructure::HeaderList>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
@@ -71,7 +71,7 @@ private:
 
     // https://fetch.spec.whatwg.org/#concept-headers-header-list
     // A Headers object has an associated header list (a header list), which is initially empty.
-    JS::NonnullGCPtr<Infrastructure::HeaderList> m_header_list;
+    GC::Ref<Infrastructure::HeaderList> m_header_list;
 
     // https://fetch.spec.whatwg.org/#concept-headers-guard
     // A Headers object also has an associated guard, which is a headers guard. A headers guard is "immutable", "request", "request-no-cors", "response" or "none".
diff --git a/Libraries/LibWeb/Fetch/HeadersIterator.cpp b/Libraries/LibWeb/Fetch/HeadersIterator.cpp
index 6576af8dc48..3b25fa055b9 100644
--- a/Libraries/LibWeb/Fetch/HeadersIterator.cpp
+++ b/Libraries/LibWeb/Fetch/HeadersIterator.cpp
@@ -23,9 +23,9 @@ void Intrinsics::create_web_prototype_and_constructor<HeadersIteratorPrototype>(
 
 namespace Web::Fetch {
 
-JS_DEFINE_ALLOCATOR(HeadersIterator);
+GC_DEFINE_ALLOCATOR(HeadersIterator);
 
-JS::NonnullGCPtr<HeadersIterator> HeadersIterator::create(Headers const& headers, JS::Object::PropertyKind iteration_kind)
+GC::Ref<HeadersIterator> HeadersIterator::create(Headers const& headers, JS::Object::PropertyKind iteration_kind)
 {
     return headers.realm().create<HeadersIterator>(headers, iteration_kind);
 }
@@ -52,7 +52,7 @@ void HeadersIterator::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://webidl.spec.whatwg.org/#es-iterable, Step 2
-JS::NonnullGCPtr<JS::Object> HeadersIterator::next()
+GC::Ref<JS::Object> HeadersIterator::next()
 {
     // The value pairs to iterate over are the return value of running sort and combine with this’s header list.
     auto value_pairs_to_iterate_over = [&]() {
diff --git a/Libraries/LibWeb/Fetch/HeadersIterator.h b/Libraries/LibWeb/Fetch/HeadersIterator.h
index 4d4c72cbed8..46db0ded977 100644
--- a/Libraries/LibWeb/Fetch/HeadersIterator.h
+++ b/Libraries/LibWeb/Fetch/HeadersIterator.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Fetch/Headers.h>
 
@@ -14,14 +14,14 @@ namespace Web::Fetch {
 
 class HeadersIterator final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(HeadersIterator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(HeadersIterator);
+    GC_DECLARE_ALLOCATOR(HeadersIterator);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<HeadersIterator> create(Headers const&, JS::Object::PropertyKind iteration_kind);
+    [[nodiscard]] static GC::Ref<HeadersIterator> create(Headers const&, JS::Object::PropertyKind iteration_kind);
 
     virtual ~HeadersIterator() override;
 
-    JS::NonnullGCPtr<JS::Object> next();
+    GC::Ref<JS::Object> next();
 
 private:
     virtual void initialize(JS::Realm&) override;
@@ -29,7 +29,7 @@ private:
 
     HeadersIterator(Headers const&, JS::Object::PropertyKind iteration_kind);
 
-    JS::NonnullGCPtr<Headers const> m_headers;
+    GC::Ref<Headers const> m_headers;
     JS::Object::PropertyKind m_iteration_kind;
     size_t m_index { 0 };
 };
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.cpp b/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.cpp
index 19e330dbc0f..eaa97c1df3f 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.cpp
@@ -4,17 +4,17 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h>
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(ConnectionTimingInfo);
+GC_DEFINE_ALLOCATOR(ConnectionTimingInfo);
 
 ConnectionTimingInfo::ConnectionTimingInfo() = default;
 
-JS::NonnullGCPtr<ConnectionTimingInfo> ConnectionTimingInfo::create(JS::VM& vm)
+GC::Ref<ConnectionTimingInfo> ConnectionTimingInfo::create(JS::VM& vm)
 {
     return vm.heap().allocate<ConnectionTimingInfo>();
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h b/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h
index 1e544853d40..3f61f76c693 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h
@@ -7,19 +7,19 @@
 #pragma once
 
 #include <AK/ByteBuffer.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/HighResolutionTime/DOMHighResTimeStamp.h>
 
 namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#connection-timing-info
 class ConnectionTimingInfo : public JS::Cell {
-    JS_CELL(ConnectionTimingInfo, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ConnectionTimingInfo);
+    GC_CELL(ConnectionTimingInfo, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ConnectionTimingInfo);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ConnectionTimingInfo> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<ConnectionTimingInfo> create(JS::VM&);
 
     [[nodiscard]] HighResolutionTime::DOMHighResTimeStamp domain_lookup_start_time() const { return m_domain_lookup_start_time; }
     void set_domain_lookup_start_time(HighResolutionTime::DOMHighResTimeStamp domain_lookup_start_time) { m_domain_lookup_start_time = domain_lookup_start_time; }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.cpp b/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.cpp
index 1c76de167f1..6113b270d6c 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.cpp
@@ -4,22 +4,22 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(FetchAlgorithms);
+GC_DEFINE_ALLOCATOR(FetchAlgorithms);
 
-JS::NonnullGCPtr<FetchAlgorithms> FetchAlgorithms::create(JS::VM& vm, Input input)
+GC::Ref<FetchAlgorithms> FetchAlgorithms::create(JS::VM& vm, Input input)
 {
-    auto process_request_body_chunk_length = JS::create_heap_function(vm.heap(), move(input.process_request_body_chunk_length));
-    auto process_request_end_of_body = JS::create_heap_function(vm.heap(), move(input.process_request_end_of_body));
-    auto process_early_hints_response = JS::create_heap_function(vm.heap(), move(input.process_early_hints_response));
-    auto process_response = JS::create_heap_function(vm.heap(), move(input.process_response));
-    auto process_response_end_of_body = JS::create_heap_function(vm.heap(), move(input.process_response_end_of_body));
-    auto process_response_consume_body = JS::create_heap_function(vm.heap(), move(input.process_response_consume_body));
+    auto process_request_body_chunk_length = GC::create_function(vm.heap(), move(input.process_request_body_chunk_length));
+    auto process_request_end_of_body = GC::create_function(vm.heap(), move(input.process_request_end_of_body));
+    auto process_early_hints_response = GC::create_function(vm.heap(), move(input.process_early_hints_response));
+    auto process_response = GC::create_function(vm.heap(), move(input.process_response));
+    auto process_response_end_of_body = GC::create_function(vm.heap(), move(input.process_response_end_of_body));
+    auto process_response_consume_body = GC::create_function(vm.heap(), move(input.process_response_consume_body));
     return vm.heap().allocate<FetchAlgorithms>(
         process_request_body_chunk_length,
         process_request_end_of_body,
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.h b/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.h
index 3019a039d40..9c69125cb41 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchAlgorithms.h
@@ -7,17 +7,17 @@
 #pragma once
 
 #include <AK/Optional.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#fetch-elsewhere-fetch
 class FetchAlgorithms : public JS::Cell {
-    JS_CELL(FetchAlgorithms, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchAlgorithms);
+    GC_CELL(FetchAlgorithms, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchAlgorithms);
 
 public:
     struct ConsumeBodyFailureTag { };
@@ -25,17 +25,17 @@ public:
 
     using ProcessRequestBodyChunkLengthFunction = Function<void(u64)>;
     using ProcessRequestEndOfBodyFunction = Function<void()>;
-    using ProcessEarlyHintsResponseFunction = Function<void(JS::NonnullGCPtr<Infrastructure::Response>)>;
-    using ProcessResponseFunction = Function<void(JS::NonnullGCPtr<Infrastructure::Response>)>;
-    using ProcessResponseEndOfBodyFunction = Function<void(JS::NonnullGCPtr<Infrastructure::Response>)>;
-    using ProcessResponseConsumeBodyFunction = Function<void(JS::NonnullGCPtr<Infrastructure::Response>, BodyBytes)>;
+    using ProcessEarlyHintsResponseFunction = Function<void(GC::Ref<Infrastructure::Response>)>;
+    using ProcessResponseFunction = Function<void(GC::Ref<Infrastructure::Response>)>;
+    using ProcessResponseEndOfBodyFunction = Function<void(GC::Ref<Infrastructure::Response>)>;
+    using ProcessResponseConsumeBodyFunction = Function<void(GC::Ref<Infrastructure::Response>, BodyBytes)>;
 
-    using ProcessRequestBodyChunkLengthHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessRequestBodyChunkLengthFunction::FunctionType>>;
-    using ProcessRequestEndOfBodyHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessRequestEndOfBodyFunction::FunctionType>>;
-    using ProcessEarlyHintsResponseHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessEarlyHintsResponseFunction::FunctionType>>;
-    using ProcessResponseHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessResponseFunction::FunctionType>>;
-    using ProcessResponseEndOfBodyHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessResponseEndOfBodyFunction::FunctionType>>;
-    using ProcessResponseConsumeBodyHeapFunction = JS::NonnullGCPtr<JS::HeapFunction<ProcessResponseConsumeBodyFunction::FunctionType>>;
+    using ProcessRequestBodyChunkLengthHeapFunction = GC::Ref<GC::Function<ProcessRequestBodyChunkLengthFunction::FunctionType>>;
+    using ProcessRequestEndOfBodyHeapFunction = GC::Ref<GC::Function<ProcessRequestEndOfBodyFunction::FunctionType>>;
+    using ProcessEarlyHintsResponseHeapFunction = GC::Ref<GC::Function<ProcessEarlyHintsResponseFunction::FunctionType>>;
+    using ProcessResponseHeapFunction = GC::Ref<GC::Function<ProcessResponseFunction::FunctionType>>;
+    using ProcessResponseEndOfBodyHeapFunction = GC::Ref<GC::Function<ProcessResponseEndOfBodyFunction::FunctionType>>;
+    using ProcessResponseConsumeBodyHeapFunction = GC::Ref<GC::Function<ProcessResponseConsumeBodyFunction::FunctionType>>;
 
     struct Input {
         ProcessRequestBodyChunkLengthFunction process_request_body_chunk_length;
@@ -46,7 +46,7 @@ public:
         ProcessResponseConsumeBodyFunction process_response_consume_body;
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<FetchAlgorithms> create(JS::VM&, Input);
+    [[nodiscard]] static GC::Ref<FetchAlgorithms> create(JS::VM&, Input);
 
     ProcessRequestBodyChunkLengthFunction const& process_request_body_chunk_length() const { return m_process_request_body_chunk_length->function(); }
     ProcessRequestEndOfBodyFunction const& process_request_end_of_body() const { return m_process_request_end_of_body->function(); }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchController.cpp b/Libraries/LibWeb/Fetch/Infrastructure/FetchController.cpp
index 2a2edf3218d..1bb6754d404 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchController.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchController.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
 #include <LibWeb/Fetch/Infrastructure/FetchController.h>
@@ -14,11 +14,11 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(FetchController);
+GC_DEFINE_ALLOCATOR(FetchController);
 
 FetchController::FetchController() = default;
 
-JS::NonnullGCPtr<FetchController> FetchController::create(JS::VM& vm)
+GC::Ref<FetchController> FetchController::create(JS::VM& vm)
 {
     return vm.heap().allocate<FetchController>();
 }
@@ -34,12 +34,12 @@ void FetchController::visit_edges(JS::Cell::Visitor& visitor)
 
 void FetchController::set_report_timing_steps(Function<void(JS::Object const&)> report_timing_steps)
 {
-    m_report_timing_steps = JS::create_heap_function(vm().heap(), move(report_timing_steps));
+    m_report_timing_steps = GC::create_function(vm().heap(), move(report_timing_steps));
 }
 
 void FetchController::set_next_manual_redirect_steps(Function<void()> next_manual_redirect_steps)
 {
-    m_next_manual_redirect_steps = JS::create_heap_function(vm().heap(), move(next_manual_redirect_steps));
+    m_next_manual_redirect_steps = GC::create_function(vm().heap(), move(next_manual_redirect_steps));
 }
 
 // https://fetch.spec.whatwg.org/#finalize-and-report-timing
@@ -63,7 +63,7 @@ void FetchController::process_next_manual_redirect() const
 }
 
 // https://fetch.spec.whatwg.org/#extract-full-timing-info
-JS::NonnullGCPtr<FetchTimingInfo> FetchController::extract_full_timing_info() const
+GC::Ref<FetchTimingInfo> FetchController::extract_full_timing_info() const
 {
     // 1. Assert: this’s full timing info is not null.
     VERIFY(m_full_timing_info);
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchController.h b/Libraries/LibWeb/Fetch/Infrastructure/FetchController.h
index 7613ba72f48..52a4a46d3d2 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchController.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchController.h
@@ -8,10 +8,10 @@
 
 #include <AK/Badge.h>
 #include <AK/HashMap.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/FetchTimingInfo.h>
 #include <LibWeb/Forward.h>
@@ -21,8 +21,8 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#fetch-controller
 class FetchController : public JS::Cell {
-    JS_CELL(FetchController, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchController);
+    GC_CELL(FetchController, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchController);
 
 public:
     enum class State {
@@ -31,9 +31,9 @@ public:
         Aborted,
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<FetchController> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<FetchController> create(JS::VM&);
 
-    void set_full_timing_info(JS::NonnullGCPtr<FetchTimingInfo> full_timing_info) { m_full_timing_info = full_timing_info; }
+    void set_full_timing_info(GC::Ref<FetchTimingInfo> full_timing_info) { m_full_timing_info = full_timing_info; }
     void set_report_timing_steps(Function<void(JS::Object const&)> report_timing_steps);
     void set_next_manual_redirect_steps(Function<void()> next_manual_redirect_steps);
 
@@ -41,11 +41,11 @@ public:
 
     void report_timing(JS::Object const&) const;
     void process_next_manual_redirect() const;
-    [[nodiscard]] JS::NonnullGCPtr<FetchTimingInfo> extract_full_timing_info() const;
+    [[nodiscard]] GC::Ref<FetchTimingInfo> extract_full_timing_info() const;
     void abort(JS::Realm&, Optional<JS::Value>);
     void terminate();
 
-    void set_fetch_params(Badge<FetchParams>, JS::NonnullGCPtr<FetchParams> fetch_params) { m_fetch_params = fetch_params; }
+    void set_fetch_params(Badge<FetchParams>, GC::Ref<FetchParams> fetch_params) { m_fetch_params = fetch_params; }
 
     void stop_fetch();
 
@@ -66,12 +66,12 @@ private:
     // https://fetch.spec.whatwg.org/#fetch-controller-full-timing-info
     // full timing info (default null)
     //    Null or a fetch timing info.
-    JS::GCPtr<FetchTimingInfo> m_full_timing_info;
+    GC::Ptr<FetchTimingInfo> m_full_timing_info;
 
     // https://fetch.spec.whatwg.org/#fetch-controller-report-timing-steps
     // report timing steps (default null)
     //    Null or an algorithm accepting a global object.
-    JS::GCPtr<JS::HeapFunction<void(JS::Object const&)>> m_report_timing_steps;
+    GC::Ptr<GC::Function<void(JS::Object const&)>> m_report_timing_steps;
 
     // https://fetch.spec.whatwg.org/#fetch-controller-report-timing-steps
     // FIXME: serialized abort reason (default null)
@@ -80,9 +80,9 @@ private:
     // https://fetch.spec.whatwg.org/#fetch-controller-next-manual-redirect-steps
     // next manual redirect steps (default null)
     //     Null or an algorithm accepting nothing.
-    JS::GCPtr<JS::HeapFunction<void()>> m_next_manual_redirect_steps;
+    GC::Ptr<GC::Function<void()>> m_next_manual_redirect_steps;
 
-    JS::GCPtr<FetchParams> m_fetch_params;
+    GC::Ptr<FetchParams> m_fetch_params;
 
     HashMap<u64, HTML::TaskID> m_ongoing_fetch_tasks;
     u64 m_next_fetch_task_id { 0 };
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.cpp b/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.cpp
index 9d886566677..ba2c62251c6 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.cpp
@@ -4,16 +4,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/FetchParams.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(FetchParams);
+GC_DEFINE_ALLOCATOR(FetchParams);
 
-FetchParams::FetchParams(JS::NonnullGCPtr<Request> request, JS::NonnullGCPtr<FetchAlgorithms> algorithms, JS::NonnullGCPtr<FetchController> controller, JS::NonnullGCPtr<FetchTimingInfo> timing_info)
+FetchParams::FetchParams(GC::Ref<Request> request, GC::Ref<FetchAlgorithms> algorithms, GC::Ref<FetchController> controller, GC::Ref<FetchTimingInfo> timing_info)
     : m_request(request)
     , m_algorithms(algorithms)
     , m_controller(controller)
@@ -22,7 +22,7 @@ FetchParams::FetchParams(JS::NonnullGCPtr<Request> request, JS::NonnullGCPtr<Fet
     m_controller->set_fetch_params({}, *this);
 }
 
-JS::NonnullGCPtr<FetchParams> FetchParams::create(JS::VM& vm, JS::NonnullGCPtr<Request> request, JS::NonnullGCPtr<FetchTimingInfo> timing_info)
+GC::Ref<FetchParams> FetchParams::create(JS::VM& vm, GC::Ref<Request> request, GC::Ref<FetchTimingInfo> timing_info)
 {
     auto algorithms = Infrastructure::FetchAlgorithms::create(vm, {});
     auto controller = Infrastructure::FetchController::create(vm);
@@ -36,10 +36,10 @@ void FetchParams::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_algorithms);
     visitor.visit(m_controller);
     visitor.visit(m_timing_info);
-    if (m_task_destination.has<JS::NonnullGCPtr<JS::Object>>())
-        visitor.visit(m_task_destination.get<JS::NonnullGCPtr<JS::Object>>());
-    if (m_preloaded_response_candidate.has<JS::NonnullGCPtr<Response>>())
-        visitor.visit(m_preloaded_response_candidate.get<JS::NonnullGCPtr<Response>>());
+    if (m_task_destination.has<GC::Ref<JS::Object>>())
+        visitor.visit(m_task_destination.get<GC::Ref<JS::Object>>());
+    if (m_preloaded_response_candidate.has<GC::Ref<Response>>())
+        visitor.visit(m_preloaded_response_candidate.get<GC::Ref<Response>>());
 }
 
 // https://fetch.spec.whatwg.org/#fetch-params-aborted
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.h b/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.h
index 31da8ba9b3c..705277dece8 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchParams.h
@@ -7,9 +7,9 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Fetch/Infrastructure/FetchAlgorithms.h>
 #include <LibWeb/Fetch/Infrastructure/FetchController.h>
 #include <LibWeb/Fetch/Infrastructure/FetchTimingInfo.h>
@@ -20,21 +20,21 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#fetch-params
 class FetchParams : public JS::Cell {
-    JS_CELL(FetchParams, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchParams);
+    GC_CELL(FetchParams, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchParams);
 
 public:
     struct PreloadedResponseCandidatePendingTag { };
-    using PreloadedResponseCandidate = Variant<Empty, PreloadedResponseCandidatePendingTag, JS::NonnullGCPtr<Response>>;
+    using PreloadedResponseCandidate = Variant<Empty, PreloadedResponseCandidatePendingTag, GC::Ref<Response>>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<FetchParams> create(JS::VM&, JS::NonnullGCPtr<Request>, JS::NonnullGCPtr<FetchTimingInfo>);
+    [[nodiscard]] static GC::Ref<FetchParams> create(JS::VM&, GC::Ref<Request>, GC::Ref<FetchTimingInfo>);
 
-    [[nodiscard]] JS::NonnullGCPtr<Request> request() const { return m_request; }
-    [[nodiscard]] JS::NonnullGCPtr<FetchController> controller() const { return m_controller; }
-    [[nodiscard]] JS::NonnullGCPtr<FetchTimingInfo> timing_info() const { return m_timing_info; }
+    [[nodiscard]] GC::Ref<Request> request() const { return m_request; }
+    [[nodiscard]] GC::Ref<FetchController> controller() const { return m_controller; }
+    [[nodiscard]] GC::Ref<FetchTimingInfo> timing_info() const { return m_timing_info; }
 
-    [[nodiscard]] JS::NonnullGCPtr<FetchAlgorithms const> algorithms() const { return m_algorithms; }
-    void set_algorithms(JS::NonnullGCPtr<FetchAlgorithms const> algorithms) { m_algorithms = algorithms; }
+    [[nodiscard]] GC::Ref<FetchAlgorithms const> algorithms() const { return m_algorithms; }
+    void set_algorithms(GC::Ref<FetchAlgorithms const> algorithms) { m_algorithms = algorithms; }
 
     [[nodiscard]] TaskDestination& task_destination() { return m_task_destination; }
     [[nodiscard]] TaskDestination const& task_destination() const { return m_task_destination; }
@@ -51,14 +51,14 @@ public:
     [[nodiscard]] bool is_canceled() const;
 
 private:
-    FetchParams(JS::NonnullGCPtr<Request>, JS::NonnullGCPtr<FetchAlgorithms>, JS::NonnullGCPtr<FetchController>, JS::NonnullGCPtr<FetchTimingInfo>);
+    FetchParams(GC::Ref<Request>, GC::Ref<FetchAlgorithms>, GC::Ref<FetchController>, GC::Ref<FetchTimingInfo>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     // https://fetch.spec.whatwg.org/#fetch-params-request
     // request
     //     A request.
-    JS::NonnullGCPtr<Request> m_request;
+    GC::Ref<Request> m_request;
 
     // https://fetch.spec.whatwg.org/#fetch-params-process-request-body
     // process request body chunk length (default null)
@@ -73,7 +73,7 @@ private:
     // https://fetch.spec.whatwg.org/#fetch-params-process-response-consume-body
     // process response consume body (default null)
     //     Null or an algorithm.
-    JS::NonnullGCPtr<FetchAlgorithms const> m_algorithms;
+    GC::Ref<FetchAlgorithms const> m_algorithms;
 
     // https://fetch.spec.whatwg.org/#fetch-params-task-destination
     // task destination (default null)
@@ -88,12 +88,12 @@ private:
     // https://fetch.spec.whatwg.org/#fetch-params-controller
     // controller (default a new fetch controller)
     //     A fetch controller.
-    JS::NonnullGCPtr<FetchController> m_controller;
+    GC::Ref<FetchController> m_controller;
 
     // https://fetch.spec.whatwg.org/#fetch-params-timing-info
     // timing info
     //     A fetch timing info.
-    JS::NonnullGCPtr<FetchTimingInfo> m_timing_info;
+    GC::Ref<FetchTimingInfo> m_timing_info;
 
     // https://fetch.spec.whatwg.org/#fetch-params-preloaded-response-candidate
     // preloaded response candidate (default null)
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.cpp b/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.cpp
index 68cccdc07f5..6142ec9f2d0 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.cpp
@@ -8,24 +8,24 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(FetchRecord);
+GC_DEFINE_ALLOCATOR(FetchRecord);
 
-JS::NonnullGCPtr<FetchRecord> FetchRecord::create(JS::VM& vm, JS::NonnullGCPtr<Infrastructure::Request> request)
+GC::Ref<FetchRecord> FetchRecord::create(JS::VM& vm, GC::Ref<Infrastructure::Request> request)
 {
     return vm.heap().allocate<FetchRecord>(request);
 }
 
-JS::NonnullGCPtr<FetchRecord> FetchRecord::create(JS::VM& vm, JS::NonnullGCPtr<Infrastructure::Request> request, JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
+GC::Ref<FetchRecord> FetchRecord::create(JS::VM& vm, GC::Ref<Infrastructure::Request> request, GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller)
 {
     return vm.heap().allocate<FetchRecord>(request, fetch_controller);
 }
 
-FetchRecord::FetchRecord(JS::NonnullGCPtr<Infrastructure::Request> request)
+FetchRecord::FetchRecord(GC::Ref<Infrastructure::Request> request)
     : m_request(request)
 {
 }
 
-FetchRecord::FetchRecord(JS::NonnullGCPtr<Infrastructure::Request> request, JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
+FetchRecord::FetchRecord(GC::Ref<Infrastructure::Request> request, GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller)
     : m_request(request)
     , m_fetch_controller(fetch_controller)
 {
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.h b/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.h
index 3e06b337251..758a87c37a3 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchRecord.h
@@ -13,32 +13,32 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#concept-fetch-record
 class FetchRecord : public JS::Cell {
-    JS_CELL(FetchRecord, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchRecord);
+    GC_CELL(FetchRecord, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchRecord);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FetchRecord> create(JS::VM&, JS::NonnullGCPtr<Infrastructure::Request>);
-    [[nodiscard]] static JS::NonnullGCPtr<FetchRecord> create(JS::VM&, JS::NonnullGCPtr<Infrastructure::Request>, JS::GCPtr<FetchController>);
+    [[nodiscard]] static GC::Ref<FetchRecord> create(JS::VM&, GC::Ref<Infrastructure::Request>);
+    [[nodiscard]] static GC::Ref<FetchRecord> create(JS::VM&, GC::Ref<Infrastructure::Request>, GC::Ptr<FetchController>);
 
-    [[nodiscard]] JS::NonnullGCPtr<Infrastructure::Request> request() const { return m_request; }
-    void set_request(JS::NonnullGCPtr<Infrastructure::Request> request) { m_request = request; }
+    [[nodiscard]] GC::Ref<Infrastructure::Request> request() const { return m_request; }
+    void set_request(GC::Ref<Infrastructure::Request> request) { m_request = request; }
 
-    [[nodiscard]] JS::GCPtr<FetchController> fetch_controller() const { return m_fetch_controller; }
-    void set_fetch_controller(JS::GCPtr<FetchController> fetch_controller) { m_fetch_controller = fetch_controller; }
+    [[nodiscard]] GC::Ptr<FetchController> fetch_controller() const { return m_fetch_controller; }
+    void set_fetch_controller(GC::Ptr<FetchController> fetch_controller) { m_fetch_controller = fetch_controller; }
 
 private:
-    explicit FetchRecord(JS::NonnullGCPtr<Infrastructure::Request>);
-    FetchRecord(JS::NonnullGCPtr<Infrastructure::Request>, JS::GCPtr<FetchController>);
+    explicit FetchRecord(GC::Ref<Infrastructure::Request>);
+    FetchRecord(GC::Ref<Infrastructure::Request>, GC::Ptr<FetchController>);
 
     virtual void visit_edges(Visitor&) override;
 
     // https://fetch.spec.whatwg.org/#concept-request
     // A fetch record has an associated request (a request)
-    JS::NonnullGCPtr<Infrastructure::Request> m_request;
+    GC::Ref<Infrastructure::Request> m_request;
 
     // https://fetch.spec.whatwg.org/#fetch-controller
     // A fetch record has an associated controller (a fetch controller or null)
-    JS::GCPtr<FetchController> m_fetch_controller { nullptr };
+    GC::Ptr<FetchController> m_fetch_controller { nullptr };
 };
 
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.cpp b/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.cpp
index 39de4db7317..2e54d5dea45 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.cpp
@@ -4,17 +4,17 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Fetch/Infrastructure/FetchTimingInfo.h>
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(FetchTimingInfo);
+GC_DEFINE_ALLOCATOR(FetchTimingInfo);
 
 FetchTimingInfo::FetchTimingInfo() = default;
 
-JS::NonnullGCPtr<FetchTimingInfo> FetchTimingInfo::create(JS::VM& vm)
+GC::Ref<FetchTimingInfo> FetchTimingInfo::create(JS::VM& vm)
 {
     return vm.heap().allocate<FetchTimingInfo>();
 }
@@ -26,7 +26,7 @@ void FetchTimingInfo::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://fetch.spec.whatwg.org/#create-an-opaque-timing-info
-JS::NonnullGCPtr<FetchTimingInfo> create_opaque_timing_info(JS::VM& vm, FetchTimingInfo const& timing_info)
+GC::Ref<FetchTimingInfo> create_opaque_timing_info(JS::VM& vm, FetchTimingInfo const& timing_info)
 {
     // To create an opaque timing info, given a fetch timing info timingInfo, return a new fetch timing info whose
     // start time and post-redirect start time are timingInfo’s start time.
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.h b/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.h
index 05a52d634d0..a41c5a9a161 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.h
@@ -8,9 +8,9 @@
 
 #include <AK/String.h>
 #include <AK/Vector.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Fetch/Infrastructure/ConnectionTimingInfo.h>
 #include <LibWeb/HighResolutionTime/DOMHighResTimeStamp.h>
 
@@ -18,11 +18,11 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#fetch-timing-info
 class FetchTimingInfo : public JS::Cell {
-    JS_CELL(FetchTimingInfo, JS::Cell);
-    JS_DECLARE_ALLOCATOR(FetchTimingInfo);
+    GC_CELL(FetchTimingInfo, JS::Cell);
+    GC_DECLARE_ALLOCATOR(FetchTimingInfo);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FetchTimingInfo> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<FetchTimingInfo> create(JS::VM&);
 
     [[nodiscard]] HighResolutionTime::DOMHighResTimeStamp start_time() const { return m_start_time; }
     void set_start_time(HighResolutionTime::DOMHighResTimeStamp start_time) { m_start_time = start_time; }
@@ -48,8 +48,8 @@ public:
     [[nodiscard]] HighResolutionTime::DOMHighResTimeStamp end_time() const { return m_end_time; }
     void set_end_time(HighResolutionTime::DOMHighResTimeStamp end_time) { m_end_time = end_time; }
 
-    [[nodiscard]] JS::GCPtr<ConnectionTimingInfo> final_connection_timing_info() const { return m_final_connection_timing_info; }
-    void set_final_connection_timing_info(JS::GCPtr<ConnectionTimingInfo> final_connection_timing_info) { m_final_connection_timing_info = final_connection_timing_info; }
+    [[nodiscard]] GC::Ptr<ConnectionTimingInfo> final_connection_timing_info() const { return m_final_connection_timing_info; }
+    void set_final_connection_timing_info(GC::Ptr<ConnectionTimingInfo> final_connection_timing_info) { m_final_connection_timing_info = final_connection_timing_info; }
 
     [[nodiscard]] Vector<String>& server_timing_headers() { return m_server_timing_headers; }
     [[nodiscard]] Vector<String> const& server_timing_headers() const { return m_server_timing_headers; }
@@ -106,7 +106,7 @@ private:
     // https://fetch.spec.whatwg.org/#fetch-timing-info-final-connection-timing-info
     // final connection timing info (default null)
     //     Null or a connection timing info.
-    JS::GCPtr<ConnectionTimingInfo> m_final_connection_timing_info;
+    GC::Ptr<ConnectionTimingInfo> m_final_connection_timing_info;
 
     // https://fetch.spec.whatwg.org/#fetch-timing-info-server-timing-headers
     // server-timing headers (default « »)
@@ -119,6 +119,6 @@ private:
     bool m_render_blocking { false };
 };
 
-JS::NonnullGCPtr<FetchTimingInfo> create_opaque_timing_info(JS::VM&, FetchTimingInfo const& timing_info);
+GC::Ref<FetchTimingInfo> create_opaque_timing_info(JS::VM&, FetchTimingInfo const& timing_info);
 
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.cpp b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.cpp
index bed2dc6410c..a07a854b540 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.cpp
@@ -16,24 +16,24 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(Body);
+GC_DEFINE_ALLOCATOR(Body);
 
-JS::NonnullGCPtr<Body> Body::create(JS::VM& vm, JS::NonnullGCPtr<Streams::ReadableStream> stream)
+GC::Ref<Body> Body::create(JS::VM& vm, GC::Ref<Streams::ReadableStream> stream)
 {
     return vm.heap().allocate<Body>(stream);
 }
 
-JS::NonnullGCPtr<Body> Body::create(JS::VM& vm, JS::NonnullGCPtr<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
+GC::Ref<Body> Body::create(JS::VM& vm, GC::Ref<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
 {
     return vm.heap().allocate<Body>(stream, source, length);
 }
 
-Body::Body(JS::NonnullGCPtr<Streams::ReadableStream> stream)
+Body::Body(GC::Ref<Streams::ReadableStream> stream)
     : m_stream(move(stream))
 {
 }
 
-Body::Body(JS::NonnullGCPtr<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
+Body::Body(GC::Ref<Streams::ReadableStream> stream, SourceType source, Optional<u64> length)
     : m_stream(move(stream))
     , m_source(move(source))
     , m_length(move(length))
@@ -47,7 +47,7 @@ void Body::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://fetch.spec.whatwg.org/#concept-body-clone
-JS::NonnullGCPtr<Body> Body::clone(JS::Realm& realm)
+GC::Ref<Body> Body::clone(JS::Realm& realm)
 {
     HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
@@ -68,21 +68,21 @@ void Body::fully_read(JS::Realm& realm, Web::Fetch::Infrastructure::Body::Proces
     // FIXME: 1. If taskDestination is null, then set taskDestination to the result of starting a new parallel queue.
     // FIXME: Handle 'parallel queue' task destination
     VERIFY(!task_destination.has<Empty>());
-    auto task_destination_object = task_destination.get<JS::NonnullGCPtr<JS::Object>>();
+    auto task_destination_object = task_destination.get<GC::Ref<JS::Object>>();
 
     // 2. Let successSteps given a byte sequence bytes be to queue a fetch task to run processBody given bytes, with taskDestination.
     auto success_steps = [&realm, process_body, task_destination_object = task_destination_object](ReadonlyBytes bytes) -> ErrorOr<void> {
         // Make a copy of the bytes, as the source of the bytes may disappear between the time the task is queued and executed.
         auto bytes_copy = TRY(ByteBuffer::copy(bytes));
-        queue_fetch_task(*task_destination_object, JS::create_heap_function(realm.heap(), [process_body, bytes_copy = move(bytes_copy)]() mutable {
+        queue_fetch_task(*task_destination_object, GC::create_function(realm.heap(), [process_body, bytes_copy = move(bytes_copy)]() mutable {
             process_body->function()(move(bytes_copy));
         }));
         return {};
     };
 
     // 3. Let errorSteps optionally given an exception exception be to queue a fetch task to run processBodyError given exception, with taskDestination.
-    auto error_steps = [&realm, process_body_error, task_destination_object](JS::GCPtr<WebIDL::DOMException> exception) {
-        queue_fetch_task(*task_destination_object, JS::create_heap_function(realm.heap(), [process_body_error, exception]() {
+    auto error_steps = [&realm, process_body_error, task_destination_object](GC::Ptr<WebIDL::DOMException> exception) {
+        queue_fetch_task(*task_destination_object, GC::create_function(realm.heap(), [process_body_error, exception]() {
             process_body_error->function()(exception);
         }));
     };
@@ -95,7 +95,7 @@ void Body::fully_read(JS::Realm& realm, Web::Fetch::Infrastructure::Body::Proces
             if (auto result = success_steps(byte_buffer); result.is_error())
                 error_steps(WebIDL::UnknownError::create(realm, "Out-of-memory"_string));
         },
-        [&](JS::Handle<FileAPI::Blob> const& blob) {
+        [&](GC::Root<FileAPI::Blob> const& blob) {
             if (auto result = success_steps(blob->raw_bytes()); result.is_error())
                 error_steps(WebIDL::UnknownError::create(realm, "Out-of-memory"_string));
         },
@@ -109,7 +109,7 @@ void Body::incrementally_read(ProcessBodyChunkCallback process_body_chunk, Proce
 {
     HTML::TemporaryExecutionContext const execution_context { m_stream->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
-    VERIFY(task_destination.has<JS::NonnullGCPtr<JS::Object>>());
+    VERIFY(task_destination.has<GC::Ref<JS::Object>>());
     // FIXME: 1. If taskDestination is null, then set taskDestination to the result of starting a new parallel queue.
     // FIXME: Handle 'parallel queue' task destination
 
@@ -118,11 +118,11 @@ void Body::incrementally_read(ProcessBodyChunkCallback process_body_chunk, Proce
     auto reader = MUST(Streams::acquire_readable_stream_default_reader(m_stream));
 
     // 3. Perform the incrementally-read loop given reader, taskDestination, processBodyChunk, processEndOfBody, and processBodyError.
-    incrementally_read_loop(reader, task_destination.get<JS::NonnullGCPtr<JS::Object>>(), process_body_chunk, process_end_of_body, process_body_error);
+    incrementally_read_loop(reader, task_destination.get<GC::Ref<JS::Object>>(), process_body_chunk, process_end_of_body, process_body_error);
 }
 
 // https://fetch.spec.whatwg.org/#incrementally-read-loop
-void Body::incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader, JS::NonnullGCPtr<JS::Object> task_destination, ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error)
+void Body::incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader, GC::Ref<JS::Object> task_destination, ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error)
 
 {
     auto& realm = reader.realm();
@@ -134,7 +134,7 @@ void Body::incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader,
 }
 
 // https://fetch.spec.whatwg.org/#byte-sequence-as-a-body
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Body>> byte_sequence_as_body(JS::Realm& realm, ReadonlyBytes bytes)
+WebIDL::ExceptionOr<GC::Ref<Body>> byte_sequence_as_body(JS::Realm& realm, ReadonlyBytes bytes)
 {
     // To get a byte sequence bytes as a body, return the body of the result of safely extracting bytes.
     auto [body, _] = TRY(safely_extract_body(realm, bytes));
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.h b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.h
index 9a5f5be4d4f..6318f9dee55 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Bodies.h
@@ -11,8 +11,8 @@
 #include <AK/NonnullRefPtr.h>
 #include <AK/Optional.h>
 #include <AK/Variant.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Fetch/Infrastructure/Task.h>
 #include <LibWeb/FileAPI/Blob.h>
 #include <LibWeb/Streams/ReadableStream.h>
@@ -22,43 +22,43 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#concept-body
 class Body final : public JS::Cell {
-    JS_CELL(Body, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Body);
+    GC_CELL(Body, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Body);
 
 public:
-    using SourceType = Variant<Empty, ByteBuffer, JS::Handle<FileAPI::Blob>>;
+    using SourceType = Variant<Empty, ByteBuffer, GC::Root<FileAPI::Blob>>;
     // processBody must be an algorithm accepting a byte sequence.
-    using ProcessBodyCallback = JS::NonnullGCPtr<JS::HeapFunction<void(ByteBuffer)>>;
+    using ProcessBodyCallback = GC::Ref<GC::Function<void(ByteBuffer)>>;
     // processBodyError must be an algorithm optionally accepting an exception.
-    using ProcessBodyErrorCallback = JS::NonnullGCPtr<JS::HeapFunction<void(JS::Value)>>;
+    using ProcessBodyErrorCallback = GC::Ref<GC::Function<void(JS::Value)>>;
     // processBodyChunk must be an algorithm accepting a byte sequence.
-    using ProcessBodyChunkCallback = JS::NonnullGCPtr<JS::HeapFunction<void(ByteBuffer)>>;
+    using ProcessBodyChunkCallback = GC::Ref<GC::Function<void(ByteBuffer)>>;
     // processEndOfBody must be an algorithm accepting no arguments
-    using ProcessEndOfBodyCallback = JS::NonnullGCPtr<JS::HeapFunction<void()>>;
+    using ProcessEndOfBodyCallback = GC::Ref<GC::Function<void()>>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<Body> create(JS::VM&, JS::NonnullGCPtr<Streams::ReadableStream>);
-    [[nodiscard]] static JS::NonnullGCPtr<Body> create(JS::VM&, JS::NonnullGCPtr<Streams::ReadableStream>, SourceType, Optional<u64>);
+    [[nodiscard]] static GC::Ref<Body> create(JS::VM&, GC::Ref<Streams::ReadableStream>);
+    [[nodiscard]] static GC::Ref<Body> create(JS::VM&, GC::Ref<Streams::ReadableStream>, SourceType, Optional<u64>);
 
-    [[nodiscard]] JS::NonnullGCPtr<Streams::ReadableStream> stream() const { return *m_stream; }
-    void set_stream(JS::NonnullGCPtr<Streams::ReadableStream> value) { m_stream = value; }
+    [[nodiscard]] GC::Ref<Streams::ReadableStream> stream() const { return *m_stream; }
+    void set_stream(GC::Ref<Streams::ReadableStream> value) { m_stream = value; }
     [[nodiscard]] SourceType const& source() const { return m_source; }
     [[nodiscard]] Optional<u64> const& length() const { return m_length; }
 
-    [[nodiscard]] JS::NonnullGCPtr<Body> clone(JS::Realm&);
+    [[nodiscard]] GC::Ref<Body> clone(JS::Realm&);
 
     void fully_read(JS::Realm&, ProcessBodyCallback process_body, ProcessBodyErrorCallback process_body_error, TaskDestination task_destination) const;
     void incrementally_read(ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error, TaskDestination task_destination);
-    void incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader, JS::NonnullGCPtr<JS::Object> task_destination, ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error);
+    void incrementally_read_loop(Streams::ReadableStreamDefaultReader& reader, GC::Ref<JS::Object> task_destination, ProcessBodyChunkCallback process_body_chunk, ProcessEndOfBodyCallback process_end_of_body, ProcessBodyErrorCallback process_body_error);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
 private:
-    explicit Body(JS::NonnullGCPtr<Streams::ReadableStream>);
-    Body(JS::NonnullGCPtr<Streams::ReadableStream>, SourceType, Optional<u64>);
+    explicit Body(GC::Ref<Streams::ReadableStream>);
+    Body(GC::Ref<Streams::ReadableStream>, SourceType, Optional<u64>);
 
     // https://fetch.spec.whatwg.org/#concept-body-stream
     // A stream (a ReadableStream object).
-    JS::NonnullGCPtr<Streams::ReadableStream> m_stream;
+    GC::Ref<Streams::ReadableStream> m_stream;
 
     // https://fetch.spec.whatwg.org/#concept-body-source
     // A source (null, a byte sequence, a Blob object, or a FormData object), initially null.
@@ -72,10 +72,10 @@ private:
 // https://fetch.spec.whatwg.org/#body-with-type
 // A body with type is a tuple that consists of a body (a body) and a type (a header value or null).
 struct BodyWithType {
-    JS::NonnullGCPtr<Body> body;
+    GC::Ref<Body> body;
     Optional<ByteBuffer> type;
 };
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Body>> byte_sequence_as_body(JS::Realm&, ReadonlyBytes);
+WebIDL::ExceptionOr<GC::Ref<Body>> byte_sequence_as_body(JS::Realm&, ReadonlyBytes);
 
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.cpp b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.cpp
index d0a51a10630..9df95ecc2cb 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.cpp
@@ -12,7 +12,7 @@
 #include <AK/QuickSort.h>
 #include <AK/ScopeGuard.h>
 #include <AK/StringUtils.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibRegex/Regex.h>
 #include <LibTextCodec/Decoder.h>
@@ -26,7 +26,7 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(HeaderList);
+GC_DEFINE_ALLOCATOR(HeaderList);
 
 template<typename T>
 requires(IsSameIgnoringCV<T, u8>) struct CaseInsensitiveBytesTraits : public Traits<Span<T>> {
@@ -58,7 +58,7 @@ Header Header::from_string_pair(StringView name, StringView value)
     };
 }
 
-JS::NonnullGCPtr<HeaderList> HeaderList::create(JS::VM& vm)
+GC::Ref<HeaderList> HeaderList::create(JS::VM& vm)
 {
     return vm.heap().allocate<HeaderList>();
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.h b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.h
index 04634e3894f..cc6035b35a3 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Headers.h
@@ -13,10 +13,10 @@
 #include <AK/Optional.h>
 #include <AK/String.h>
 #include <AK/Vector.h>
+#include <LibGC/Heap.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibWeb/MimeSniff/MimeType.h>
 
 namespace Web::Fetch::Infrastructure {
@@ -36,8 +36,8 @@ struct Header {
 class HeaderList final
     : public JS::Cell
     , public Vector<Header> {
-    JS_CELL(HeaderList, JS::Cell);
-    JS_DECLARE_ALLOCATOR(HeaderList);
+    GC_CELL(HeaderList, JS::Cell);
+    GC_DECLARE_ALLOCATOR(HeaderList);
 
 public:
     using Vector::begin;
@@ -45,7 +45,7 @@ public:
     using Vector::end;
     using Vector::is_empty;
 
-    [[nodiscard]] static JS::NonnullGCPtr<HeaderList> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<HeaderList> create(JS::VM&);
 
     [[nodiscard]] bool contains(ReadonlyBytes) const;
     [[nodiscard]] Optional<ByteBuffer> get(ReadonlyBytes) const;
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.cpp b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.cpp
index 295d9e54ccb..975970503ef 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.cpp
@@ -5,7 +5,7 @@
  */
 
 #include <AK/Array.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/DOMURL/DOMURL.h>
 #include <LibWeb/Fetch/Fetching/PendingResponse.h>
@@ -13,9 +13,9 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(Request);
+GC_DEFINE_ALLOCATOR(Request);
 
-Request::Request(JS::NonnullGCPtr<HeaderList> header_list)
+Request::Request(GC::Ref<HeaderList> header_list)
     : m_header_list(header_list)
 {
 }
@@ -26,16 +26,16 @@ void Request::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_header_list);
     visitor.visit(m_client);
     m_body.visit(
-        [&](JS::NonnullGCPtr<Body>& body) { visitor.visit(body); },
+        [&](GC::Ref<Body>& body) { visitor.visit(body); },
         [](auto&) {});
     visitor.visit(m_reserved_client);
     m_window.visit(
-        [&](JS::GCPtr<HTML::EnvironmentSettingsObject> const& value) { visitor.visit(value); },
+        [&](GC::Ptr<HTML::EnvironmentSettingsObject> const& value) { visitor.visit(value); },
         [](auto const&) {});
     visitor.visit(m_pending_responses);
 }
 
-JS::NonnullGCPtr<Request> Request::create(JS::VM& vm)
+GC::Ref<Request> Request::create(JS::VM& vm)
 {
     return vm.heap().allocate<Request>(HeaderList::create(vm));
 }
@@ -205,7 +205,7 @@ ByteBuffer Request::byte_serialize_origin() const
 }
 
 // https://fetch.spec.whatwg.org/#concept-request-clone
-JS::NonnullGCPtr<Request> Request::clone(JS::Realm& realm) const
+GC::Ref<Request> Request::clone(JS::Realm& realm) const
 {
     // To clone a request request, run these steps:
     auto& vm = realm.vm();
@@ -253,7 +253,7 @@ JS::NonnullGCPtr<Request> Request::clone(JS::Realm& realm) const
     new_request->set_buffer_policy(m_buffer_policy);
 
     // 2. If request’s body is non-null, set newRequest’s body to the result of cloning request’s body.
-    if (auto const* body = m_body.get_pointer<JS::NonnullGCPtr<Body>>())
+    if (auto const* body = m_body.get_pointer<GC::Ref<Body>>())
         new_request->set_body((*body)->clone(realm));
 
     // 3. Return newRequest.
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.h b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.h
index 873e6114b37..c6d8d103526 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Requests.h
@@ -14,9 +14,9 @@
 #include <AK/String.h>
 #include <AK/Variant.h>
 #include <AK/Vector.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibURL/Origin.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
@@ -28,8 +28,8 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#concept-request
 class Request final : public JS::Cell {
-    JS_CELL(Request, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Request);
+    GC_CELL(Request, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Request);
 
 public:
     enum class CacheMode {
@@ -169,14 +169,14 @@ public:
     // Members are implementation-defined
     struct InternalPriority { };
 
-    using BodyType = Variant<Empty, ByteBuffer, JS::NonnullGCPtr<Body>>;
+    using BodyType = Variant<Empty, ByteBuffer, GC::Ref<Body>>;
     using OriginType = Variant<Origin, URL::Origin>;
     using PolicyContainerType = Variant<PolicyContainer, HTML::PolicyContainer>;
     using ReferrerType = Variant<Referrer, URL::URL>;
-    using ReservedClientType = JS::GCPtr<HTML::Environment>;
-    using WindowType = Variant<Window, JS::GCPtr<HTML::EnvironmentSettingsObject>>;
+    using ReservedClientType = GC::Ptr<HTML::Environment>;
+    using WindowType = Variant<Window, GC::Ptr<HTML::EnvironmentSettingsObject>>;
 
-    [[nodiscard]] static JS::NonnullGCPtr<Request> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<Request> create(JS::VM&);
 
     [[nodiscard]] ReadonlyBytes method() const { return m_method; }
     void set_method(ByteBuffer method) { m_method = move(method); }
@@ -184,8 +184,8 @@ public:
     [[nodiscard]] bool local_urls_only() const { return m_local_urls_only; }
     void set_local_urls_only(bool local_urls_only) { m_local_urls_only = local_urls_only; }
 
-    [[nodiscard]] JS::NonnullGCPtr<HeaderList> header_list() const { return m_header_list; }
-    void set_header_list(JS::NonnullGCPtr<HeaderList> header_list) { m_header_list = header_list; }
+    [[nodiscard]] GC::Ref<HeaderList> header_list() const { return m_header_list; }
+    void set_header_list(GC::Ref<HeaderList> header_list) { m_header_list = header_list; }
 
     [[nodiscard]] bool unsafe_request() const { return m_unsafe_request; }
     void set_unsafe_request(bool unsafe_request) { m_unsafe_request = unsafe_request; }
@@ -194,8 +194,8 @@ public:
     [[nodiscard]] BodyType& body() { return m_body; }
     void set_body(BodyType body) { m_body = move(body); }
 
-    [[nodiscard]] JS::GCPtr<HTML::EnvironmentSettingsObject const> client() const { return m_client; }
-    [[nodiscard]] JS::GCPtr<HTML::EnvironmentSettingsObject> client() { return m_client; }
+    [[nodiscard]] GC::Ptr<HTML::EnvironmentSettingsObject const> client() const { return m_client; }
+    [[nodiscard]] GC::Ptr<HTML::EnvironmentSettingsObject> client() { return m_client; }
     void set_client(HTML::EnvironmentSettingsObject* client) { m_client = client; }
 
     [[nodiscard]] ReservedClientType const& reserved_client() const { return m_reserved_client; }
@@ -313,7 +313,7 @@ public:
     [[nodiscard]] String serialize_origin() const;
     [[nodiscard]] ByteBuffer byte_serialize_origin() const;
 
-    [[nodiscard]] JS::NonnullGCPtr<Request> clone(JS::Realm&) const;
+    [[nodiscard]] GC::Ref<Request> clone(JS::Realm&) const;
 
     void add_range_header(u64 first, Optional<u64> const& last);
     void add_origin_header();
@@ -321,13 +321,13 @@ public:
     [[nodiscard]] bool cross_origin_embedder_policy_allows_credentials() const;
 
     // Non-standard
-    void add_pending_response(Badge<Fetching::PendingResponse>, JS::NonnullGCPtr<Fetching::PendingResponse> pending_response)
+    void add_pending_response(Badge<Fetching::PendingResponse>, GC::Ref<Fetching::PendingResponse> pending_response)
     {
         VERIFY(!m_pending_responses.contains_slow(pending_response));
         m_pending_responses.append(pending_response);
     }
 
-    void remove_pending_response(Badge<Fetching::PendingResponse>, JS::NonnullGCPtr<Fetching::PendingResponse> pending_response)
+    void remove_pending_response(Badge<Fetching::PendingResponse>, GC::Ref<Fetching::PendingResponse> pending_response)
     {
         m_pending_responses.remove_first_matching([&](auto gc_ptr) { return gc_ptr == pending_response; });
     }
@@ -336,7 +336,7 @@ public:
     void set_buffer_policy(BufferPolicy buffer_policy) { m_buffer_policy = buffer_policy; }
 
 private:
-    explicit Request(JS::NonnullGCPtr<HeaderList>);
+    explicit Request(GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
@@ -350,7 +350,7 @@ private:
 
     // https://fetch.spec.whatwg.org/#concept-request-header-list
     // A request has an associated header list (a header list). Unless stated otherwise it is empty.
-    JS::NonnullGCPtr<HeaderList> m_header_list;
+    GC::Ref<HeaderList> m_header_list;
 
     // https://fetch.spec.whatwg.org/#unsafe-request-flag
     // A request has an associated unsafe-request flag. Unless stated otherwise it is unset.
@@ -362,7 +362,7 @@ private:
 
     // https://fetch.spec.whatwg.org/#concept-request-client
     // A request has an associated client (null or an environment settings object).
-    JS::GCPtr<HTML::EnvironmentSettingsObject> m_client;
+    GC::Ptr<HTML::EnvironmentSettingsObject> m_client;
 
     // https://fetch.spec.whatwg.org/#concept-request-reserved-client
     // A request has an associated reserved client (null, an environment, or an environment settings object). Unless
@@ -524,7 +524,7 @@ private:
     bool m_timing_allow_failed { false };
 
     // Non-standard
-    Vector<JS::NonnullGCPtr<Fetching::PendingResponse>> m_pending_responses;
+    Vector<GC::Ref<Fetching::PendingResponse>> m_pending_responses;
 
     BufferPolicy m_buffer_policy { BufferPolicy::BufferResponse };
 };
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp
index cb6e1ce5e1d..5b39a61cf67 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.cpp
@@ -6,7 +6,7 @@
 
 #include <AK/Debug.h>
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Bindings/MainThreadVM.h>
@@ -17,13 +17,13 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(Response);
-JS_DEFINE_ALLOCATOR(BasicFilteredResponse);
-JS_DEFINE_ALLOCATOR(CORSFilteredResponse);
-JS_DEFINE_ALLOCATOR(OpaqueFilteredResponse);
-JS_DEFINE_ALLOCATOR(OpaqueRedirectFilteredResponse);
+GC_DEFINE_ALLOCATOR(Response);
+GC_DEFINE_ALLOCATOR(BasicFilteredResponse);
+GC_DEFINE_ALLOCATOR(CORSFilteredResponse);
+GC_DEFINE_ALLOCATOR(OpaqueFilteredResponse);
+GC_DEFINE_ALLOCATOR(OpaqueRedirectFilteredResponse);
 
-Response::Response(JS::NonnullGCPtr<HeaderList> header_list)
+Response::Response(GC::Ref<HeaderList> header_list)
     : m_header_list(header_list)
     , m_response_time(UnixDateTime::now())
 {
@@ -36,7 +36,7 @@ void Response::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_body);
 }
 
-JS::NonnullGCPtr<Response> Response::create(JS::VM& vm)
+GC::Ref<Response> Response::create(JS::VM& vm)
 {
     return vm.heap().allocate<Response>(HeaderList::create(vm));
 }
@@ -45,14 +45,14 @@ JS::NonnullGCPtr<Response> Response::create(JS::VM& vm)
 // A network error is a response whose status is always 0, status message is always
 // the empty byte sequence, header list is always empty, and body is always null.
 
-JS::NonnullGCPtr<Response> Response::aborted_network_error(JS::VM& vm)
+GC::Ref<Response> Response::aborted_network_error(JS::VM& vm)
 {
     auto response = network_error(vm, "Fetch has been aborted"sv);
     response->set_aborted(true);
     return response;
 }
 
-JS::NonnullGCPtr<Response> Response::network_error(JS::VM& vm, Variant<String, StringView> message)
+GC::Ref<Response> Response::network_error(JS::VM& vm, Variant<String, StringView> message)
 {
     dbgln_if(WEB_FETCH_DEBUG, "Fetch: Creating network error response with message: {}", message.visit([](auto const& s) -> StringView { return s; }));
     auto response = Response::create(vm);
@@ -64,7 +64,7 @@ JS::NonnullGCPtr<Response> Response::network_error(JS::VM& vm, Variant<String, S
 }
 
 // https://fetch.spec.whatwg.org/#appropriate-network-error
-JS::NonnullGCPtr<Response> Response::appropriate_network_error(JS::VM& vm, FetchParams const& fetch_params)
+GC::Ref<Response> Response::appropriate_network_error(JS::VM& vm, FetchParams const& fetch_params)
 {
     // 1. Assert: fetchParams is canceled.
     VERIFY(fetch_params.is_canceled());
@@ -147,7 +147,7 @@ ErrorOr<Optional<URL::URL>> Response::location_url(Optional<String> const& reque
 }
 
 // https://fetch.spec.whatwg.org/#concept-response-clone
-JS::NonnullGCPtr<Response> Response::clone(JS::Realm& realm) const
+GC::Ref<Response> Response::clone(JS::Realm& realm) const
 {
     // To clone a response response, run these steps:
     auto& vm = realm.vm();
@@ -192,7 +192,7 @@ JS::NonnullGCPtr<Response> Response::clone(JS::Realm& realm) const
 }
 
 // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#unsafe-response
-JS::NonnullGCPtr<Response> Response::unsafe_response()
+GC::Ref<Response> Response::unsafe_response()
 {
     // A response's unsafe response is its internal response if it has one, and the response itself otherwise.
     if (is<FilteredResponse>(this))
@@ -334,7 +334,7 @@ Optional<StringView> Response::network_error_message() const
     return m_network_error_message->visit([](auto const& s) -> StringView { return s; });
 }
 
-FilteredResponse::FilteredResponse(JS::NonnullGCPtr<Response> internal_response, JS::NonnullGCPtr<HeaderList> header_list)
+FilteredResponse::FilteredResponse(GC::Ref<Response> internal_response, GC::Ref<HeaderList> header_list)
     : Response(header_list)
     , m_internal_response(internal_response)
 {
@@ -350,7 +350,7 @@ void FilteredResponse::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_internal_response);
 }
 
-JS::NonnullGCPtr<BasicFilteredResponse> BasicFilteredResponse::create(JS::VM& vm, JS::NonnullGCPtr<Response> internal_response)
+GC::Ref<BasicFilteredResponse> BasicFilteredResponse::create(JS::VM& vm, GC::Ref<Response> internal_response)
 {
     // A basic filtered response is a filtered response whose type is "basic" and header list excludes
     // any headers in internal response’s header list whose name is a forbidden response-header name.
@@ -363,7 +363,7 @@ JS::NonnullGCPtr<BasicFilteredResponse> BasicFilteredResponse::create(JS::VM& vm
     return vm.heap().allocate<BasicFilteredResponse>(internal_response, header_list);
 }
 
-BasicFilteredResponse::BasicFilteredResponse(JS::NonnullGCPtr<Response> internal_response, JS::NonnullGCPtr<HeaderList> header_list)
+BasicFilteredResponse::BasicFilteredResponse(GC::Ref<Response> internal_response, GC::Ref<HeaderList> header_list)
     : FilteredResponse(internal_response, header_list)
     , m_header_list(header_list)
 {
@@ -375,7 +375,7 @@ void BasicFilteredResponse::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_header_list);
 }
 
-JS::NonnullGCPtr<CORSFilteredResponse> CORSFilteredResponse::create(JS::VM& vm, JS::NonnullGCPtr<Response> internal_response)
+GC::Ref<CORSFilteredResponse> CORSFilteredResponse::create(JS::VM& vm, GC::Ref<Response> internal_response)
 {
     // A CORS filtered response is a filtered response whose type is "cors" and header list excludes
     // any headers in internal response’s header list whose name is not a CORS-safelisted response-header
@@ -393,7 +393,7 @@ JS::NonnullGCPtr<CORSFilteredResponse> CORSFilteredResponse::create(JS::VM& vm,
     return vm.heap().allocate<CORSFilteredResponse>(internal_response, header_list);
 }
 
-CORSFilteredResponse::CORSFilteredResponse(JS::NonnullGCPtr<Response> internal_response, JS::NonnullGCPtr<HeaderList> header_list)
+CORSFilteredResponse::CORSFilteredResponse(GC::Ref<Response> internal_response, GC::Ref<HeaderList> header_list)
     : FilteredResponse(internal_response, header_list)
     , m_header_list(header_list)
 {
@@ -405,14 +405,14 @@ void CORSFilteredResponse::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_header_list);
 }
 
-JS::NonnullGCPtr<OpaqueFilteredResponse> OpaqueFilteredResponse::create(JS::VM& vm, JS::NonnullGCPtr<Response> internal_response)
+GC::Ref<OpaqueFilteredResponse> OpaqueFilteredResponse::create(JS::VM& vm, GC::Ref<Response> internal_response)
 {
     // An opaque filtered response is a filtered response whose type is "opaque", URL list is the empty list,
     // status is 0, status message is the empty byte sequence, header list is empty, and body is null.
     return vm.heap().allocate<OpaqueFilteredResponse>(internal_response, HeaderList::create(vm));
 }
 
-OpaqueFilteredResponse::OpaqueFilteredResponse(JS::NonnullGCPtr<Response> internal_response, JS::NonnullGCPtr<HeaderList> header_list)
+OpaqueFilteredResponse::OpaqueFilteredResponse(GC::Ref<Response> internal_response, GC::Ref<HeaderList> header_list)
     : FilteredResponse(internal_response, header_list)
     , m_header_list(header_list)
 {
@@ -425,14 +425,14 @@ void OpaqueFilteredResponse::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_body);
 }
 
-JS::NonnullGCPtr<OpaqueRedirectFilteredResponse> OpaqueRedirectFilteredResponse::create(JS::VM& vm, JS::NonnullGCPtr<Response> internal_response)
+GC::Ref<OpaqueRedirectFilteredResponse> OpaqueRedirectFilteredResponse::create(JS::VM& vm, GC::Ref<Response> internal_response)
 {
     // An opaque-redirect filtered response is a filtered response whose type is "opaqueredirect",
     // status is 0, status message is the empty byte sequence, header list is empty, and body is null.
     return vm.heap().allocate<OpaqueRedirectFilteredResponse>(internal_response, HeaderList::create(vm));
 }
 
-OpaqueRedirectFilteredResponse::OpaqueRedirectFilteredResponse(JS::NonnullGCPtr<Response> internal_response, JS::NonnullGCPtr<HeaderList> header_list)
+OpaqueRedirectFilteredResponse::OpaqueRedirectFilteredResponse(GC::Ref<Response> internal_response, GC::Ref<HeaderList> header_list)
     : FilteredResponse(internal_response, header_list)
     , m_header_list(header_list)
 {
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h
index db3c76869dc..bda902af941 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/HTTP/Responses.h
@@ -12,9 +12,9 @@
 #include <AK/Optional.h>
 #include <AK/Time.h>
 #include <AK/Vector.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Bodies.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Headers.h>
@@ -24,8 +24,8 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#concept-response
 class Response : public JS::Cell {
-    JS_CELL(Response, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Response);
+    GC_CELL(Response, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Response);
 
 public:
     enum class CacheState {
@@ -56,10 +56,10 @@ public:
         bool operator==(BodyInfo const&) const = default;
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<Response> create(JS::VM&);
-    [[nodiscard]] static JS::NonnullGCPtr<Response> aborted_network_error(JS::VM&);
-    [[nodiscard]] static JS::NonnullGCPtr<Response> network_error(JS::VM&, Variant<String, StringView> message);
-    [[nodiscard]] static JS::NonnullGCPtr<Response> appropriate_network_error(JS::VM&, FetchParams const&);
+    [[nodiscard]] static GC::Ref<Response> create(JS::VM&);
+    [[nodiscard]] static GC::Ref<Response> aborted_network_error(JS::VM&);
+    [[nodiscard]] static GC::Ref<Response> network_error(JS::VM&, Variant<String, StringView> message);
+    [[nodiscard]] static GC::Ref<Response> appropriate_network_error(JS::VM&, FetchParams const&);
 
     virtual ~Response() = default;
 
@@ -79,12 +79,12 @@ public:
     [[nodiscard]] virtual ReadonlyBytes status_message() const { return m_status_message; }
     void set_status_message(ByteBuffer status_message) { m_status_message = move(status_message); }
 
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const { return m_header_list; }
-    void set_header_list(JS::NonnullGCPtr<HeaderList> header_list) { m_header_list = header_list; }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const { return m_header_list; }
+    void set_header_list(GC::Ref<HeaderList> header_list) { m_header_list = header_list; }
 
-    [[nodiscard]] virtual JS::GCPtr<Body> const& body() const { return m_body; }
-    [[nodiscard]] virtual JS::GCPtr<Body>& body() { return m_body; }
-    void set_body(JS::GCPtr<Body> body) { m_body = move(body); }
+    [[nodiscard]] virtual GC::Ptr<Body> const& body() const { return m_body; }
+    [[nodiscard]] virtual GC::Ptr<Body>& body() { return m_body; }
+    void set_body(GC::Ptr<Body> body) { m_body = move(body); }
 
     [[nodiscard]] virtual Optional<CacheState> const& cache_state() const { return m_cache_state; }
     void set_cache_state(Optional<CacheState> cache_state) { m_cache_state = move(cache_state); }
@@ -113,9 +113,9 @@ public:
     [[nodiscard]] Optional<URL::URL const&> url() const;
     [[nodiscard]] ErrorOr<Optional<URL::URL>> location_url(Optional<String> const& request_fragment) const;
 
-    [[nodiscard]] JS::NonnullGCPtr<Response> clone(JS::Realm&) const;
+    [[nodiscard]] GC::Ref<Response> clone(JS::Realm&) const;
 
-    [[nodiscard]] JS::NonnullGCPtr<Response> unsafe_response();
+    [[nodiscard]] GC::Ref<Response> unsafe_response();
 
     [[nodiscard]] bool is_cors_cross_origin() const;
 
@@ -127,7 +127,7 @@ public:
     [[nodiscard]] Optional<StringView> network_error_message() const;
 
 protected:
-    explicit Response(JS::NonnullGCPtr<HeaderList>);
+    explicit Response(GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
@@ -154,11 +154,11 @@ private:
 
     // https://fetch.spec.whatwg.org/#concept-response-header-list
     // A response has an associated header list (a header list). Unless stated otherwise it is empty.
-    JS::NonnullGCPtr<HeaderList> m_header_list;
+    GC::Ref<HeaderList> m_header_list;
 
     // https://fetch.spec.whatwg.org/#concept-response-body
     // A response has an associated body (null or a body). Unless stated otherwise it is null.
-    JS::GCPtr<Body> m_body;
+    GC::Ptr<Body> m_body;
 
     // https://fetch.spec.whatwg.org/#concept-response-cache-state
     // A response has an associated cache state (the empty string, "local", or "validated"). Unless stated otherwise, it is the empty string.
@@ -209,10 +209,10 @@ public:
 
 // https://fetch.spec.whatwg.org/#concept-filtered-response
 class FilteredResponse : public Response {
-    JS_CELL(FilteredResponse, Response);
+    GC_CELL(FilteredResponse, Response);
 
 public:
-    FilteredResponse(JS::NonnullGCPtr<Response>, JS::NonnullGCPtr<HeaderList>);
+    FilteredResponse(GC::Ref<Response>, GC::Ref<HeaderList>);
     virtual ~FilteredResponse() = 0;
 
     [[nodiscard]] virtual Type type() const override { return m_internal_response->type(); }
@@ -221,9 +221,9 @@ public:
     [[nodiscard]] virtual Vector<URL::URL>& url_list() override { return m_internal_response->url_list(); }
     [[nodiscard]] virtual Status status() const override { return m_internal_response->status(); }
     [[nodiscard]] virtual ReadonlyBytes status_message() const override { return m_internal_response->status_message(); }
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const override { return m_internal_response->header_list(); }
-    [[nodiscard]] virtual JS::GCPtr<Body> const& body() const override { return m_internal_response->body(); }
-    [[nodiscard]] virtual JS::GCPtr<Body>& body() override { return m_internal_response->body(); }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const override { return m_internal_response->header_list(); }
+    [[nodiscard]] virtual GC::Ptr<Body> const& body() const override { return m_internal_response->body(); }
+    [[nodiscard]] virtual GC::Ptr<Body>& body() override { return m_internal_response->body(); }
     [[nodiscard]] virtual Optional<CacheState> const& cache_state() const override { return m_internal_response->cache_state(); }
     [[nodiscard]] virtual Vector<ByteBuffer> const& cors_exposed_header_name_list() const override { return m_internal_response->cors_exposed_header_name_list(); }
     [[nodiscard]] virtual bool range_requested() const override { return m_internal_response->range_requested(); }
@@ -231,102 +231,102 @@ public:
     [[nodiscard]] virtual bool timing_allow_passed() const override { return m_internal_response->timing_allow_passed(); }
     [[nodiscard]] virtual BodyInfo const& body_info() const override { return m_internal_response->body_info(); }
 
-    [[nodiscard]] JS::NonnullGCPtr<Response> internal_response() const { return m_internal_response; }
+    [[nodiscard]] GC::Ref<Response> internal_response() const { return m_internal_response; }
 
 protected:
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
 private:
     // https://fetch.spec.whatwg.org/#concept-internal-response
-    JS::NonnullGCPtr<Response> m_internal_response;
+    GC::Ref<Response> m_internal_response;
 };
 
 // https://fetch.spec.whatwg.org/#concept-filtered-response-basic
 class BasicFilteredResponse final : public FilteredResponse {
-    JS_CELL(BasicFilteredResponse, FilteredResponse);
-    JS_DECLARE_ALLOCATOR(BasicFilteredResponse);
+    GC_CELL(BasicFilteredResponse, FilteredResponse);
+    GC_DECLARE_ALLOCATOR(BasicFilteredResponse);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<BasicFilteredResponse> create(JS::VM&, JS::NonnullGCPtr<Response>);
+    [[nodiscard]] static GC::Ref<BasicFilteredResponse> create(JS::VM&, GC::Ref<Response>);
 
     [[nodiscard]] virtual Type type() const override { return Type::Basic; }
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const override { return m_header_list; }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const override { return m_header_list; }
 
 private:
-    BasicFilteredResponse(JS::NonnullGCPtr<Response>, JS::NonnullGCPtr<HeaderList>);
+    BasicFilteredResponse(GC::Ref<Response>, GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<HeaderList> m_header_list;
+    GC::Ref<HeaderList> m_header_list;
 };
 
 // https://fetch.spec.whatwg.org/#concept-filtered-response-cors
 class CORSFilteredResponse final : public FilteredResponse {
-    JS_CELL(CORSFilteredResponse, FilteredResponse);
-    JS_DECLARE_ALLOCATOR(CORSFilteredResponse);
+    GC_CELL(CORSFilteredResponse, FilteredResponse);
+    GC_DECLARE_ALLOCATOR(CORSFilteredResponse);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CORSFilteredResponse> create(JS::VM&, JS::NonnullGCPtr<Response>);
+    [[nodiscard]] static GC::Ref<CORSFilteredResponse> create(JS::VM&, GC::Ref<Response>);
 
     [[nodiscard]] virtual Type type() const override { return Type::CORS; }
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const override { return m_header_list; }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const override { return m_header_list; }
 
 private:
-    CORSFilteredResponse(JS::NonnullGCPtr<Response>, JS::NonnullGCPtr<HeaderList>);
+    CORSFilteredResponse(GC::Ref<Response>, GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<HeaderList> m_header_list;
+    GC::Ref<HeaderList> m_header_list;
 };
 
 // https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
 class OpaqueFilteredResponse final : public FilteredResponse {
-    JS_CELL(OpaqueFilteredResponse, FilteredResponse);
-    JS_DECLARE_ALLOCATOR(OpaqueFilteredResponse);
+    GC_CELL(OpaqueFilteredResponse, FilteredResponse);
+    GC_DECLARE_ALLOCATOR(OpaqueFilteredResponse);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<OpaqueFilteredResponse> create(JS::VM&, JS::NonnullGCPtr<Response>);
+    [[nodiscard]] static GC::Ref<OpaqueFilteredResponse> create(JS::VM&, GC::Ref<Response>);
 
     [[nodiscard]] virtual Type type() const override { return Type::Opaque; }
     [[nodiscard]] virtual Vector<URL::URL> const& url_list() const override { return m_url_list; }
     [[nodiscard]] virtual Vector<URL::URL>& url_list() override { return m_url_list; }
     [[nodiscard]] virtual Status status() const override { return 0; }
     [[nodiscard]] virtual ReadonlyBytes status_message() const override { return {}; }
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const override { return m_header_list; }
-    [[nodiscard]] virtual JS::GCPtr<Body> const& body() const override { return m_body; }
-    [[nodiscard]] virtual JS::GCPtr<Body>& body() override { return m_body; }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const override { return m_header_list; }
+    [[nodiscard]] virtual GC::Ptr<Body> const& body() const override { return m_body; }
+    [[nodiscard]] virtual GC::Ptr<Body>& body() override { return m_body; }
 
 private:
-    OpaqueFilteredResponse(JS::NonnullGCPtr<Response>, JS::NonnullGCPtr<HeaderList>);
+    OpaqueFilteredResponse(GC::Ref<Response>, GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     Vector<URL::URL> m_url_list;
-    JS::NonnullGCPtr<HeaderList> m_header_list;
-    JS::GCPtr<Body> m_body;
+    GC::Ref<HeaderList> m_header_list;
+    GC::Ptr<Body> m_body;
 };
 
 // https://fetch.spec.whatwg.org/#concept-filtered-response-opaque-redirect
 class OpaqueRedirectFilteredResponse final : public FilteredResponse {
-    JS_CELL(OpaqueRedirectFilteredResponse, FilteredResponse);
-    JS_DECLARE_ALLOCATOR(OpaqueRedirectFilteredResponse);
+    GC_CELL(OpaqueRedirectFilteredResponse, FilteredResponse);
+    GC_DECLARE_ALLOCATOR(OpaqueRedirectFilteredResponse);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<OpaqueRedirectFilteredResponse> create(JS::VM&, JS::NonnullGCPtr<Response>);
+    [[nodiscard]] static GC::Ref<OpaqueRedirectFilteredResponse> create(JS::VM&, GC::Ref<Response>);
 
     [[nodiscard]] virtual Type type() const override { return Type::OpaqueRedirect; }
     [[nodiscard]] virtual Status status() const override { return 0; }
     [[nodiscard]] virtual ReadonlyBytes status_message() const override { return {}; }
-    [[nodiscard]] virtual JS::NonnullGCPtr<HeaderList> header_list() const override { return m_header_list; }
-    [[nodiscard]] virtual JS::GCPtr<Body> const& body() const override { return m_body; }
-    [[nodiscard]] virtual JS::GCPtr<Body>& body() override { return m_body; }
+    [[nodiscard]] virtual GC::Ref<HeaderList> header_list() const override { return m_header_list; }
+    [[nodiscard]] virtual GC::Ptr<Body> const& body() const override { return m_body; }
+    [[nodiscard]] virtual GC::Ptr<Body>& body() override { return m_body; }
 
 private:
-    OpaqueRedirectFilteredResponse(JS::NonnullGCPtr<Response>, JS::NonnullGCPtr<HeaderList>);
+    OpaqueRedirectFilteredResponse(GC::Ref<Response>, GC::Ref<HeaderList>);
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<HeaderList> m_header_list;
-    JS::GCPtr<Body> m_body;
+    GC::Ref<HeaderList> m_header_list;
+    GC::Ptr<Body> m_body;
 };
 }
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.cpp b/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.cpp
index 0ec13989c9c..5c937a9603f 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.cpp
@@ -10,17 +10,17 @@
 
 namespace Web::Fetch::Infrastructure {
 
-JS_DEFINE_ALLOCATOR(IncrementalReadLoopReadRequest);
+GC_DEFINE_ALLOCATOR(IncrementalReadLoopReadRequest);
 
 void IncrementalReadLoopReadRequest::on_chunk(JS::Value chunk)
 {
     auto& realm = m_reader->realm();
     // 1. Let continueAlgorithm be null.
-    JS::GCPtr<JS::HeapFunction<void()>> continue_algorithm;
+    GC::Ptr<GC::Function<void()>> continue_algorithm;
 
     // 2. If chunk is not a Uint8Array object, then set continueAlgorithm to this step: run processBodyError given a TypeError.
     if (!chunk.is_object() || !is<JS::Uint8Array>(chunk.as_object())) {
-        continue_algorithm = JS::create_heap_function(realm.heap(), [&realm, process_body_error = m_process_body_error] {
+        continue_algorithm = GC::create_function(realm.heap(), [&realm, process_body_error = m_process_body_error] {
             process_body_error->function()(JS::TypeError::create(realm, "Chunk data is not Uint8Array"sv));
         });
     }
@@ -31,7 +31,7 @@ void IncrementalReadLoopReadRequest::on_chunk(JS::Value chunk)
         auto& uint8_array = static_cast<JS::Uint8Array&>(chunk.as_object());
         auto bytes = MUST(ByteBuffer::copy(uint8_array.data()));
         // 2. Set continueAlgorithm to these steps:
-        continue_algorithm = JS::create_heap_function(realm.heap(), [bytes = move(bytes), body = m_body, reader = m_reader, task_destination = m_task_destination, process_body_chunk = m_process_body_chunk, process_end_of_body = m_process_end_of_body, process_body_error = m_process_body_error] {
+        continue_algorithm = GC::create_function(realm.heap(), [bytes = move(bytes), body = m_body, reader = m_reader, task_destination = m_task_destination, process_body_chunk = m_process_body_chunk, process_end_of_body = m_process_end_of_body, process_body_error = m_process_body_error] {
             HTML::TemporaryExecutionContext execution_context { reader->realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
             // 1. Run processBodyChunk given bytes.
             process_body_chunk->function()(move(bytes));
@@ -48,7 +48,7 @@ void IncrementalReadLoopReadRequest::on_chunk(JS::Value chunk)
 void IncrementalReadLoopReadRequest::on_close()
 {
     // 1. Queue a fetch task given processEndOfBody and taskDestination.
-    Fetch::Infrastructure::queue_fetch_task(m_task_destination, JS::create_heap_function(m_reader->heap(), [this] {
+    Fetch::Infrastructure::queue_fetch_task(m_task_destination, GC::create_function(m_reader->heap(), [this] {
         m_process_end_of_body->function()();
     }));
 }
@@ -56,12 +56,12 @@ void IncrementalReadLoopReadRequest::on_close()
 void IncrementalReadLoopReadRequest::on_error(JS::Value error)
 {
     // 1. Queue a fetch task to run processBodyError given e, with taskDestination.
-    Fetch::Infrastructure::queue_fetch_task(m_task_destination, JS::create_heap_function(m_reader->heap(), [this, error = move(error)] {
+    Fetch::Infrastructure::queue_fetch_task(m_task_destination, GC::create_function(m_reader->heap(), [this, error = move(error)] {
         m_process_body_error->function()(error);
     }));
 }
 
-IncrementalReadLoopReadRequest::IncrementalReadLoopReadRequest(JS::NonnullGCPtr<Body> body, JS::NonnullGCPtr<Streams::ReadableStreamDefaultReader> reader, JS::NonnullGCPtr<JS::Object> task_destination, Body::ProcessBodyChunkCallback process_body_chunk, Body::ProcessEndOfBodyCallback process_end_of_body, Body::ProcessBodyErrorCallback process_body_error)
+IncrementalReadLoopReadRequest::IncrementalReadLoopReadRequest(GC::Ref<Body> body, GC::Ref<Streams::ReadableStreamDefaultReader> reader, GC::Ref<JS::Object> task_destination, Body::ProcessBodyChunkCallback process_body_chunk, Body::ProcessEndOfBodyCallback process_end_of_body, Body::ProcessBodyErrorCallback process_body_error)
     : m_body(body)
     , m_reader(reader)
     , m_task_destination(task_destination)
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.h b/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.h
index 2eb8b6c4495..81332df4226 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/IncrementalReadLoopReadRequest.h
@@ -13,11 +13,11 @@ namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#incrementally-read-loop
 class IncrementalReadLoopReadRequest : public Streams::ReadRequest {
-    JS_CELL(IncrementalReadLoopReadRequest, Streams::ReadRequest);
-    JS_DECLARE_ALLOCATOR(IncrementalReadLoopReadRequest);
+    GC_CELL(IncrementalReadLoopReadRequest, Streams::ReadRequest);
+    GC_DECLARE_ALLOCATOR(IncrementalReadLoopReadRequest);
 
 public:
-    IncrementalReadLoopReadRequest(JS::NonnullGCPtr<Body>, JS::NonnullGCPtr<Streams::ReadableStreamDefaultReader>, JS::NonnullGCPtr<JS::Object> task_destination, Body::ProcessBodyChunkCallback, Body::ProcessEndOfBodyCallback, Body::ProcessBodyErrorCallback);
+    IncrementalReadLoopReadRequest(GC::Ref<Body>, GC::Ref<Streams::ReadableStreamDefaultReader>, GC::Ref<JS::Object> task_destination, Body::ProcessBodyChunkCallback, Body::ProcessEndOfBodyCallback, Body::ProcessBodyErrorCallback);
 
     virtual void on_chunk(JS::Value chunk) override;
     virtual void on_close() override;
@@ -26,9 +26,9 @@ public:
 private:
     virtual void visit_edges(Visitor&) override;
 
-    JS::NonnullGCPtr<Body> m_body;
-    JS::NonnullGCPtr<Streams::ReadableStreamDefaultReader> m_reader;
-    JS::NonnullGCPtr<JS::Object> m_task_destination;
+    GC::Ref<Body> m_body;
+    GC::Ref<Streams::ReadableStreamDefaultReader> m_reader;
+    GC::Ref<JS::Object> m_task_destination;
     Body::ProcessBodyChunkCallback m_process_body_chunk;
     Body::ProcessEndOfBodyCallback m_process_end_of_body;
     Body::ProcessBodyErrorCallback m_process_body_error;
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/Task.cpp b/Libraries/LibWeb/Fetch/Infrastructure/Task.cpp
index bd223000c2b..c28a6c1d6d2 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/Task.cpp
+++ b/Libraries/LibWeb/Fetch/Infrastructure/Task.cpp
@@ -11,7 +11,7 @@
 namespace Web::Fetch::Infrastructure {
 
 // https://fetch.spec.whatwg.org/#queue-a-fetch-task
-HTML::TaskID queue_fetch_task(JS::Object& task_destination, JS::NonnullGCPtr<JS::HeapFunction<void()>> algorithm)
+HTML::TaskID queue_fetch_task(JS::Object& task_destination, GC::Ref<GC::Function<void()>> algorithm)
 {
     // FIXME: 1. If taskDestination is a parallel queue, then enqueue algorithm to taskDestination.
 
@@ -21,12 +21,12 @@ HTML::TaskID queue_fetch_task(JS::Object& task_destination, JS::NonnullGCPtr<JS:
 
 // AD-HOC: This overload allows tracking the queued task within the fetch controller so that we may cancel queued tasks
 //         when the spec indicates that we must stop an ongoing fetch.
-HTML::TaskID queue_fetch_task(JS::NonnullGCPtr<FetchController> fetch_controller, JS::Object& task_destination, JS::NonnullGCPtr<JS::HeapFunction<void()>> algorithm)
+HTML::TaskID queue_fetch_task(GC::Ref<FetchController> fetch_controller, JS::Object& task_destination, GC::Ref<GC::Function<void()>> algorithm)
 {
     auto fetch_task_id = fetch_controller->next_fetch_task_id();
 
     auto& heap = task_destination.heap();
-    auto html_task_id = queue_fetch_task(task_destination, JS::create_heap_function(heap, [fetch_controller, fetch_task_id, algorithm]() {
+    auto html_task_id = queue_fetch_task(task_destination, GC::create_function(heap, [fetch_controller, fetch_task_id, algorithm]() {
         fetch_controller->fetch_task_complete(fetch_task_id);
         algorithm->function()();
     }));
diff --git a/Libraries/LibWeb/Fetch/Infrastructure/Task.h b/Libraries/LibWeb/Fetch/Infrastructure/Task.h
index faa7214d7ca..031637273df 100644
--- a/Libraries/LibWeb/Fetch/Infrastructure/Task.h
+++ b/Libraries/LibWeb/Fetch/Infrastructure/Task.h
@@ -7,17 +7,17 @@
 #pragma once
 
 #include <AK/Variant.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/EventLoop/Task.h>
 
 namespace Web::Fetch::Infrastructure {
 
 // FIXME: 'or a parallel queue'
-using TaskDestination = Variant<Empty, JS::NonnullGCPtr<JS::Object>>;
+using TaskDestination = Variant<Empty, GC::Ref<JS::Object>>;
 
-HTML::TaskID queue_fetch_task(JS::Object&, JS::NonnullGCPtr<JS::HeapFunction<void()>>);
-HTML::TaskID queue_fetch_task(JS::NonnullGCPtr<FetchController>, JS::Object&, JS::NonnullGCPtr<JS::HeapFunction<void()>>);
+HTML::TaskID queue_fetch_task(JS::Object&, GC::Ref<GC::Function<void()>>);
+HTML::TaskID queue_fetch_task(GC::Ref<FetchController>, JS::Object&, GC::Ref<GC::Function<void()>>);
 
 }
diff --git a/Libraries/LibWeb/Fetch/Request.cpp b/Libraries/LibWeb/Fetch/Request.cpp
index 67bd25e0eb3..dedd80d7d98 100644
--- a/Libraries/LibWeb/Fetch/Request.cpp
+++ b/Libraries/LibWeb/Fetch/Request.cpp
@@ -21,9 +21,9 @@
 
 namespace Web::Fetch {
 
-JS_DEFINE_ALLOCATOR(Request);
+GC_DEFINE_ALLOCATOR(Request);
 
-Request::Request(JS::Realm& realm, JS::NonnullGCPtr<Infrastructure::Request> request)
+Request::Request(JS::Realm& realm, GC::Ref<Infrastructure::Request> request)
     : PlatformObject(realm)
     , m_request(request)
 {
@@ -56,32 +56,32 @@ Optional<MimeSniff::MimeType> Request::mime_type_impl() const
 
 // https://fetch.spec.whatwg.org/#concept-body-body
 // https://fetch.spec.whatwg.org/#ref-for-concept-body-body%E2%91%A7
-JS::GCPtr<Infrastructure::Body const> Request::body_impl() const
+GC::Ptr<Infrastructure::Body const> Request::body_impl() const
 {
     // Objects including the Body interface mixin have an associated body (null or a body).
     // A Request object’s body is its request’s body.
     return m_request->body().visit(
-        [](JS::NonnullGCPtr<Infrastructure::Body> const& b) -> JS::GCPtr<Infrastructure::Body const> { return b; },
-        [](Empty) -> JS::GCPtr<Infrastructure::Body const> { return nullptr; },
+        [](GC::Ref<Infrastructure::Body> const& b) -> GC::Ptr<Infrastructure::Body const> { return b; },
+        [](Empty) -> GC::Ptr<Infrastructure::Body const> { return nullptr; },
         // A byte sequence will be safely extracted into a body early on in fetch.
-        [](ByteBuffer const&) -> JS::GCPtr<Infrastructure::Body const> { VERIFY_NOT_REACHED(); });
+        [](ByteBuffer const&) -> GC::Ptr<Infrastructure::Body const> { VERIFY_NOT_REACHED(); });
 }
 
 // https://fetch.spec.whatwg.org/#concept-body-body
 // https://fetch.spec.whatwg.org/#ref-for-concept-body-body%E2%91%A7
-JS::GCPtr<Infrastructure::Body> Request::body_impl()
+GC::Ptr<Infrastructure::Body> Request::body_impl()
 {
     // Objects including the Body interface mixin have an associated body (null or a body).
     // A Request object’s body is its request’s body.
     return m_request->body().visit(
-        [](JS::NonnullGCPtr<Infrastructure::Body>& b) -> JS::GCPtr<Infrastructure::Body> { return b; },
-        [](Empty) -> JS::GCPtr<Infrastructure::Body> { return {}; },
+        [](GC::Ref<Infrastructure::Body>& b) -> GC::Ptr<Infrastructure::Body> { return b; },
+        [](Empty) -> GC::Ptr<Infrastructure::Body> { return {}; },
         // A byte sequence will be safely extracted into a body early on in fetch.
-        [](ByteBuffer&) -> JS::GCPtr<Infrastructure::Body> { VERIFY_NOT_REACHED(); });
+        [](ByteBuffer&) -> GC::Ptr<Infrastructure::Body> { VERIFY_NOT_REACHED(); });
 }
 
 // https://fetch.spec.whatwg.org/#request-create
-JS::NonnullGCPtr<Request> Request::create(JS::Realm& realm, JS::NonnullGCPtr<Infrastructure::Request> request, Headers::Guard guard, JS::NonnullGCPtr<DOM::AbortSignal> signal)
+GC::Ref<Request> Request::create(JS::Realm& realm, GC::Ref<Infrastructure::Request> request, Headers::Guard guard, GC::Ref<DOM::AbortSignal> signal)
 {
     // 1. Let requestObject be a new Request object with realm.
     // 2. Set requestObject’s request to request.
@@ -99,7 +99,7 @@ JS::NonnullGCPtr<Request> Request::create(JS::Realm& realm, JS::NonnullGCPtr<Inf
 }
 
 // https://fetch.spec.whatwg.org/#dom-request
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm& realm, RequestInfo const& input, RequestInit const& init)
+WebIDL::ExceptionOr<GC::Ref<Request>> Request::construct_impl(JS::Realm& realm, RequestInfo const& input, RequestInit const& init)
 {
     auto& vm = realm.vm();
 
@@ -107,7 +107,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     auto request_object = realm.create<Request>(realm, Infrastructure::Request::create(vm));
 
     // 1. Let request be null.
-    JS::GCPtr<Infrastructure::Request> input_request;
+    GC::Ptr<Infrastructure::Request> input_request;
 
     // 2. Let fallbackMode be null.
     Optional<Infrastructure::Request::Mode> fallback_mode;
@@ -141,13 +141,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     // 6. Otherwise:
     else {
         // 1. Assert: input is a Request object.
-        VERIFY(input.has<JS::Handle<Request>>());
+        VERIFY(input.has<GC::Root<Request>>());
 
         // 2. Set request to input’s request.
-        input_request = input.get<JS::Handle<Request>>()->request();
+        input_request = input.get<GC::Root<Request>>()->request();
 
         // 3. Set signal to input’s signal.
-        input_signal = input.get<JS::Handle<Request>>()->signal();
+        input_signal = input.get<GC::Root<Request>>()->signal();
     }
 
     // 7. Let origin be this’s relevant settings object’s origin.
@@ -157,8 +157,8 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     auto window = Infrastructure::Request::WindowType { Infrastructure::Request::Window::Client };
 
     // 9. If request’s window is an environment settings object and its origin is same origin with origin, then set window to request’s window.
-    if (input_request->window().has<JS::GCPtr<HTML::EnvironmentSettingsObject>>()) {
-        auto eso = input_request->window().get<JS::GCPtr<HTML::EnvironmentSettingsObject>>();
+    if (input_request->window().has<GC::Ptr<HTML::EnvironmentSettingsObject>>()) {
+        auto eso = input_request->window().get<GC::Ptr<HTML::EnvironmentSettingsObject>>();
         if (eso->origin().is_same_origin(origin))
             window = input_request->window();
     }
@@ -394,7 +394,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
 
     // 29. Let signals be « signal » if signal is non-null; otherwise « ».
     auto& this_relevant_realm = HTML::relevant_realm(*request_object);
-    Vector<JS::Handle<DOM::AbortSignal>> signals;
+    Vector<GC::Root<DOM::AbortSignal>> signals;
     if (input_signal != nullptr)
         signals.append(*input_signal);
 
@@ -418,7 +418,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     // 33. If init is not empty, then:
     if (!init.is_empty()) {
         // 1. Let headers be a copy of this’s headers and its associated header list.
-        auto headers = Variant<HeadersInit, JS::NonnullGCPtr<Infrastructure::HeaderList>> { request_object->headers()->header_list() };
+        auto headers = Variant<HeadersInit, GC::Ref<Infrastructure::HeaderList>> { request_object->headers()->header_list() };
 
         // 2. If init["headers"] exists, then set headers to init["headers"].
         if (init.headers.has_value())
@@ -428,7 +428,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
         request_object->headers()->header_list()->clear();
 
         // 4. If headers is a Headers object, then for each header of its header list, append header to this’s headers.
-        if (auto* header_list = headers.get_pointer<JS::NonnullGCPtr<Infrastructure::HeaderList>>()) {
+        if (auto* header_list = headers.get_pointer<GC::Ref<Infrastructure::HeaderList>>()) {
             for (auto& header : *header_list->ptr())
                 TRY(request_object->headers()->append(Infrastructure::Header::from_string_pair(header.name, header.value)));
         }
@@ -440,15 +440,15 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
 
     // 34. Let inputBody be input’s request’s body if input is a Request object; otherwise null.
     Optional<Infrastructure::Request::BodyType const&> input_body;
-    if (input.has<JS::Handle<Request>>())
-        input_body = input.get<JS::Handle<Request>>()->request()->body();
+    if (input.has<GC::Root<Request>>())
+        input_body = input.get<GC::Root<Request>>()->request()->body();
 
     // 35. If either init["body"] exists and is non-null or inputBody is non-null, and request’s method is `GET` or `HEAD`, then throw a TypeError.
     if (((init.body.has_value() && (*init.body).has_value()) || (input_body.has_value() && !input_body.value().has<Empty>())) && StringView { request->method() }.is_one_of("GET"sv, "HEAD"sv))
         return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Method must not be GET or HEAD when body is provided"sv };
 
     // 36. Let initBody be null.
-    JS::GCPtr<Infrastructure::Body> init_body;
+    GC::Ptr<Infrastructure::Body> init_body;
 
     // 37. If init["body"] exists and is non-null, then:
     if (init.body.has_value() && (*init.body).has_value()) {
@@ -473,7 +473,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
 
     // 39. If inputOrInitBody is non-null and inputOrInitBody’s source is null, then:
     // FIXME: The spec doesn't check if inputOrInitBody is a body before accessing source.
-    if (input_or_init_body.has_value() && input_or_init_body->has<JS::NonnullGCPtr<Infrastructure::Body>>() && input_or_init_body->get<JS::NonnullGCPtr<Infrastructure::Body>>()->source().has<Empty>()) {
+    if (input_or_init_body.has_value() && input_or_init_body->has<GC::Ref<Infrastructure::Body>>() && input_or_init_body->get<GC::Ref<Infrastructure::Body>>()->source().has<Empty>()) {
         // 1. If initBody is non-null and init["duplex"] does not exist, then throw a TypeError.
         if (init_body && !init.duplex.has_value())
             return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Body without source requires 'duplex' value to be set"sv };
@@ -492,7 +492,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     // 41. If initBody is null and inputBody is non-null, then:
     if (!init_body && input_body.has_value()) {
         // 2. If input is unusable, then throw a TypeError.
-        if (input.has<JS::Handle<Request>>() && input.get<JS::Handle<Request>>()->is_unusable())
+        if (input.has<GC::Root<Request>>() && input.get<GC::Root<Request>>()->is_unusable())
             return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Request is unusable"sv };
 
         // FIXME: 2. Set finalBody to the result of creating a proxy for inputBody.
@@ -502,7 +502,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::construct_impl(JS::Realm
     if (final_body.has_value())
         request_object->request()->set_body(*final_body);
 
-    return JS::NonnullGCPtr { *request_object };
+    return GC::Ref { *request_object };
 }
 
 // https://fetch.spec.whatwg.org/#dom-request-method
@@ -520,7 +520,7 @@ String Request::url() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-request-headers
-JS::NonnullGCPtr<Headers> Request::headers() const
+GC::Ref<Headers> Request::headers() const
 {
     // The headers getter steps are to return this’s headers.
     return *m_headers;
@@ -619,7 +619,7 @@ bool Request::is_history_navigation() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-request-signal
-JS::NonnullGCPtr<DOM::AbortSignal> Request::signal() const
+GC::Ref<DOM::AbortSignal> Request::signal() const
 {
     // The signal getter steps are to return this’s signal.
     return *m_signal;
@@ -633,7 +633,7 @@ Bindings::RequestDuplex Request::duplex() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-request-clone
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> Request::clone() const
+WebIDL::ExceptionOr<GC::Ref<Request>> Request::clone() const
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/Fetch/Request.h b/Libraries/LibWeb/Fetch/Request.h
index eac7663ded7..5e9a0f521b2 100644
--- a/Libraries/LibWeb/Fetch/Request.h
+++ b/Libraries/LibWeb/Fetch/Request.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Bindings/RequestPrototype.h>
 #include <LibWeb/Fetch/Body.h>
@@ -20,7 +20,7 @@
 namespace Web::Fetch {
 
 // https://fetch.spec.whatwg.org/#requestinfo
-using RequestInfo = Variant<JS::Handle<Request>, String>;
+using RequestInfo = Variant<GC::Root<Request>, String>;
 
 // https://fetch.spec.whatwg.org/#requestinit
 struct RequestInit {
@@ -35,7 +35,7 @@ struct RequestInit {
     Optional<Bindings::RequestRedirect> redirect;
     Optional<String> integrity;
     Optional<bool> keepalive;
-    Optional<JS::GCPtr<DOM::AbortSignal>> signal;
+    Optional<GC::Ptr<DOM::AbortSignal>> signal;
     Optional<Bindings::RequestDuplex> duplex;
     Optional<Bindings::RequestPriority> priority;
     Optional<JS::Value> window;
@@ -66,27 +66,27 @@ class Request final
     : public Bindings::PlatformObject
     , public BodyMixin {
     WEB_PLATFORM_OBJECT(Request, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Request);
+    GC_DECLARE_ALLOCATOR(Request);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Request> create(JS::Realm&, JS::NonnullGCPtr<Infrastructure::Request>, Headers::Guard, JS::NonnullGCPtr<DOM::AbortSignal>);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> construct_impl(JS::Realm&, RequestInfo const& input, RequestInit const& init = {});
+    [[nodiscard]] static GC::Ref<Request> create(JS::Realm&, GC::Ref<Infrastructure::Request>, Headers::Guard, GC::Ref<DOM::AbortSignal>);
+    static WebIDL::ExceptionOr<GC::Ref<Request>> construct_impl(JS::Realm&, RequestInfo const& input, RequestInit const& init = {});
 
     virtual ~Request() override;
 
     // ^BodyMixin
     virtual Optional<MimeSniff::MimeType> mime_type_impl() const override;
-    virtual JS::GCPtr<Infrastructure::Body> body_impl() override;
-    virtual JS::GCPtr<Infrastructure::Body const> body_impl() const override;
+    virtual GC::Ptr<Infrastructure::Body> body_impl() override;
+    virtual GC::Ptr<Infrastructure::Body const> body_impl() const override;
     virtual Bindings::PlatformObject& as_platform_object() override { return *this; }
     virtual Bindings::PlatformObject const& as_platform_object() const override { return *this; }
 
-    [[nodiscard]] JS::NonnullGCPtr<Infrastructure::Request> request() const { return m_request; }
+    [[nodiscard]] GC::Ref<Infrastructure::Request> request() const { return m_request; }
 
     // JS API functions
     [[nodiscard]] String method() const;
     [[nodiscard]] String url() const;
-    [[nodiscard]] JS::NonnullGCPtr<Headers> headers() const;
+    [[nodiscard]] GC::Ref<Headers> headers() const;
     [[nodiscard]] Bindings::RequestDestination destination() const;
     [[nodiscard]] String referrer() const;
     [[nodiscard]] Bindings::ReferrerPolicy referrer_policy() const;
@@ -98,27 +98,27 @@ public:
     [[nodiscard]] bool keepalive() const;
     [[nodiscard]] bool is_reload_navigation() const;
     [[nodiscard]] bool is_history_navigation() const;
-    [[nodiscard]] JS::NonnullGCPtr<DOM::AbortSignal> signal() const;
+    [[nodiscard]] GC::Ref<DOM::AbortSignal> signal() const;
     [[nodiscard]] Bindings::RequestDuplex duplex() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<Request>> clone() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<Request>> clone() const;
 
 private:
-    Request(JS::Realm&, JS::NonnullGCPtr<Infrastructure::Request>);
+    Request(JS::Realm&, GC::Ref<Infrastructure::Request>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://fetch.spec.whatwg.org/#concept-request-request
     // A Request object has an associated request (a request).
-    JS::NonnullGCPtr<Infrastructure::Request> m_request;
+    GC::Ref<Infrastructure::Request> m_request;
 
     // https://fetch.spec.whatwg.org/#request-headers
     // A Request object also has an associated headers (null or a Headers object), initially null.
-    JS::GCPtr<Headers> m_headers;
+    GC::Ptr<Headers> m_headers;
 
     // https://fetch.spec.whatwg.org/#request-signal
     // A Request object has an associated signal (null or an AbortSignal object), initially null.
-    JS::GCPtr<DOM::AbortSignal> m_signal;
+    GC::Ptr<DOM::AbortSignal> m_signal;
 };
 
 }
diff --git a/Libraries/LibWeb/Fetch/Response.cpp b/Libraries/LibWeb/Fetch/Response.cpp
index fb4a69a3746..ce538b2fd8d 100644
--- a/Libraries/LibWeb/Fetch/Response.cpp
+++ b/Libraries/LibWeb/Fetch/Response.cpp
@@ -19,9 +19,9 @@
 
 namespace Web::Fetch {
 
-JS_DEFINE_ALLOCATOR(Response);
+GC_DEFINE_ALLOCATOR(Response);
 
-Response::Response(JS::Realm& realm, JS::NonnullGCPtr<Infrastructure::Response> response)
+Response::Response(JS::Realm& realm, GC::Ref<Infrastructure::Response> response)
     : PlatformObject(realm)
     , m_response(response)
 {
@@ -53,7 +53,7 @@ Optional<MimeSniff::MimeType> Response::mime_type_impl() const
 
 // https://fetch.spec.whatwg.org/#concept-body-body
 // https://fetch.spec.whatwg.org/#ref-for-concept-body-body%E2%91%A8
-JS::GCPtr<Infrastructure::Body const> Response::body_impl() const
+GC::Ptr<Infrastructure::Body const> Response::body_impl() const
 {
     // Objects including the Body interface mixin have an associated body (null or a body).
     // A Response object’s body is its response’s body.
@@ -62,7 +62,7 @@ JS::GCPtr<Infrastructure::Body const> Response::body_impl() const
 
 // https://fetch.spec.whatwg.org/#concept-body-body
 // https://fetch.spec.whatwg.org/#ref-for-concept-body-body%E2%91%A8
-JS::GCPtr<Infrastructure::Body> Response::body_impl()
+GC::Ptr<Infrastructure::Body> Response::body_impl()
 {
     // Objects including the Body interface mixin have an associated body (null or a body).
     // A Response object’s body is its response’s body.
@@ -70,7 +70,7 @@ JS::GCPtr<Infrastructure::Body> Response::body_impl()
 }
 
 // https://fetch.spec.whatwg.org/#response-create
-JS::NonnullGCPtr<Response> Response::create(JS::Realm& realm, JS::NonnullGCPtr<Infrastructure::Response> response, Headers::Guard guard)
+GC::Ref<Response> Response::create(JS::Realm& realm, GC::Ref<Infrastructure::Response> response, Headers::Guard guard)
 {
     // 1. Let responseObject be a new Response object with realm.
     // 2. Set responseObject’s response to response.
@@ -126,7 +126,7 @@ WebIDL::ExceptionOr<void> Response::initialize_response(ResponseInit const& init
 }
 
 // https://fetch.spec.whatwg.org/#dom-response
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::construct_impl(JS::Realm& realm, Optional<BodyInit> const& body, ResponseInit const& init)
+WebIDL::ExceptionOr<GC::Ref<Response>> Response::construct_impl(JS::Realm& realm, Optional<BodyInit> const& body, ResponseInit const& init)
 {
     auto& vm = realm.vm();
 
@@ -155,7 +155,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::construct_impl(JS::Rea
 }
 
 // https://fetch.spec.whatwg.org/#dom-response-error
-JS::NonnullGCPtr<Response> Response::error(JS::VM& vm)
+GC::Ref<Response> Response::error(JS::VM& vm)
 {
     // The static error() method steps are to return the result of creating a Response object, given a new network error, "immutable", and this’s relevant Realm.
     // FIXME: How can we reliably get 'this', i.e. the object the function was called on, in IDL-defined functions?
@@ -163,7 +163,7 @@ JS::NonnullGCPtr<Response> Response::error(JS::VM& vm)
 }
 
 // https://fetch.spec.whatwg.org/#dom-response-redirect
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::redirect(JS::VM& vm, String const& url, u16 status)
+WebIDL::ExceptionOr<GC::Ref<Response>> Response::redirect(JS::VM& vm, String const& url, u16 status)
 {
     auto& realm = *vm.current_realm();
 
@@ -198,7 +198,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::redirect(JS::VM& vm, S
 }
 
 // https://fetch.spec.whatwg.org/#dom-response-json
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::json(JS::VM& vm, JS::Value data, ResponseInit const& init)
+WebIDL::ExceptionOr<GC::Ref<Response>> Response::json(JS::VM& vm, JS::Value data, ResponseInit const& init)
 {
     auto& realm = *vm.current_realm();
 
@@ -268,14 +268,14 @@ String Response::status_text() const
 }
 
 // https://fetch.spec.whatwg.org/#dom-response-headers
-JS::NonnullGCPtr<Headers> Response::headers() const
+GC::Ref<Headers> Response::headers() const
 {
     // The headers getter steps are to return this’s headers.
     return *m_headers;
 }
 
 // https://fetch.spec.whatwg.org/#dom-response-clone
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> Response::clone() const
+WebIDL::ExceptionOr<GC::Ref<Response>> Response::clone() const
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/Fetch/Response.h b/Libraries/LibWeb/Fetch/Response.h
index 02a4a79965a..a292905249a 100644
--- a/Libraries/LibWeb/Fetch/Response.h
+++ b/Libraries/LibWeb/Fetch/Response.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Bindings/RequestPrototype.h>
 #include <LibWeb/Fetch/Body.h>
@@ -31,41 +31,41 @@ class Response final
     : public Bindings::PlatformObject
     , public BodyMixin {
     WEB_PLATFORM_OBJECT(Response, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Response);
+    GC_DECLARE_ALLOCATOR(Response);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Response> create(JS::Realm&, JS::NonnullGCPtr<Infrastructure::Response>, Headers::Guard);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> construct_impl(JS::Realm&, Optional<BodyInit> const& body = {}, ResponseInit const& init = {});
+    [[nodiscard]] static GC::Ref<Response> create(JS::Realm&, GC::Ref<Infrastructure::Response>, Headers::Guard);
+    static WebIDL::ExceptionOr<GC::Ref<Response>> construct_impl(JS::Realm&, Optional<BodyInit> const& body = {}, ResponseInit const& init = {});
 
     virtual ~Response() override;
 
     // ^BodyMixin
     virtual Optional<MimeSniff::MimeType> mime_type_impl() const override;
-    virtual JS::GCPtr<Infrastructure::Body> body_impl() override;
-    virtual JS::GCPtr<Infrastructure::Body const> body_impl() const override;
+    virtual GC::Ptr<Infrastructure::Body> body_impl() override;
+    virtual GC::Ptr<Infrastructure::Body const> body_impl() const override;
     virtual Bindings::PlatformObject& as_platform_object() override { return *this; }
     virtual Bindings::PlatformObject const& as_platform_object() const override { return *this; }
 
-    [[nodiscard]] JS::NonnullGCPtr<Infrastructure::Response> response() const { return m_response; }
+    [[nodiscard]] GC::Ref<Infrastructure::Response> response() const { return m_response; }
 
     // JS API functions
-    [[nodiscard]] static JS::NonnullGCPtr<Response> error(JS::VM&);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> redirect(JS::VM&, String const& url, u16 status);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> json(JS::VM&, JS::Value data, ResponseInit const& init = {});
+    [[nodiscard]] static GC::Ref<Response> error(JS::VM&);
+    static WebIDL::ExceptionOr<GC::Ref<Response>> redirect(JS::VM&, String const& url, u16 status);
+    static WebIDL::ExceptionOr<GC::Ref<Response>> json(JS::VM&, JS::Value data, ResponseInit const& init = {});
     [[nodiscard]] Bindings::ResponseType type() const;
     [[nodiscard]] String url() const;
     [[nodiscard]] bool redirected() const;
     [[nodiscard]] u16 status() const;
     [[nodiscard]] bool ok() const;
     [[nodiscard]] String status_text() const;
-    [[nodiscard]] JS::NonnullGCPtr<Headers> headers() const;
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<Response>> clone() const;
+    [[nodiscard]] GC::Ref<Headers> headers() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<Response>> clone() const;
 
     // Pull in json() from the BodyMixin, which gets lost due to the static json() above
     using BodyMixin::json;
 
 private:
-    Response(JS::Realm&, JS::NonnullGCPtr<Infrastructure::Response>);
+    Response(JS::Realm&, GC::Ref<Infrastructure::Response>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -74,11 +74,11 @@ private:
 
     // https://fetch.spec.whatwg.org/#concept-response-response
     // A Response object has an associated response (a response).
-    JS::NonnullGCPtr<Infrastructure::Response> m_response;
+    GC::Ref<Infrastructure::Response> m_response;
 
     // https://fetch.spec.whatwg.org/#response-headers
     // A Response object also has an associated headers (null or a Headers object), initially null.
-    JS::GCPtr<Headers> m_headers;
+    GC::Ptr<Headers> m_headers;
 };
 
 }
diff --git a/Libraries/LibWeb/FileAPI/Blob.cpp b/Libraries/LibWeb/FileAPI/Blob.cpp
index afe73e5c50d..8c1201eec47 100644
--- a/Libraries/LibWeb/FileAPI/Blob.cpp
+++ b/Libraries/LibWeb/FileAPI/Blob.cpp
@@ -26,9 +26,9 @@
 
 namespace Web::FileAPI {
 
-JS_DEFINE_ALLOCATOR(Blob);
+GC_DEFINE_ALLOCATOR(Blob);
 
-JS::NonnullGCPtr<Blob> Blob::create(JS::Realm& realm, ByteBuffer byte_buffer, String type)
+GC::Ref<Blob> Blob::create(JS::Realm& realm, ByteBuffer byte_buffer, String type)
 {
     return realm.create<Blob>(realm, move(byte_buffer), move(type));
 }
@@ -103,12 +103,12 @@ ErrorOr<ByteBuffer> process_blob_parts(Vector<BlobPart> const& blob_parts, Optio
                 return bytes.try_append(s.bytes());
             },
             // 2. If element is a BufferSource, get a copy of the bytes held by the buffer source, and append those bytes to bytes.
-            [&](JS::Handle<WebIDL::BufferSource> const& buffer_source) -> ErrorOr<void> {
+            [&](GC::Root<WebIDL::BufferSource> const& buffer_source) -> ErrorOr<void> {
                 auto data_buffer = TRY(WebIDL::get_buffer_source_copy(*buffer_source->raw_object()));
                 return bytes.try_append(data_buffer.bytes());
             },
             // 3. If element is a Blob, append the bytes it represents to bytes.
-            [&](JS::Handle<Blob> const& blob) -> ErrorOr<void> {
+            [&](GC::Root<Blob> const& blob) -> ErrorOr<void> {
                 return bytes.try_append(blob->raw_bytes());
             }));
     }
@@ -184,7 +184,7 @@ WebIDL::ExceptionOr<void> Blob::deserialization_steps(ReadonlySpan<u32> const& r
 }
 
 // https://w3c.github.io/FileAPI/#ref-for-dom-blob-blob
-JS::NonnullGCPtr<Blob> Blob::create(JS::Realm& realm, Optional<Vector<BlobPart>> const& blob_parts, Optional<BlobPropertyBag> const& options)
+GC::Ref<Blob> Blob::create(JS::Realm& realm, Optional<Vector<BlobPart>> const& blob_parts, Optional<BlobPropertyBag> const& options)
 {
     // 1. If invoked with zero parameters, return a new Blob object consisting of 0 bytes, with size set to 0, and with type set to the empty string.
     if (!blob_parts.has_value() && !options.has_value())
@@ -216,13 +216,13 @@ JS::NonnullGCPtr<Blob> Blob::create(JS::Realm& realm, Optional<Vector<BlobPart>>
     return realm.create<Blob>(realm, move(byte_buffer), move(type));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> Blob::construct_impl(JS::Realm& realm, Optional<Vector<BlobPart>> const& blob_parts, Optional<BlobPropertyBag> const& options)
+WebIDL::ExceptionOr<GC::Ref<Blob>> Blob::construct_impl(JS::Realm& realm, Optional<Vector<BlobPart>> const& blob_parts, Optional<BlobPropertyBag> const& options)
 {
     return Blob::create(realm, blob_parts, options);
 }
 
 // https://w3c.github.io/FileAPI/#dfn-slice
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> Blob::slice(Optional<i64> start, Optional<i64> end, Optional<String> const& content_type)
+WebIDL::ExceptionOr<GC::Ref<Blob>> Blob::slice(Optional<i64> start, Optional<i64> end, Optional<String> const& content_type)
 {
     // 1. Let sliceStart, sliceEnd, and sliceContentType be null.
     // 2. If start is given, set sliceStart to start.
@@ -233,7 +233,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> Blob::slice(Optional<i64> start, Opt
 }
 
 // https://w3c.github.io/FileAPI/#slice-blob
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> Blob::slice_blob(Optional<i64> start, Optional<i64> end, Optional<String> const& content_type)
+WebIDL::ExceptionOr<GC::Ref<Blob>> Blob::slice_blob(Optional<i64> start, Optional<i64> end, Optional<String> const& content_type)
 {
     auto& vm = realm().vm();
 
@@ -309,14 +309,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> Blob::slice_blob(Optional<i64> start
 }
 
 // https://w3c.github.io/FileAPI/#dom-blob-stream
-JS::NonnullGCPtr<Streams::ReadableStream> Blob::stream()
+GC::Ref<Streams::ReadableStream> Blob::stream()
 {
     // The stream() method, when invoked, must return the result of calling get stream on this.
     return get_stream();
 }
 
 // https://w3c.github.io/FileAPI/#blob-get-stream
-JS::NonnullGCPtr<Streams::ReadableStream> Blob::get_stream()
+GC::Ref<Streams::ReadableStream> Blob::get_stream()
 {
     auto& realm = this->realm();
 
@@ -335,7 +335,7 @@ JS::NonnullGCPtr<Streams::ReadableStream> Blob::get_stream()
             auto bytes = m_byte_buffer;
 
             // 2. Queue a global task on the file reading task source given blob’s relevant global object to perform the following steps:
-            HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), JS::create_heap_function(heap(), [stream, bytes = move(bytes)]() {
+            HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [stream, bytes = move(bytes)]() {
                 // NOTE: Using an TemporaryExecutionContext here results in a crash in the method HTML::incumbent_realm()
                 //       since we end up in a state where we have no execution context + an event loop with an empty incumbent
                 //       realm stack. We still need an execution context therefore we push the realm's execution context
@@ -378,7 +378,7 @@ JS::NonnullGCPtr<Streams::ReadableStream> Blob::get_stream()
 }
 
 // https://w3c.github.io/FileAPI/#dom-blob-text
-JS::NonnullGCPtr<WebIDL::Promise> Blob::text()
+GC::Ref<WebIDL::Promise> Blob::text()
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
@@ -396,7 +396,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Blob::text()
     auto promise = reader->read_all_bytes_deprecated();
 
     // 4. Return the result of transforming promise by a fulfillment handler that returns the result of running UTF-8 decode on its first argument.
-    return WebIDL::upon_fulfillment(*promise, JS::create_heap_function(heap(), [&vm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
+    return WebIDL::upon_fulfillment(*promise, GC::create_function(heap(), [&vm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
         auto const& object = first_argument.as_object();
         VERIFY(is<JS::ArrayBuffer>(object));
         auto const& buffer = static_cast<const JS::ArrayBuffer&>(object).buffer();
@@ -408,7 +408,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Blob::text()
 }
 
 // https://w3c.github.io/FileAPI/#dom-blob-arraybuffer
-JS::NonnullGCPtr<WebIDL::Promise> Blob::array_buffer()
+GC::Ref<WebIDL::Promise> Blob::array_buffer()
 {
     auto& realm = this->realm();
 
@@ -425,7 +425,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Blob::array_buffer()
     auto promise = reader->read_all_bytes_deprecated();
 
     // 4. Return the result of transforming promise by a fulfillment handler that returns a new ArrayBuffer whose contents are its first argument.
-    return WebIDL::upon_fulfillment(*promise, JS::create_heap_function(heap(), [&realm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
+    return WebIDL::upon_fulfillment(*promise, GC::create_function(heap(), [&realm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
         auto const& object = first_argument.as_object();
         VERIFY(is<JS::ArrayBuffer>(object));
         auto const& buffer = static_cast<const JS::ArrayBuffer&>(object).buffer();
@@ -435,7 +435,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Blob::array_buffer()
 }
 
 // https://w3c.github.io/FileAPI/#dom-blob-bytes
-JS::NonnullGCPtr<WebIDL::Promise> Blob::bytes()
+GC::Ref<WebIDL::Promise> Blob::bytes()
 {
     auto& realm = this->realm();
 
@@ -452,7 +452,7 @@ JS::NonnullGCPtr<WebIDL::Promise> Blob::bytes()
     auto promise = reader->read_all_bytes_deprecated();
 
     // 4. Return the result of transforming promise by a fulfillment handler that returns a new Uint8Array wrapping an ArrayBuffer containing its first argument.
-    return WebIDL::upon_fulfillment(*promise, JS::create_heap_function(heap(), [&realm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
+    return WebIDL::upon_fulfillment(*promise, GC::create_function(heap(), [&realm](JS::Value first_argument) -> WebIDL::ExceptionOr<JS::Value> {
         auto& object = first_argument.as_object();
         VERIFY(is<JS::ArrayBuffer>(object));
         auto& array_buffer = static_cast<JS::ArrayBuffer&>(object);
diff --git a/Libraries/LibWeb/FileAPI/Blob.h b/Libraries/LibWeb/FileAPI/Blob.h
index c7f240e280e..1c83b2658d2 100644
--- a/Libraries/LibWeb/FileAPI/Blob.h
+++ b/Libraries/LibWeb/FileAPI/Blob.h
@@ -16,7 +16,7 @@
 
 namespace Web::FileAPI {
 
-using BlobPart = Variant<JS::Handle<WebIDL::BufferSource>, JS::Handle<Blob>, String>;
+using BlobPart = Variant<GC::Root<WebIDL::BufferSource>, GC::Root<Blob>, String>;
 
 struct BlobPropertyBag {
     String type = String {};
@@ -31,30 +31,30 @@ class Blob
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(Blob, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Blob);
+    GC_DECLARE_ALLOCATOR(Blob);
 
 public:
     virtual ~Blob() override;
 
-    [[nodiscard]] static JS::NonnullGCPtr<Blob> create(JS::Realm&, ByteBuffer, String type);
-    [[nodiscard]] static JS::NonnullGCPtr<Blob> create(JS::Realm&, Optional<Vector<BlobPart>> const& blob_parts = {}, Optional<BlobPropertyBag> const& options = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> construct_impl(JS::Realm&, Optional<Vector<BlobPart>> const& blob_parts = {}, Optional<BlobPropertyBag> const& options = {});
+    [[nodiscard]] static GC::Ref<Blob> create(JS::Realm&, ByteBuffer, String type);
+    [[nodiscard]] static GC::Ref<Blob> create(JS::Realm&, Optional<Vector<BlobPart>> const& blob_parts = {}, Optional<BlobPropertyBag> const& options = {});
+    static WebIDL::ExceptionOr<GC::Ref<Blob>> construct_impl(JS::Realm&, Optional<Vector<BlobPart>> const& blob_parts = {}, Optional<BlobPropertyBag> const& options = {});
 
     // https://w3c.github.io/FileAPI/#dfn-size
     u64 size() const { return m_byte_buffer.size(); }
     // https://w3c.github.io/FileAPI/#dfn-type
     String const& type() const { return m_type; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> slice(Optional<i64> start = {}, Optional<i64> end = {}, Optional<String> const& content_type = {});
+    WebIDL::ExceptionOr<GC::Ref<Blob>> slice(Optional<i64> start = {}, Optional<i64> end = {}, Optional<String> const& content_type = {});
 
-    JS::NonnullGCPtr<Streams::ReadableStream> stream();
-    JS::NonnullGCPtr<WebIDL::Promise> text();
-    JS::NonnullGCPtr<WebIDL::Promise> array_buffer();
-    JS::NonnullGCPtr<WebIDL::Promise> bytes();
+    GC::Ref<Streams::ReadableStream> stream();
+    GC::Ref<WebIDL::Promise> text();
+    GC::Ref<WebIDL::Promise> array_buffer();
+    GC::Ref<WebIDL::Promise> bytes();
 
     ReadonlyBytes raw_bytes() const { return m_byte_buffer.bytes(); }
 
-    JS::NonnullGCPtr<Streams::ReadableStream> get_stream();
+    GC::Ref<Streams::ReadableStream> get_stream();
 
     virtual StringView interface_name() const override { return "Blob"sv; }
 
@@ -67,7 +67,7 @@ protected:
 
     virtual void initialize(JS::Realm&) override;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Blob>> slice_blob(Optional<i64> start = {}, Optional<i64> end = {}, Optional<String> const& content_type = {});
+    WebIDL::ExceptionOr<GC::Ref<Blob>> slice_blob(Optional<i64> start = {}, Optional<i64> end = {}, Optional<String> const& content_type = {});
 
     ByteBuffer m_byte_buffer {};
     String m_type {};
diff --git a/Libraries/LibWeb/FileAPI/BlobURLStore.cpp b/Libraries/LibWeb/FileAPI/BlobURLStore.cpp
index 41b7132faf5..d27a42e561f 100644
--- a/Libraries/LibWeb/FileAPI/BlobURLStore.cpp
+++ b/Libraries/LibWeb/FileAPI/BlobURLStore.cpp
@@ -60,7 +60,7 @@ ErrorOr<String> generate_new_blob_url()
 }
 
 // https://w3c.github.io/FileAPI/#add-an-entry
-ErrorOr<String> add_entry_to_blob_url_store(JS::NonnullGCPtr<Blob> object)
+ErrorOr<String> add_entry_to_blob_url_store(GC::Ref<Blob> object)
 {
     // 1. Let store be the user agent’s blob URL store.
     auto& store = blob_url_store();
@@ -93,7 +93,7 @@ ErrorOr<void> remove_entry_from_blob_url_store(StringView url)
 }
 
 // https://w3c.github.io/FileAPI/#lifeTime
-void run_unloading_cleanup_steps(JS::NonnullGCPtr<DOM::Document> document)
+void run_unloading_cleanup_steps(GC::Ref<DOM::Document> document)
 {
     // 1.  Let environment be the Document's relevant settings object.
     auto& environment = document->relevant_settings_object();
diff --git a/Libraries/LibWeb/FileAPI/BlobURLStore.h b/Libraries/LibWeb/FileAPI/BlobURLStore.h
index 7e3664e20f5..45be3b441d7 100644
--- a/Libraries/LibWeb/FileAPI/BlobURLStore.h
+++ b/Libraries/LibWeb/FileAPI/BlobURLStore.h
@@ -8,8 +8,8 @@
 
 #include <AK/HashMap.h>
 #include <AK/String.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibURL/Forward.h>
 #include <LibWeb/Forward.h>
 
@@ -17,8 +17,8 @@ namespace Web::FileAPI {
 
 // https://w3c.github.io/FileAPI/#blob-url-entry
 struct BlobURLEntry {
-    JS::Handle<Blob> object; // FIXME: This could also be a MediaSource after we implement MSE.
-    JS::Handle<HTML::EnvironmentSettingsObject> environment;
+    GC::Root<Blob> object; // FIXME: This could also be a MediaSource after we implement MSE.
+    GC::Root<HTML::EnvironmentSettingsObject> environment;
 };
 
 // https://w3c.github.io/FileAPI/#BlobURLStore
@@ -26,10 +26,10 @@ using BlobURLStore = HashMap<String, BlobURLEntry>;
 
 BlobURLStore& blob_url_store();
 ErrorOr<String> generate_new_blob_url();
-ErrorOr<String> add_entry_to_blob_url_store(JS::NonnullGCPtr<Blob> object);
+ErrorOr<String> add_entry_to_blob_url_store(GC::Ref<Blob> object);
 ErrorOr<void> remove_entry_from_blob_url_store(StringView url);
 Optional<BlobURLEntry> resolve_a_blob_url(URL::URL const&);
 
-void run_unloading_cleanup_steps(JS::NonnullGCPtr<DOM::Document>);
+void run_unloading_cleanup_steps(GC::Ref<DOM::Document>);
 
 }
diff --git a/Libraries/LibWeb/FileAPI/File.cpp b/Libraries/LibWeb/FileAPI/File.cpp
index 67c4e1c5348..db7e93738c2 100644
--- a/Libraries/LibWeb/FileAPI/File.cpp
+++ b/Libraries/LibWeb/FileAPI/File.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::FileAPI {
 
-JS_DEFINE_ALLOCATOR(File);
+GC_DEFINE_ALLOCATOR(File);
 
 File::File(JS::Realm& realm, ByteBuffer byte_buffer, String file_name, String type, i64 last_modified)
     : Blob(realm, move(byte_buffer), move(type))
@@ -36,13 +36,13 @@ void File::initialize(JS::Realm& realm)
 
 File::~File() = default;
 
-JS::NonnullGCPtr<File> File::create(JS::Realm& realm)
+GC::Ref<File> File::create(JS::Realm& realm)
 {
     return realm.create<File>(realm);
 }
 
 // https://w3c.github.io/FileAPI/#ref-for-dom-file-file
-WebIDL::ExceptionOr<JS::NonnullGCPtr<File>> File::create(JS::Realm& realm, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options)
+WebIDL::ExceptionOr<GC::Ref<File>> File::create(JS::Realm& realm, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options)
 {
     auto& vm = realm.vm();
 
@@ -82,7 +82,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<File>> File::create(JS::Realm& realm, Vecto
     return realm.create<File>(realm, move(bytes), move(name), move(type), last_modified);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<File>> File::construct_impl(JS::Realm& realm, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options)
+WebIDL::ExceptionOr<GC::Ref<File>> File::construct_impl(JS::Realm& realm, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options)
 {
     return create(realm, file_bits, file_name, options);
 }
diff --git a/Libraries/LibWeb/FileAPI/File.h b/Libraries/LibWeb/FileAPI/File.h
index 5a8fa860943..3cadef5fcd2 100644
--- a/Libraries/LibWeb/FileAPI/File.h
+++ b/Libraries/LibWeb/FileAPI/File.h
@@ -16,12 +16,12 @@ struct FilePropertyBag : BlobPropertyBag {
 
 class File : public Blob {
     WEB_PLATFORM_OBJECT(File, Blob);
-    JS_DECLARE_ALLOCATOR(File);
+    GC_DECLARE_ALLOCATOR(File);
 
 public:
-    static JS::NonnullGCPtr<File> create(JS::Realm& realm);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<File>> create(JS::Realm&, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<File>> construct_impl(JS::Realm&, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options = {});
+    static GC::Ref<File> create(JS::Realm& realm);
+    static WebIDL::ExceptionOr<GC::Ref<File>> create(JS::Realm&, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options = {});
+    static WebIDL::ExceptionOr<GC::Ref<File>> construct_impl(JS::Realm&, Vector<BlobPart> const& file_bits, String const& file_name, Optional<FilePropertyBag> const& options = {});
 
     virtual ~File() override;
 
diff --git a/Libraries/LibWeb/FileAPI/FileList.cpp b/Libraries/LibWeb/FileAPI/FileList.cpp
index 0a21892114e..9251de64c98 100644
--- a/Libraries/LibWeb/FileAPI/FileList.cpp
+++ b/Libraries/LibWeb/FileAPI/FileList.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::FileAPI {
 
-JS_DEFINE_ALLOCATOR(FileList);
+GC_DEFINE_ALLOCATOR(FileList);
 
-JS::NonnullGCPtr<FileList> FileList::create(JS::Realm& realm)
+GC::Ref<FileList> FileList::create(JS::Realm& realm)
 {
     return realm.create<FileList>(realm);
 }
diff --git a/Libraries/LibWeb/FileAPI/FileList.h b/Libraries/LibWeb/FileAPI/FileList.h
index 4fcd3208bd7..f485d1821e6 100644
--- a/Libraries/LibWeb/FileAPI/FileList.h
+++ b/Libraries/LibWeb/FileAPI/FileList.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/Vector.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/FileAPI/File.h>
 #include <LibWeb/WebIDL/Types.h>
@@ -19,12 +19,12 @@ class FileList
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(FileList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(FileList);
+    GC_DECLARE_ALLOCATOR(FileList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FileList> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<FileList> create(JS::Realm&);
 
-    void add_file(JS::NonnullGCPtr<File> file) { m_files.append(file); }
+    void add_file(GC::Ref<File> file) { m_files.append(file); }
 
     virtual ~FileList() override;
 
@@ -55,7 +55,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<JS::NonnullGCPtr<File>> m_files;
+    Vector<GC::Ref<File>> m_files;
 };
 
 }
diff --git a/Libraries/LibWeb/FileAPI/FileReader.cpp b/Libraries/LibWeb/FileAPI/FileReader.cpp
index acb0581d549..db04958fd5e 100644
--- a/Libraries/LibWeb/FileAPI/FileReader.cpp
+++ b/Libraries/LibWeb/FileAPI/FileReader.cpp
@@ -8,7 +8,7 @@
 #include <AK/Base64.h>
 #include <AK/ByteBuffer.h>
 #include <AK/Time.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Promise.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibJS/Runtime/TypedArray.h>
@@ -32,7 +32,7 @@
 
 namespace Web::FileAPI {
 
-JS_DEFINE_ALLOCATOR(FileReader);
+GC_DEFINE_ALLOCATOR(FileReader);
 
 FileReader::~FileReader() = default;
 
@@ -53,12 +53,12 @@ void FileReader::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_error);
 }
 
-JS::NonnullGCPtr<FileReader> FileReader::create(JS::Realm& realm)
+GC::Ref<FileReader> FileReader::create(JS::Realm& realm)
 {
     return realm.create<FileReader>(realm);
 }
 
-JS::NonnullGCPtr<FileReader> FileReader::construct_impl(JS::Realm& realm)
+GC::Ref<FileReader> FileReader::construct_impl(JS::Realm& realm)
 {
     return FileReader::create(realm);
 }
@@ -146,25 +146,25 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
     bool is_first_chunk = true;
 
     // 10. In parallel, while true:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [this, chunk_promise, reader, bytes, is_first_chunk, &realm, type, encoding_name, blobs_type]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this, chunk_promise, reader, bytes, is_first_chunk, &realm, type, encoding_name, blobs_type]() mutable {
         HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
         Optional<MonotonicTime> progress_timer;
 
         while (true) {
             auto& vm = realm.vm();
             // FIXME: Try harder to not reach into the [[Promise]] slot of chunkPromise
-            auto promise = JS::NonnullGCPtr { verify_cast<JS::Promise>(*chunk_promise->promise()) };
+            auto promise = GC::Ref { verify_cast<JS::Promise>(*chunk_promise->promise()) };
 
             // 1. Wait for chunkPromise to be fulfilled or rejected.
             // FIXME: Create spec issue to use WebIDL react to promise steps here instead of this custom logic
-            Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(heap(), [promise]() {
+            Platform::EventLoopPlugin::the().spin_until(GC::create_function(heap(), [promise]() {
                 return promise->state() == JS::Promise::State::Fulfilled || promise->state() == JS::Promise::State::Rejected;
             }));
 
             // 2. If chunkPromise is fulfilled, and isFirstChunk is true, queue a task to fire a progress event called loadstart at fr.
             // NOTE: ISSUE 2 We might change loadstart to be dispatched synchronously, to align with XMLHttpRequest behavior. [Issue #119]
             if (promise->state() == JS::Promise::State::Fulfilled && is_first_chunk) {
-                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), JS::create_heap_function(heap(), [this, &realm]() {
+                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [this, &realm]() {
                     dispatch_event(DOM::Event::create(realm, HTML::EventNames::loadstart));
                 }));
             }
@@ -193,7 +193,7 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
                 // See http://wpt.live/FileAPI/reading-data-section/filereader_events.any.html
                 bool contained_data = byte_sequence.array_length().length() > 0;
                 if (enough_time_passed && contained_data) {
-                    HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), JS::create_heap_function(heap(), [this, &realm]() {
+                    HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [this, &realm]() {
                         dispatch_event(DOM::Event::create(realm, HTML::EventNames::progress));
                     }));
                     progress_timer = now;
@@ -204,7 +204,7 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
             }
             // 5. Otherwise, if chunkPromise is fulfilled with an object whose done property is true, queue a task to run the following steps and abort this algorithm:
             else if (promise->state() == JS::Promise::State::Fulfilled && done.as_bool()) {
-                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), JS::create_heap_function(heap(), [this, bytes, type, &realm, encoding_name, blobs_type]() {
+                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [this, bytes, type, &realm, encoding_name, blobs_type]() {
                     // 1. Set fr’s state to "done".
                     m_state = State::Done;
 
@@ -238,7 +238,7 @@ WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Opti
             }
             // 6. Otherwise, if chunkPromise is rejected with an error error, queue a task to run the following steps and abort this algorithm:
             else if (promise->state() == JS::Promise::State::Rejected) {
-                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), JS::create_heap_function(heap(), [this, &realm]() {
+                HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [this, &realm]() {
                     // 1. Set fr’s state to "done".
                     m_state = State::Done;
 
diff --git a/Libraries/LibWeb/FileAPI/FileReader.h b/Libraries/LibWeb/FileAPI/FileReader.h
index f069f073e3d..8523e116199 100644
--- a/Libraries/LibWeb/FileAPI/FileReader.h
+++ b/Libraries/LibWeb/FileAPI/FileReader.h
@@ -17,15 +17,15 @@ namespace Web::FileAPI {
 // https://w3c.github.io/FileAPI/#dfn-filereader
 class FileReader : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(FileReader, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(FileReader);
+    GC_DECLARE_ALLOCATOR(FileReader);
 
 public:
-    using Result = Variant<Empty, String, JS::Handle<JS::ArrayBuffer>>;
+    using Result = Variant<Empty, String, GC::Root<JS::ArrayBuffer>>;
 
     virtual ~FileReader() override;
 
-    [[nodiscard]] static JS::NonnullGCPtr<FileReader> create(JS::Realm&);
-    static JS::NonnullGCPtr<FileReader> construct_impl(JS::Realm&);
+    [[nodiscard]] static GC::Ref<FileReader> create(JS::Realm&);
+    static GC::Ref<FileReader> construct_impl(JS::Realm&);
 
     // async read methods
     WebIDL::ExceptionOr<void> read_as_array_buffer(Blob&);
@@ -59,7 +59,7 @@ public:
     Result result() const { return m_result; }
 
     // https://w3c.github.io/FileAPI/#dom-filereader-error
-    JS::GCPtr<WebIDL::DOMException> error() const { return m_error; }
+    GC::Ptr<WebIDL::DOMException> error() const { return m_error; }
 
     // event handler attributes
     void set_onloadstart(WebIDL::CallbackType*);
@@ -111,7 +111,7 @@ private:
 
     // A FileReader has an associated error (null or a DOMException). It is initially null.
     // https://w3c.github.io/FileAPI/#filereader-error
-    JS::GCPtr<WebIDL::DOMException> m_error;
+    GC::Ptr<WebIDL::DOMException> m_error;
 };
 
 }
diff --git a/Libraries/LibWeb/Geometry/DOMMatrix.cpp b/Libraries/LibWeb/Geometry/DOMMatrix.cpp
index 7c550b2e196..b669d3ae9f7 100644
--- a/Libraries/LibWeb/Geometry/DOMMatrix.cpp
+++ b/Libraries/LibWeb/Geometry/DOMMatrix.cpp
@@ -15,10 +15,10 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMMatrix);
+GC_DEFINE_ALLOCATOR(DOMMatrix);
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-dommatrix
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::construct_impl(JS::Realm& realm, Optional<Variant<String, Vector<double>>> const& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::construct_impl(JS::Realm& realm, Optional<Variant<String, Vector<double>>> const& init)
 {
     auto& vm = realm.vm();
 
@@ -77,7 +77,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::construct_impl(JS::R
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-dommatrix-from-the-2d-dictionary
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::create_from_dom_matrix_2d_init(JS::Realm& realm, DOMMatrix2DInit& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::create_from_dom_matrix_2d_init(JS::Realm& realm, DOMMatrix2DInit& init)
 {
     // 1. Validate and fixup (2D) other.
     TRY(validate_and_fixup_dom_matrix_2d_init(init));
@@ -96,7 +96,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::create_from_dom_matr
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-dommatrix-from-the-dictionary
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::create_from_dom_matrix_init(JS::Realm& realm, DOMMatrixInit& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::create_from_dom_matrix_init(JS::Realm& realm, DOMMatrixInit& init)
 {
     // 1. Validate and fixup other.
     TRY(validate_and_fixup_dom_matrix_init(init));
@@ -114,12 +114,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::create_from_dom_matr
         init.m41.value(), init.m42.value(), init.m43, init.m44);
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::create_from_dom_matrix_read_only(JS::Realm& realm, DOMMatrixReadOnly const& read_only_matrix)
+GC::Ref<DOMMatrix> DOMMatrix::create_from_dom_matrix_read_only(JS::Realm& realm, DOMMatrixReadOnly const& read_only_matrix)
 {
     return realm.create<DOMMatrix>(realm, read_only_matrix);
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::create(JS::Realm& realm)
+GC::Ref<DOMMatrix> DOMMatrix::create(JS::Realm& realm)
 {
     return realm.create<DOMMatrix>(realm);
 }
@@ -153,13 +153,13 @@ void DOMMatrix::initialize(JS::Realm& realm)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-frommatrix
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::from_matrix(JS::VM& vm, DOMMatrixInit other)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::from_matrix(JS::VM& vm, DOMMatrixInit other)
 {
     return create_from_dom_matrix_init(*vm.current_realm(), other);
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-fromfloat32array
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::from_float32_array(JS::VM& vm, JS::Handle<WebIDL::BufferSource> const& array32)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::from_float32_array(JS::VM& vm, GC::Root<WebIDL::BufferSource> const& array32)
 {
     if (!is<JS::Float32Array>(*array32->raw_object()))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Float32Array");
@@ -184,7 +184,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::from_float32_array(J
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-fromfloat64array
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::from_float64_array(JS::VM& vm, JS::Handle<WebIDL::BufferSource> const& array64)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::from_float64_array(JS::VM& vm, GC::Root<WebIDL::BufferSource> const& array64)
 {
     if (!is<JS::Float64Array>(*array64->raw_object()))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Float64Array");
@@ -383,7 +383,7 @@ void DOMMatrix::set_f(double value)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-multiplyself
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::multiply_self(DOMMatrixInit other)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::multiply_self(DOMMatrixInit other)
 {
     // 1. Let otherObject be the result of invoking create a DOMMatrix from the dictionary other.
     auto other_object = TRY(DOMMatrix::create_from_dom_matrix_init(realm(), other));
@@ -396,11 +396,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::multiply_self(DOMMat
         m_is_2d = false;
 
     // 4. Return the current matrix.
-    return JS::NonnullGCPtr<DOMMatrix>(*this);
+    return GC::Ref<DOMMatrix>(*this);
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-premultiplyself
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::pre_multiply_self(DOMMatrixInit other)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::pre_multiply_self(DOMMatrixInit other)
 {
     // 1. Let otherObject be the result of invoking create a DOMMatrix from the dictionary other.
     auto other_object = TRY(DOMMatrix::create_from_dom_matrix_init(realm(), other));
@@ -413,11 +413,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::pre_multiply_self(DO
         m_is_2d = false;
 
     // 4. Return the current matrix.
-    return JS::NonnullGCPtr<DOMMatrix>(*this);
+    return GC::Ref<DOMMatrix>(*this);
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-translateself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::translate_self(Optional<double> tx, Optional<double> ty, Optional<double> tz)
+GC::Ref<DOMMatrix> DOMMatrix::translate_self(Optional<double> tx, Optional<double> ty, Optional<double> tz)
 {
     // 1. Post-multiply a translation transformation on the current matrix. The 3D translation matrix is described in CSS Transforms.
     m_matrix = m_matrix * Gfx::translation_matrix(Vector3<double> { tx.value_or(0), ty.value_or(0), tz.value_or(0) });
@@ -431,7 +431,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::translate_self(Optional<double> tx, Optio
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-scaleself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::scale_self(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
+GC::Ref<DOMMatrix> DOMMatrix::scale_self(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
 {
     // 1. Perform a translateSelf() transformation on the current matrix with the arguments originX, originY, originZ.
     translate_self(origin_x, origin_y, origin_z);
@@ -456,7 +456,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::scale_self(Optional<double> scale_x, Opti
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-scale3dself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::scale3d_self(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
+GC::Ref<DOMMatrix> DOMMatrix::scale3d_self(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
 {
     // 1. Apply a translateSelf() transformation to the current matrix with the arguments originX, originY, originZ.
     translate_self(origin_x, origin_y, origin_z);
@@ -476,7 +476,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::scale3d_self(Optional<double> scale, Opti
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-rotateself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_self(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z)
+GC::Ref<DOMMatrix> DOMMatrix::rotate_self(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z)
 {
     // 1. If rotY and rotZ are both missing, set rotZ to the value of rotX and set rotX and rotY to 0.
     if (!rot_y.has_value() && !rot_z.has_value()) {
@@ -510,7 +510,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_self(Optional<double> rot_x, Optio
     return *this;
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_from_vector_self(Optional<double> x, Optional<double> y)
+GC::Ref<DOMMatrix> DOMMatrix::rotate_from_vector_self(Optional<double> x, Optional<double> y)
 {
     // 1. Post-multiply a rotation transformation on the current matrix.
     //    The rotation angle is determined by the angle between the vector (1,0)T and (x,y)T in the clockwise direction. If x and y should both be 0 or -0, the angle is specified as 0.
@@ -523,7 +523,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_from_vector_self(Optional<double>
     return *this;
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_axis_angle_self(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle)
+GC::Ref<DOMMatrix> DOMMatrix::rotate_axis_angle_self(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle)
 {
     // 1. Post-multiply a rotation transformation on the current matrix around the specified vector x, y, z by the specified rotation angle in degrees. The 3D rotation matrix is described in CSS Transforms with alpha = angle in degrees. [CSS3-TRANSFORMS]
     m_matrix = m_matrix * Gfx::rotation_matrix<double>(Vector3<double> { x.value_or(0), y.value_or(0), z.value_or(0) }.normalized(), AK::to_radians(angle.value()));
@@ -537,7 +537,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::rotate_axis_angle_self(Optional<double> x
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-skewxself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::skew_x_self(double sx)
+GC::Ref<DOMMatrix> DOMMatrix::skew_x_self(double sx)
 {
     // 1. Post-multiply a skewX transformation on the current matrix by the specified angle sx in degrees. The 2D skewX matrix is described in CSS Transforms with alpha = sx in degrees. [CSS3-TRANSFORMS]
     Gfx::DoubleMatrix4x4 skew_matrix = {
@@ -553,7 +553,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::skew_x_self(double sx)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-skewyself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::skew_y_self(double sy)
+GC::Ref<DOMMatrix> DOMMatrix::skew_y_self(double sy)
 {
     // 1. Post-multiply a skewX transformation on the current matrix by the specified angle sy in degrees. The 2D skewY matrix is described in CSS Transforms with beta = sy in degrees. [CSS3-TRANSFORMS]
     Gfx::DoubleMatrix4x4 skew_matrix = {
@@ -569,7 +569,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::skew_y_self(double sy)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-invertself
-JS::NonnullGCPtr<DOMMatrix> DOMMatrix::invert_self()
+GC::Ref<DOMMatrix> DOMMatrix::invert_self()
 {
     bool is_invertible = m_matrix.is_invertible();
 
@@ -591,7 +591,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrix::invert_self()
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrix-setmatrixvalue
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::set_matrix_value(String const& transform_list)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrix::set_matrix_value(String const& transform_list)
 {
     // 1. Parse transformList into an abstract matrix, and let matrix and 2dTransform be the result. If the result is failure, then throw a "SyntaxError" DOMException.
     auto result = TRY(parse_dom_matrix_init_string(realm(), transform_list));
@@ -603,7 +603,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrix::set_matrix_value(Str
     m_matrix = result.matrix;
 
     // 4. Return the current matrix.
-    return JS::NonnullGCPtr<DOMMatrix>(*this);
+    return GC::Ref<DOMMatrix>(*this);
 }
 
 }
diff --git a/Libraries/LibWeb/Geometry/DOMMatrix.h b/Libraries/LibWeb/Geometry/DOMMatrix.h
index 1fbb7ffa57b..7ada1a3517b 100644
--- a/Libraries/LibWeb/Geometry/DOMMatrix.h
+++ b/Libraries/LibWeb/Geometry/DOMMatrix.h
@@ -16,20 +16,20 @@ namespace Web::Geometry {
 // https://drafts.fxtf.org/geometry/#dommatrix
 class DOMMatrix : public DOMMatrixReadOnly {
     WEB_PLATFORM_OBJECT(DOMMatrix, DOMMatrixReadOnly);
-    JS_DECLARE_ALLOCATOR(DOMMatrix);
+    GC_DECLARE_ALLOCATOR(DOMMatrix);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> construct_impl(JS::Realm&, Optional<Variant<String, Vector<double>>> const& init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> create_from_dom_matrix_2d_init(JS::Realm&, DOMMatrix2DInit& init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> create_from_dom_matrix_init(JS::Realm&, DOMMatrixInit& init);
-    static JS::NonnullGCPtr<DOMMatrix> create_from_dom_matrix_read_only(JS::Realm&, DOMMatrixReadOnly const& read_only_matrix);
-    static JS::NonnullGCPtr<DOMMatrix> create(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> construct_impl(JS::Realm&, Optional<Variant<String, Vector<double>>> const& init);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> create_from_dom_matrix_2d_init(JS::Realm&, DOMMatrix2DInit& init);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> create_from_dom_matrix_init(JS::Realm&, DOMMatrixInit& init);
+    static GC::Ref<DOMMatrix> create_from_dom_matrix_read_only(JS::Realm&, DOMMatrixReadOnly const& read_only_matrix);
+    static GC::Ref<DOMMatrix> create(JS::Realm&);
 
     virtual ~DOMMatrix() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> from_matrix(JS::VM&, DOMMatrixInit other = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> from_float32_array(JS::VM&, JS::Handle<WebIDL::BufferSource> const& array32);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> from_float64_array(JS::VM&, JS::Handle<WebIDL::BufferSource> const& array64);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> from_matrix(JS::VM&, DOMMatrixInit other = {});
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> from_float32_array(JS::VM&, GC::Root<WebIDL::BufferSource> const& array32);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> from_float64_array(JS::VM&, GC::Root<WebIDL::BufferSource> const& array64);
 
     void set_m11(double value);
     void set_m12(double value);
@@ -55,19 +55,19 @@ public:
     void set_e(double value);
     void set_f(double value);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> multiply_self(DOMMatrixInit other = {});
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> pre_multiply_self(DOMMatrixInit other = {});
-    JS::NonnullGCPtr<DOMMatrix> translate_self(Optional<double> tx, Optional<double> ty, Optional<double> tz);
-    JS::NonnullGCPtr<DOMMatrix> scale_self(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
-    JS::NonnullGCPtr<DOMMatrix> scale3d_self(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
-    JS::NonnullGCPtr<DOMMatrix> rotate_self(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z);
-    JS::NonnullGCPtr<DOMMatrix> rotate_from_vector_self(Optional<double> x, Optional<double> y);
-    JS::NonnullGCPtr<DOMMatrix> rotate_axis_angle_self(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle);
-    JS::NonnullGCPtr<DOMMatrix> skew_x_self(double sx = 0);
-    JS::NonnullGCPtr<DOMMatrix> skew_y_self(double sy = 0);
-    JS::NonnullGCPtr<DOMMatrix> invert_self();
+    WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> multiply_self(DOMMatrixInit other = {});
+    WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> pre_multiply_self(DOMMatrixInit other = {});
+    GC::Ref<DOMMatrix> translate_self(Optional<double> tx, Optional<double> ty, Optional<double> tz);
+    GC::Ref<DOMMatrix> scale_self(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
+    GC::Ref<DOMMatrix> scale3d_self(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
+    GC::Ref<DOMMatrix> rotate_self(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z);
+    GC::Ref<DOMMatrix> rotate_from_vector_self(Optional<double> x, Optional<double> y);
+    GC::Ref<DOMMatrix> rotate_axis_angle_self(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle);
+    GC::Ref<DOMMatrix> skew_x_self(double sx = 0);
+    GC::Ref<DOMMatrix> skew_y_self(double sy = 0);
+    GC::Ref<DOMMatrix> invert_self();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> set_matrix_value(String const& transform_list);
+    WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> set_matrix_value(String const& transform_list);
 
     virtual StringView interface_name() const override { return "DOMMatrix"sv; }
 
diff --git a/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.cpp b/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.cpp
index 91126aba7a4..f8cd279434c 100644
--- a/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.cpp
+++ b/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.cpp
@@ -21,10 +21,10 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMMatrixReadOnly);
+GC_DEFINE_ALLOCATOR(DOMMatrixReadOnly);
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-dommatrixreadonly
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::construct_impl(JS::Realm& realm, Optional<Variant<String, Vector<double>>> const& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::construct_impl(JS::Realm& realm, Optional<Variant<String, Vector<double>>> const& init)
 {
     auto& vm = realm.vm();
 
@@ -83,7 +83,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::cons
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-dommatrixreadonly-from-the-2d-dictionary
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::create_from_dom_matrix_2d_init(JS::Realm& realm, DOMMatrix2DInit& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::create_from_dom_matrix_2d_init(JS::Realm& realm, DOMMatrix2DInit& init)
 {
     // 1. Validate and fixup (2D) other.
     TRY(validate_and_fixup_dom_matrix_2d_init(init));
@@ -102,7 +102,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::crea
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-dommatrixreadonly-from-the-dictionary
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::create_from_dom_matrix_init(JS::Realm& realm, DOMMatrixInit& init)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::create_from_dom_matrix_init(JS::Realm& realm, DOMMatrixInit& init)
 {
     // 1. Validate and fixup other.
     TRY(validate_and_fixup_dom_matrix_init(init));
@@ -120,7 +120,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::crea
         init.m41.value(), init.m42.value(), init.m43, init.m44);
 }
 
-JS::NonnullGCPtr<DOMMatrixReadOnly> DOMMatrixReadOnly::create(JS::Realm& realm)
+GC::Ref<DOMMatrixReadOnly> DOMMatrixReadOnly::create(JS::Realm& realm)
 {
     return realm.create<DOMMatrixReadOnly>(realm);
 }
@@ -224,13 +224,13 @@ void DOMMatrixReadOnly::initialize_from_create_3d_matrix(double m11, double m12,
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-frommatrix
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_matrix(JS::VM& vm, DOMMatrixInit& other)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_matrix(JS::VM& vm, DOMMatrixInit& other)
 {
     return create_from_dom_matrix_init(*vm.current_realm(), other);
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-fromfloat32array
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_float32_array(JS::VM& vm, JS::Handle<WebIDL::BufferSource> const& array32)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_float32_array(JS::VM& vm, GC::Root<WebIDL::BufferSource> const& array32)
 {
     if (!is<JS::Float32Array>(*array32))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Float32Array");
@@ -255,7 +255,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::from
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-fromfloat64array
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_float64_array(JS::VM& vm, JS::Handle<WebIDL::BufferSource> const& array64)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> DOMMatrixReadOnly::from_float64_array(JS::VM& vm, GC::Root<WebIDL::BufferSource> const& array64)
 {
     if (!is<JS::Float64Array>(*array64))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "Float64Array");
@@ -333,7 +333,7 @@ bool DOMMatrixReadOnly::is_identity() const
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-translate
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::translate(Optional<double> const& tx, Optional<double> const& ty, Optional<double> const& tz) const
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::translate(Optional<double> const& tx, Optional<double> const& ty, Optional<double> const& tz) const
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -344,7 +344,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::translate(Optional<double> const&
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-scale
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::scale(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
 {
     // 1. If scaleY is missing, set scaleY to the value of scaleX.
     if (!scale_y.has_value())
@@ -359,7 +359,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale(Optional<double> scale_x, O
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-scalenonuniform
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale_non_uniform(Optional<double> scale_x, Optional<double> scale_y)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::scale_non_uniform(Optional<double> scale_x, Optional<double> scale_y)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -370,7 +370,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale_non_uniform(Optional<double
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-scale3d
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale3d(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::scale3d(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -380,7 +380,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::scale3d(Optional<double> scale, O
     return result->scale3d_self(scale, origin_x, origin_y, origin_z);
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::rotate(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -390,7 +390,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate(Optional<double> rot_x, Op
     return result->rotate_self(rot_x, rot_y, rot_z);
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate_from_vector(Optional<double> x, Optional<double> y)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::rotate_from_vector(Optional<double> x, Optional<double> y)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -400,7 +400,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate_from_vector(Optional<doubl
     return result->rotate_from_vector_self(x, y);
 }
 
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate_axis_angle(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle)
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::rotate_axis_angle(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -411,7 +411,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::rotate_axis_angle(Optional<double
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-skewx
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::skew_x(double sx) const
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::skew_x(double sx) const
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -422,7 +422,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::skew_x(double sx) const
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-skewy
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::skew_y(double sy) const
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::skew_y(double sy) const
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -433,7 +433,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::skew_y(double sy) const
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-multiply
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrixReadOnly::multiply(DOMMatrixInit other)
+WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> DOMMatrixReadOnly::multiply(DOMMatrixInit other)
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -444,7 +444,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> DOMMatrixReadOnly::multiply(DOM
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-flipx
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::flip_x()
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::flip_x()
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -463,7 +463,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::flip_x()
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-flipy
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::flip_y()
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::flip_y()
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -482,7 +482,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::flip_y()
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-inverse
-JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::inverse() const
+GC::Ref<DOMMatrix> DOMMatrixReadOnly::inverse() const
 {
     // 1. Let result be the resulting matrix initialized to the values of the current matrix.
     auto result = DOMMatrix::create_from_dom_matrix_read_only(realm(), *this);
@@ -494,7 +494,7 @@ JS::NonnullGCPtr<DOMMatrix> DOMMatrixReadOnly::inverse() const
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-transformpoint
-JS::NonnullGCPtr<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointInit const& point) const
+GC::Ref<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointInit const& point) const
 {
     // Let pointObject be the result of invoking create a DOMPoint from the dictionary point.
     auto point_object = DOMPoint::from_point(realm().vm(), point);
@@ -504,7 +504,7 @@ JS::NonnullGCPtr<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointInit const
 }
 
 // https://drafts.fxtf.org/geometry/#transform-a-point-with-a-matrix
-JS::NonnullGCPtr<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointReadOnly const& point) const
+GC::Ref<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointReadOnly const& point) const
 {
     // 1. Let x be point’s x coordinate.
     // 2. Let y be point’s y coordinate.
@@ -527,7 +527,7 @@ JS::NonnullGCPtr<DOMPoint> DOMMatrixReadOnly::transform_point(DOMPointReadOnly c
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-tofloat32array
-JS::NonnullGCPtr<JS::Float32Array> DOMMatrixReadOnly::to_float32_array() const
+GC::Ref<JS::Float32Array> DOMMatrixReadOnly::to_float32_array() const
 {
     // Returns the serialized 16 elements m11 to m44 of the current matrix in column-major order as Float32Array.
     float elements[16] = { static_cast<float>(m11()), static_cast<float>(m12()), static_cast<float>(m13()), static_cast<float>(m14()),
@@ -540,7 +540,7 @@ JS::NonnullGCPtr<JS::Float32Array> DOMMatrixReadOnly::to_float32_array() const
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dommatrixreadonly-tofloat64array
-JS::NonnullGCPtr<JS::Float64Array> DOMMatrixReadOnly::to_float64_array() const
+GC::Ref<JS::Float64Array> DOMMatrixReadOnly::to_float64_array() const
 {
     // Returns the serialized 16 elements m11 to m44 of the current matrix in column-major order as Float64Array.
     double elements[16] = { m11(), m12(), m13(), m14(),
diff --git a/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.h b/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.h
index bfe6cd6ee8b..6a072558d9f 100644
--- a/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.h
+++ b/Libraries/LibWeb/Geometry/DOMMatrixReadOnly.h
@@ -52,19 +52,19 @@ class DOMMatrixReadOnly
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(DOMMatrixReadOnly, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMMatrixReadOnly);
+    GC_DECLARE_ALLOCATOR(DOMMatrixReadOnly);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> construct_impl(JS::Realm&, Optional<Variant<String, Vector<double>>> const& init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> create_from_dom_matrix_2d_init(JS::Realm&, DOMMatrix2DInit& init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> create_from_dom_matrix_init(JS::Realm&, DOMMatrixInit& init);
-    static JS::NonnullGCPtr<DOMMatrixReadOnly> create(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> construct_impl(JS::Realm&, Optional<Variant<String, Vector<double>>> const& init);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> create_from_dom_matrix_2d_init(JS::Realm&, DOMMatrix2DInit& init);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> create_from_dom_matrix_init(JS::Realm&, DOMMatrixInit& init);
+    static GC::Ref<DOMMatrixReadOnly> create(JS::Realm&);
 
     virtual ~DOMMatrixReadOnly() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> from_matrix(JS::VM&, DOMMatrixInit& other);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> from_float32_array(JS::VM&, JS::Handle<WebIDL::BufferSource> const& array32);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrixReadOnly>> from_float64_array(JS::VM&, JS::Handle<WebIDL::BufferSource> const& array64);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> from_matrix(JS::VM&, DOMMatrixInit& other);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> from_float32_array(JS::VM&, GC::Root<WebIDL::BufferSource> const& array32);
+    static WebIDL::ExceptionOr<GC::Ref<DOMMatrixReadOnly>> from_float64_array(JS::VM&, GC::Root<WebIDL::BufferSource> const& array64);
 
     // https://drafts.fxtf.org/geometry/#dommatrix-attributes
     double m11() const { return m_matrix.elements()[0][0]; }
@@ -94,24 +94,24 @@ public:
     bool is2d() const { return m_is_2d; }
     bool is_identity() const;
 
-    JS::NonnullGCPtr<DOMMatrix> translate(Optional<double> const& tx, Optional<double> const& ty, Optional<double> const& tz) const;
-    JS::NonnullGCPtr<DOMMatrix> scale(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
-    JS::NonnullGCPtr<DOMMatrix> scale_non_uniform(Optional<double> scale_x, Optional<double> scale_y);
-    JS::NonnullGCPtr<DOMMatrix> scale3d(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
-    JS::NonnullGCPtr<DOMMatrix> rotate(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z);
-    JS::NonnullGCPtr<DOMMatrix> rotate_from_vector(Optional<double> x, Optional<double> y);
-    JS::NonnullGCPtr<DOMMatrix> rotate_axis_angle(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle);
-    JS::NonnullGCPtr<DOMMatrix> skew_x(double sx = 0) const;
-    JS::NonnullGCPtr<DOMMatrix> skew_y(double sy = 0) const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMMatrix>> multiply(DOMMatrixInit other = {});
-    JS::NonnullGCPtr<DOMMatrix> flip_x();
-    JS::NonnullGCPtr<DOMMatrix> flip_y();
-    JS::NonnullGCPtr<DOMMatrix> inverse() const;
+    GC::Ref<DOMMatrix> translate(Optional<double> const& tx, Optional<double> const& ty, Optional<double> const& tz) const;
+    GC::Ref<DOMMatrix> scale(Optional<double> scale_x, Optional<double> scale_y, Optional<double> scale_z, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
+    GC::Ref<DOMMatrix> scale_non_uniform(Optional<double> scale_x, Optional<double> scale_y);
+    GC::Ref<DOMMatrix> scale3d(Optional<double> scale, Optional<double> origin_x, Optional<double> origin_y, Optional<double> origin_z);
+    GC::Ref<DOMMatrix> rotate(Optional<double> rot_x, Optional<double> rot_y, Optional<double> rot_z);
+    GC::Ref<DOMMatrix> rotate_from_vector(Optional<double> x, Optional<double> y);
+    GC::Ref<DOMMatrix> rotate_axis_angle(Optional<double> x, Optional<double> y, Optional<double> z, Optional<double> angle);
+    GC::Ref<DOMMatrix> skew_x(double sx = 0) const;
+    GC::Ref<DOMMatrix> skew_y(double sy = 0) const;
+    WebIDL::ExceptionOr<GC::Ref<DOMMatrix>> multiply(DOMMatrixInit other = {});
+    GC::Ref<DOMMatrix> flip_x();
+    GC::Ref<DOMMatrix> flip_y();
+    GC::Ref<DOMMatrix> inverse() const;
 
-    JS::NonnullGCPtr<DOMPoint> transform_point(DOMPointInit const&) const;
-    JS::NonnullGCPtr<DOMPoint> transform_point(DOMPointReadOnly const&) const;
-    JS::NonnullGCPtr<JS::Float32Array> to_float32_array() const;
-    JS::NonnullGCPtr<JS::Float64Array> to_float64_array() const;
+    GC::Ref<DOMPoint> transform_point(DOMPointInit const&) const;
+    GC::Ref<DOMPoint> transform_point(DOMPointReadOnly const&) const;
+    GC::Ref<JS::Float32Array> to_float32_array() const;
+    GC::Ref<JS::Float64Array> to_float64_array() const;
 
     WebIDL::ExceptionOr<String> to_string() const;
 
diff --git a/Libraries/LibWeb/Geometry/DOMPoint.cpp b/Libraries/LibWeb/Geometry/DOMPoint.cpp
index 64975ac9601..f110a50e6dd 100644
--- a/Libraries/LibWeb/Geometry/DOMPoint.cpp
+++ b/Libraries/LibWeb/Geometry/DOMPoint.cpp
@@ -11,14 +11,14 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMPoint);
+GC_DEFINE_ALLOCATOR(DOMPoint);
 
-JS::NonnullGCPtr<DOMPoint> DOMPoint::construct_impl(JS::Realm& realm, double x, double y, double z, double w)
+GC::Ref<DOMPoint> DOMPoint::construct_impl(JS::Realm& realm, double x, double y, double z, double w)
 {
     return realm.create<DOMPoint>(realm, x, y, z, w);
 }
 
-JS::NonnullGCPtr<DOMPoint> DOMPoint::create(JS::Realm& realm)
+GC::Ref<DOMPoint> DOMPoint::create(JS::Realm& realm)
 {
     return realm.create<DOMPoint>(realm);
 }
@@ -34,7 +34,7 @@ DOMPoint::DOMPoint(JS::Realm& realm)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dompoint-frompoint
-JS::NonnullGCPtr<DOMPoint> DOMPoint::from_point(JS::VM& vm, DOMPointInit const& other)
+GC::Ref<DOMPoint> DOMPoint::from_point(JS::VM& vm, DOMPointInit const& other)
 {
     // The fromPoint(other) static method on DOMPoint must create a DOMPoint from the dictionary other.
     return construct_impl(*vm.current_realm(), other.x, other.y, other.z, other.w);
diff --git a/Libraries/LibWeb/Geometry/DOMPoint.h b/Libraries/LibWeb/Geometry/DOMPoint.h
index d3f16f55b41..7cf6762ebf0 100644
--- a/Libraries/LibWeb/Geometry/DOMPoint.h
+++ b/Libraries/LibWeb/Geometry/DOMPoint.h
@@ -14,13 +14,13 @@ namespace Web::Geometry {
 // https://drafts.fxtf.org/geometry/#DOMPoint
 class DOMPoint final : public DOMPointReadOnly {
     WEB_PLATFORM_OBJECT(DOMPoint, DOMPointReadOnly);
-    JS_DECLARE_ALLOCATOR(DOMPoint);
+    GC_DECLARE_ALLOCATOR(DOMPoint);
 
 public:
-    static JS::NonnullGCPtr<DOMPoint> construct_impl(JS::Realm&, double x = 0, double y = 0, double z = 0, double w = 1);
-    static JS::NonnullGCPtr<DOMPoint> create(JS::Realm&);
+    static GC::Ref<DOMPoint> construct_impl(JS::Realm&, double x = 0, double y = 0, double z = 0, double w = 1);
+    static GC::Ref<DOMPoint> create(JS::Realm&);
 
-    static JS::NonnullGCPtr<DOMPoint> from_point(JS::VM&, DOMPointInit const&);
+    static GC::Ref<DOMPoint> from_point(JS::VM&, DOMPointInit const&);
 
     virtual ~DOMPoint() override;
 
diff --git a/Libraries/LibWeb/Geometry/DOMPointReadOnly.cpp b/Libraries/LibWeb/Geometry/DOMPointReadOnly.cpp
index cac5acdc841..7f686a73a52 100644
--- a/Libraries/LibWeb/Geometry/DOMPointReadOnly.cpp
+++ b/Libraries/LibWeb/Geometry/DOMPointReadOnly.cpp
@@ -15,14 +15,14 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMPointReadOnly);
+GC_DEFINE_ALLOCATOR(DOMPointReadOnly);
 
-JS::NonnullGCPtr<DOMPointReadOnly> DOMPointReadOnly::construct_impl(JS::Realm& realm, double x, double y, double z, double w)
+GC::Ref<DOMPointReadOnly> DOMPointReadOnly::construct_impl(JS::Realm& realm, double x, double y, double z, double w)
 {
     return realm.create<DOMPointReadOnly>(realm, x, y, z, w);
 }
 
-JS::NonnullGCPtr<DOMPointReadOnly> DOMPointReadOnly::create(JS::Realm& realm)
+GC::Ref<DOMPointReadOnly> DOMPointReadOnly::create(JS::Realm& realm)
 {
     return realm.create<DOMPointReadOnly>(realm);
 }
@@ -42,7 +42,7 @@ DOMPointReadOnly::DOMPointReadOnly(JS::Realm& realm)
 }
 
 // https://drafts.fxtf.org/geometry/#dom-dompointreadonly-frompoint
-JS::NonnullGCPtr<DOMPointReadOnly> DOMPointReadOnly::from_point(JS::VM& vm, DOMPointInit const& other)
+GC::Ref<DOMPointReadOnly> DOMPointReadOnly::from_point(JS::VM& vm, DOMPointInit const& other)
 {
     // The fromPoint(other) static method on DOMPointReadOnly must create a DOMPointReadOnly from the dictionary other.
     return construct_impl(*vm.current_realm(), other.x, other.y, other.z, other.w);
@@ -51,7 +51,7 @@ JS::NonnullGCPtr<DOMPointReadOnly> DOMPointReadOnly::from_point(JS::VM& vm, DOMP
 DOMPointReadOnly::~DOMPointReadOnly() = default;
 
 // https://drafts.fxtf.org/geometry/#dom-dompointreadonly-matrixtransform
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMPoint>> DOMPointReadOnly::matrix_transform(DOMMatrixInit& matrix) const
+WebIDL::ExceptionOr<GC::Ref<DOMPoint>> DOMPointReadOnly::matrix_transform(DOMMatrixInit& matrix) const
 {
     // 1. Let matrixObject be the result of invoking create a DOMMatrix from the dictionary matrix.
     auto matrix_object = TRY(DOMMatrix::create_from_dom_matrix_init(realm(), matrix));
diff --git a/Libraries/LibWeb/Geometry/DOMPointReadOnly.h b/Libraries/LibWeb/Geometry/DOMPointReadOnly.h
index e28421baadc..1f3e2b11d37 100644
--- a/Libraries/LibWeb/Geometry/DOMPointReadOnly.h
+++ b/Libraries/LibWeb/Geometry/DOMPointReadOnly.h
@@ -27,13 +27,13 @@ class DOMPointReadOnly
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(DOMPointReadOnly, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMPointReadOnly);
+    GC_DECLARE_ALLOCATOR(DOMPointReadOnly);
 
 public:
-    static JS::NonnullGCPtr<DOMPointReadOnly> construct_impl(JS::Realm&, double x = 0, double y = 0, double z = 0, double w = 1);
-    static JS::NonnullGCPtr<DOMPointReadOnly> create(JS::Realm&);
+    static GC::Ref<DOMPointReadOnly> construct_impl(JS::Realm&, double x = 0, double y = 0, double z = 0, double w = 1);
+    static GC::Ref<DOMPointReadOnly> create(JS::Realm&);
 
-    static JS::NonnullGCPtr<DOMPointReadOnly> from_point(JS::VM&, DOMPointInit const&);
+    static GC::Ref<DOMPointReadOnly> from_point(JS::VM&, DOMPointInit const&);
 
     virtual ~DOMPointReadOnly() override;
 
@@ -42,7 +42,7 @@ public:
     double z() const { return m_z; }
     double w() const { return m_w; }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMPoint>> matrix_transform(DOMMatrixInit&) const;
+    WebIDL::ExceptionOr<GC::Ref<DOMPoint>> matrix_transform(DOMMatrixInit&) const;
 
     virtual StringView interface_name() const override { return "DOMPointReadOnly"sv; }
     virtual WebIDL::ExceptionOr<void> serialization_steps(HTML::SerializationRecord&, bool for_storage, HTML::SerializationMemory&) override;
diff --git a/Libraries/LibWeb/Geometry/DOMQuad.cpp b/Libraries/LibWeb/Geometry/DOMQuad.cpp
index eacddede11e..974afe6634a 100644
--- a/Libraries/LibWeb/Geometry/DOMQuad.cpp
+++ b/Libraries/LibWeb/Geometry/DOMQuad.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMQuad);
+GC_DEFINE_ALLOCATOR(DOMQuad);
 
-JS::NonnullGCPtr<DOMQuad> DOMQuad::construct_impl(JS::Realm& realm, DOMPointInit const& p1, DOMPointInit const& p2, DOMPointInit const& p3, DOMPointInit const& p4)
+GC::Ref<DOMQuad> DOMQuad::construct_impl(JS::Realm& realm, DOMPointInit const& p1, DOMPointInit const& p2, DOMPointInit const& p3, DOMPointInit const& p4)
 {
     return realm.create<DOMQuad>(realm, p1, p2, p3, p4);
 }
 
-JS::NonnullGCPtr<DOMQuad> DOMQuad::create(JS::Realm& realm)
+GC::Ref<DOMQuad> DOMQuad::create(JS::Realm& realm)
 {
     return realm.create<DOMQuad>(realm);
 }
@@ -43,7 +43,7 @@ DOMQuad::DOMQuad(JS::Realm& realm)
 DOMQuad::~DOMQuad() = default;
 
 // https://drafts.fxtf.org/geometry/#dom-domquad-fromrect
-JS::NonnullGCPtr<DOMQuad> DOMQuad::from_rect(JS::VM& vm, DOMRectInit const& other)
+GC::Ref<DOMQuad> DOMQuad::from_rect(JS::VM& vm, DOMRectInit const& other)
 {
     // The fromRect(other) static method on DOMQuad must create a DOMQuad from the DOMRectInit dictionary other.
     return construct_impl(*vm.current_realm(), { other.x, other.y },
@@ -53,14 +53,14 @@ JS::NonnullGCPtr<DOMQuad> DOMQuad::from_rect(JS::VM& vm, DOMRectInit const& othe
 }
 
 // https://drafts.fxtf.org/geometry/#dom-domquad-fromquad
-JS::NonnullGCPtr<DOMQuad> DOMQuad::from_quad(JS::VM& vm, DOMQuadInit const& other)
+GC::Ref<DOMQuad> DOMQuad::from_quad(JS::VM& vm, DOMQuadInit const& other)
 {
     // The fromQuad(other) static method on DOMQuad must create a DOMQuad from the DOMQuadInit dictionary other.
     return construct_impl(*vm.current_realm(), other.p1, other.p2, other.p3, other.p4);
 }
 
 // https://drafts.fxtf.org/geometry/#dom-domquad-getbounds
-JS::NonnullGCPtr<DOMRect> DOMQuad::get_bounds() const
+GC::Ref<DOMRect> DOMQuad::get_bounds() const
 {
     // The NaN-safe minimum of a non-empty list of unrestricted double values is NaN if any member of the list is NaN, or the minimum of the list otherwise.
     auto nan_safe_minimum = [](double a, double b, double c, double d) -> double {
diff --git a/Libraries/LibWeb/Geometry/DOMQuad.h b/Libraries/LibWeb/Geometry/DOMQuad.h
index 61d6957baf9..2dd9f787ef1 100644
--- a/Libraries/LibWeb/Geometry/DOMQuad.h
+++ b/Libraries/LibWeb/Geometry/DOMQuad.h
@@ -26,23 +26,23 @@ class DOMQuad
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(DOMQuad, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMQuad);
+    GC_DECLARE_ALLOCATOR(DOMQuad);
 
 public:
-    static JS::NonnullGCPtr<DOMQuad> construct_impl(JS::Realm&, DOMPointInit const& p1, DOMPointInit const& p2, DOMPointInit const& p3, DOMPointInit const& p4);
-    static JS::NonnullGCPtr<DOMQuad> create(JS::Realm& realm);
+    static GC::Ref<DOMQuad> construct_impl(JS::Realm&, DOMPointInit const& p1, DOMPointInit const& p2, DOMPointInit const& p3, DOMPointInit const& p4);
+    static GC::Ref<DOMQuad> create(JS::Realm& realm);
 
     virtual ~DOMQuad() override;
 
-    static JS::NonnullGCPtr<DOMQuad> from_rect(JS::VM&, DOMRectInit const&);
-    static JS::NonnullGCPtr<DOMQuad> from_quad(JS::VM&, DOMQuadInit const&);
+    static GC::Ref<DOMQuad> from_rect(JS::VM&, DOMRectInit const&);
+    static GC::Ref<DOMQuad> from_quad(JS::VM&, DOMQuadInit const&);
 
-    JS::NonnullGCPtr<DOMPoint> p1() const { return m_p1; }
-    JS::NonnullGCPtr<DOMPoint> p2() const { return m_p2; }
-    JS::NonnullGCPtr<DOMPoint> p3() const { return m_p3; }
-    JS::NonnullGCPtr<DOMPoint> p4() const { return m_p4; }
+    GC::Ref<DOMPoint> p1() const { return m_p1; }
+    GC::Ref<DOMPoint> p2() const { return m_p2; }
+    GC::Ref<DOMPoint> p3() const { return m_p3; }
+    GC::Ref<DOMPoint> p4() const { return m_p4; }
 
-    JS::NonnullGCPtr<DOMRect> get_bounds() const;
+    GC::Ref<DOMRect> get_bounds() const;
 
     virtual StringView interface_name() const override { return "DOMQuad"sv; }
     virtual WebIDL::ExceptionOr<void> serialization_steps(HTML::SerializationRecord&, bool for_storage, HTML::SerializationMemory&) override;
@@ -55,10 +55,10 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<DOMPoint> m_p1;
-    JS::NonnullGCPtr<DOMPoint> m_p2;
-    JS::NonnullGCPtr<DOMPoint> m_p3;
-    JS::NonnullGCPtr<DOMPoint> m_p4;
+    GC::Ref<DOMPoint> m_p1;
+    GC::Ref<DOMPoint> m_p2;
+    GC::Ref<DOMPoint> m_p3;
+    GC::Ref<DOMPoint> m_p4;
 };
 
 }
diff --git a/Libraries/LibWeb/Geometry/DOMRect.cpp b/Libraries/LibWeb/Geometry/DOMRect.cpp
index 6fc4eda4b14..56792fec499 100644
--- a/Libraries/LibWeb/Geometry/DOMRect.cpp
+++ b/Libraries/LibWeb/Geometry/DOMRect.cpp
@@ -11,25 +11,25 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMRect);
+GC_DEFINE_ALLOCATOR(DOMRect);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMRect>> DOMRect::construct_impl(JS::Realm& realm, double x, double y, double width, double height)
+WebIDL::ExceptionOr<GC::Ref<DOMRect>> DOMRect::construct_impl(JS::Realm& realm, double x, double y, double width, double height)
 {
     return create(realm, Gfx::FloatRect { x, y, width, height });
 }
 
-JS::NonnullGCPtr<DOMRect> DOMRect::create(JS::Realm& realm, Gfx::FloatRect const& rect)
+GC::Ref<DOMRect> DOMRect::create(JS::Realm& realm, Gfx::FloatRect const& rect)
 {
     return realm.create<DOMRect>(realm, rect.x(), rect.y(), rect.width(), rect.height());
 }
 
-JS::NonnullGCPtr<DOMRect> DOMRect::create(JS::Realm& realm)
+GC::Ref<DOMRect> DOMRect::create(JS::Realm& realm)
 {
     return realm.create<DOMRect>(realm);
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-domrect-from-the-dictionary
-JS::NonnullGCPtr<DOMRect> DOMRect::from_rect(JS::VM& vm, Geometry::DOMRectInit const& other)
+GC::Ref<DOMRect> DOMRect::from_rect(JS::VM& vm, Geometry::DOMRectInit const& other)
 {
     auto& realm = *vm.current_realm();
     return realm.create<DOMRect>(realm, other.x, other.y, other.width, other.height);
diff --git a/Libraries/LibWeb/Geometry/DOMRect.h b/Libraries/LibWeb/Geometry/DOMRect.h
index 1a54aecc1b8..f107c119e38 100644
--- a/Libraries/LibWeb/Geometry/DOMRect.h
+++ b/Libraries/LibWeb/Geometry/DOMRect.h
@@ -13,13 +13,13 @@ namespace Web::Geometry {
 // https://drafts.fxtf.org/geometry/#DOMRect
 class DOMRect final : public DOMRectReadOnly {
     WEB_PLATFORM_OBJECT(DOMRect, DOMRectReadOnly);
-    JS_DECLARE_ALLOCATOR(DOMRect);
+    GC_DECLARE_ALLOCATOR(DOMRect);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMRect>> construct_impl(JS::Realm&, double x = 0, double y = 0, double width = 0, double height = 0);
-    [[nodiscard]] static JS::NonnullGCPtr<DOMRect> create(JS::Realm&, Gfx::FloatRect const&);
-    [[nodiscard]] static JS::NonnullGCPtr<DOMRect> create(JS::Realm&);
-    [[nodiscard]] static JS::NonnullGCPtr<DOMRect> from_rect(JS::VM&, DOMRectInit const&);
+    static WebIDL::ExceptionOr<GC::Ref<DOMRect>> construct_impl(JS::Realm&, double x = 0, double y = 0, double width = 0, double height = 0);
+    [[nodiscard]] static GC::Ref<DOMRect> create(JS::Realm&, Gfx::FloatRect const&);
+    [[nodiscard]] static GC::Ref<DOMRect> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<DOMRect> from_rect(JS::VM&, DOMRectInit const&);
 
     virtual ~DOMRect() override;
 
diff --git a/Libraries/LibWeb/Geometry/DOMRectList.cpp b/Libraries/LibWeb/Geometry/DOMRectList.cpp
index 5620d586b27..2630813ae7a 100644
--- a/Libraries/LibWeb/Geometry/DOMRectList.cpp
+++ b/Libraries/LibWeb/Geometry/DOMRectList.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Bindings/DOMRectListPrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Geometry/DOMRect.h>
@@ -13,17 +13,17 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMRectList);
+GC_DEFINE_ALLOCATOR(DOMRectList);
 
-JS::NonnullGCPtr<DOMRectList> DOMRectList::create(JS::Realm& realm, Vector<JS::Handle<DOMRect>> rect_handles)
+GC::Ref<DOMRectList> DOMRectList::create(JS::Realm& realm, Vector<GC::Root<DOMRect>> rect_handles)
 {
-    Vector<JS::NonnullGCPtr<DOMRect>> rects;
+    Vector<GC::Ref<DOMRect>> rects;
     for (auto& rect : rect_handles)
         rects.append(*rect);
     return realm.create<DOMRectList>(realm, move(rects));
 }
 
-DOMRectList::DOMRectList(JS::Realm& realm, Vector<JS::NonnullGCPtr<DOMRect>> rects)
+DOMRectList::DOMRectList(JS::Realm& realm, Vector<GC::Ref<DOMRect>> rects)
     : Bindings::PlatformObject(realm)
     , m_rects(move(rects))
 {
diff --git a/Libraries/LibWeb/Geometry/DOMRectList.h b/Libraries/LibWeb/Geometry/DOMRectList.h
index 10f6bb4b2f5..572f3071e91 100644
--- a/Libraries/LibWeb/Geometry/DOMRectList.h
+++ b/Libraries/LibWeb/Geometry/DOMRectList.h
@@ -16,10 +16,10 @@ namespace Web::Geometry {
 // https://drafts.fxtf.org/geometry-1/#DOMRectList
 class DOMRectList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMRectList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMRectList);
+    GC_DECLARE_ALLOCATOR(DOMRectList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DOMRectList> create(JS::Realm&, Vector<JS::Handle<DOMRect>>);
+    [[nodiscard]] static GC::Ref<DOMRectList> create(JS::Realm&, Vector<GC::Root<DOMRect>>);
 
     virtual ~DOMRectList() override;
 
@@ -29,12 +29,12 @@ public:
     virtual Optional<JS::Value> item_value(size_t index) const override;
 
 private:
-    DOMRectList(JS::Realm&, Vector<JS::NonnullGCPtr<DOMRect>>);
+    DOMRectList(JS::Realm&, Vector<GC::Ref<DOMRect>>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<JS::NonnullGCPtr<DOMRect>> m_rects;
+    Vector<GC::Ref<DOMRect>> m_rects;
 };
 
 }
diff --git a/Libraries/LibWeb/Geometry/DOMRectReadOnly.cpp b/Libraries/LibWeb/Geometry/DOMRectReadOnly.cpp
index 98d756ec20c..1984432045b 100644
--- a/Libraries/LibWeb/Geometry/DOMRectReadOnly.cpp
+++ b/Libraries/LibWeb/Geometry/DOMRectReadOnly.cpp
@@ -13,21 +13,21 @@
 
 namespace Web::Geometry {
 
-JS_DEFINE_ALLOCATOR(DOMRectReadOnly);
+GC_DEFINE_ALLOCATOR(DOMRectReadOnly);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMRectReadOnly>> DOMRectReadOnly::construct_impl(JS::Realm& realm, double x, double y, double width, double height)
+WebIDL::ExceptionOr<GC::Ref<DOMRectReadOnly>> DOMRectReadOnly::construct_impl(JS::Realm& realm, double x, double y, double width, double height)
 {
     return realm.create<DOMRectReadOnly>(realm, x, y, width, height);
 }
 
 // https://drafts.fxtf.org/geometry/#create-a-domrect-from-the-dictionary
-JS::NonnullGCPtr<DOMRectReadOnly> DOMRectReadOnly::from_rect(JS::VM& vm, Geometry::DOMRectInit const& other)
+GC::Ref<DOMRectReadOnly> DOMRectReadOnly::from_rect(JS::VM& vm, Geometry::DOMRectInit const& other)
 {
     auto& realm = *vm.current_realm();
     return realm.create<DOMRectReadOnly>(realm, other.x, other.y, other.width, other.height);
 }
 
-JS::NonnullGCPtr<DOMRectReadOnly> DOMRectReadOnly::create(JS::Realm& realm)
+GC::Ref<DOMRectReadOnly> DOMRectReadOnly::create(JS::Realm& realm)
 {
     return realm.create<DOMRectReadOnly>(realm);
 }
diff --git a/Libraries/LibWeb/Geometry/DOMRectReadOnly.h b/Libraries/LibWeb/Geometry/DOMRectReadOnly.h
index 4769168a543..9c77dc9c7ee 100644
--- a/Libraries/LibWeb/Geometry/DOMRectReadOnly.h
+++ b/Libraries/LibWeb/Geometry/DOMRectReadOnly.h
@@ -27,12 +27,12 @@ class DOMRectReadOnly
     : public Bindings::PlatformObject
     , public Bindings::Serializable {
     WEB_PLATFORM_OBJECT(DOMRectReadOnly, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMRectReadOnly);
+    GC_DECLARE_ALLOCATOR(DOMRectReadOnly);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMRectReadOnly>> construct_impl(JS::Realm&, double x = 0, double y = 0, double width = 0, double height = 0);
-    [[nodiscard]] static JS::NonnullGCPtr<DOMRectReadOnly> from_rect(JS::VM&, DOMRectInit const&);
-    static JS::NonnullGCPtr<DOMRectReadOnly> create(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<DOMRectReadOnly>> construct_impl(JS::Realm&, double x = 0, double y = 0, double width = 0, double height = 0);
+    [[nodiscard]] static GC::Ref<DOMRectReadOnly> from_rect(JS::VM&, DOMRectInit const&);
+    static GC::Ref<DOMRectReadOnly> create(JS::Realm&);
 
     virtual ~DOMRectReadOnly() override;
 
diff --git a/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp b/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp
index 68089984fa4..196e3b4bf83 100644
--- a/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp
+++ b/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp
@@ -4,16 +4,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibGC/Heap.h>
 #include <LibGfx/Bitmap.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(AnimatedBitmapDecodedImageData);
+GC_DEFINE_ALLOCATOR(AnimatedBitmapDecodedImageData);
 
-ErrorOr<JS::NonnullGCPtr<AnimatedBitmapDecodedImageData>> AnimatedBitmapDecodedImageData::create(JS::Realm& realm, Vector<Frame>&& frames, size_t loop_count, bool animated)
+ErrorOr<GC::Ref<AnimatedBitmapDecodedImageData>> AnimatedBitmapDecodedImageData::create(JS::Realm& realm, Vector<Frame>&& frames, size_t loop_count, bool animated)
 {
     return realm.create<AnimatedBitmapDecodedImageData>(move(frames), loop_count, animated);
 }
diff --git a/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h b/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h
index c87e643f017..995a5547c53 100644
--- a/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h
+++ b/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h
@@ -12,8 +12,8 @@
 namespace Web::HTML {
 
 class AnimatedBitmapDecodedImageData final : public DecodedImageData {
-    JS_CELL(AnimatedBitmapDecodedImageData, DecodedImageData);
-    JS_DECLARE_ALLOCATOR(AnimatedBitmapDecodedImageData);
+    GC_CELL(AnimatedBitmapDecodedImageData, DecodedImageData);
+    GC_DECLARE_ALLOCATOR(AnimatedBitmapDecodedImageData);
 
 public:
     struct Frame {
@@ -21,7 +21,7 @@ public:
         int duration { 0 };
     };
 
-    static ErrorOr<JS::NonnullGCPtr<AnimatedBitmapDecodedImageData>> create(JS::Realm&, Vector<Frame>&&, size_t loop_count, bool animated);
+    static ErrorOr<GC::Ref<AnimatedBitmapDecodedImageData>> create(JS::Realm&, Vector<Frame>&&, size_t loop_count, bool animated);
     virtual ~AnimatedBitmapDecodedImageData() override;
 
     virtual RefPtr<Gfx::ImmutableBitmap> bitmap(size_t frame_index, Gfx::IntSize = {}) const override;
diff --git a/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.cpp b/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.cpp
index c21f866ca9a..bd8eae65aa7 100644
--- a/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.cpp
+++ b/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(AnimationFrameCallbackDriver);
+GC_DEFINE_ALLOCATOR(AnimationFrameCallbackDriver);
 
 void AnimationFrameCallbackDriver::visit_edges(Cell::Visitor& visitor)
 {
diff --git a/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.h b/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.h
index dfdb6a00f7b..65109b19a63 100644
--- a/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.h
+++ b/Libraries/LibWeb/HTML/AnimationFrameCallbackDriver.h
@@ -9,18 +9,18 @@
 #pragma once
 
 #include <AK/HashMap.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/WebIDL/Types.h>
 
 namespace Web::HTML {
 
 class AnimationFrameCallbackDriver final : public JS::Cell {
-    JS_CELL(AnimationFrameCallbackDriver, JS::Cell);
-    JS_DECLARE_ALLOCATOR(AnimationFrameCallbackDriver);
+    GC_CELL(AnimationFrameCallbackDriver, JS::Cell);
+    GC_DECLARE_ALLOCATOR(AnimationFrameCallbackDriver);
 
-    using Callback = JS::NonnullGCPtr<JS::HeapFunction<void(double)>>;
+    using Callback = GC::Ref<GC::Function<void(double)>>;
 
 public:
     [[nodiscard]] WebIDL::UnsignedLong add(Callback handler);
diff --git a/Libraries/LibWeb/HTML/AudioTrack.cpp b/Libraries/LibWeb/HTML/AudioTrack.cpp
index 1d62566a618..4edbff5ecc6 100644
--- a/Libraries/LibWeb/HTML/AudioTrack.cpp
+++ b/Libraries/LibWeb/HTML/AudioTrack.cpp
@@ -21,11 +21,11 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(AudioTrack);
+GC_DEFINE_ALLOCATOR(AudioTrack);
 
 static IDAllocator s_audio_track_id_allocator;
 
-AudioTrack::AudioTrack(JS::Realm& realm, JS::NonnullGCPtr<HTMLMediaElement> media_element, NonnullRefPtr<Audio::Loader> loader)
+AudioTrack::AudioTrack(JS::Realm& realm, GC::Ref<HTMLMediaElement> media_element, NonnullRefPtr<Audio::Loader> loader)
     : PlatformObject(realm)
     , m_media_element(media_element)
     , m_audio_plugin(Platform::AudioCodecPlugin::create(move(loader)).release_value_but_fixme_should_propagate_errors())
diff --git a/Libraries/LibWeb/HTML/AudioTrack.h b/Libraries/LibWeb/HTML/AudioTrack.h
index a98eb1a2423..1862bd76037 100644
--- a/Libraries/LibWeb/HTML/AudioTrack.h
+++ b/Libraries/LibWeb/HTML/AudioTrack.h
@@ -15,12 +15,12 @@ namespace Web::HTML {
 
 class AudioTrack final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AudioTrack, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AudioTrack);
+    GC_DECLARE_ALLOCATOR(AudioTrack);
 
 public:
     virtual ~AudioTrack() override;
 
-    void set_audio_track_list(Badge<AudioTrackList>, JS::GCPtr<AudioTrackList> audio_track_list) { m_audio_track_list = audio_track_list; }
+    void set_audio_track_list(Badge<AudioTrackList>, GC::Ptr<AudioTrackList> audio_track_list) { m_audio_track_list = audio_track_list; }
 
     void play(Badge<HTMLAudioElement>);
     void pause(Badge<HTMLAudioElement>);
@@ -39,7 +39,7 @@ public:
     void set_enabled(bool enabled);
 
 private:
-    AudioTrack(JS::Realm&, JS::NonnullGCPtr<HTMLMediaElement>, NonnullRefPtr<Audio::Loader>);
+    AudioTrack(JS::Realm&, GC::Ref<HTMLMediaElement>, NonnullRefPtr<Audio::Loader>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -59,8 +59,8 @@ private:
     // https://html.spec.whatwg.org/multipage/media.html#dom-audiotrack-enabled
     bool m_enabled { false };
 
-    JS::NonnullGCPtr<HTMLMediaElement> m_media_element;
-    JS::GCPtr<AudioTrackList> m_audio_track_list;
+    GC::Ref<HTMLMediaElement> m_media_element;
+    GC::Ptr<AudioTrackList> m_audio_track_list;
 
     NonnullOwnPtr<Platform::AudioCodecPlugin> m_audio_plugin;
 };
diff --git a/Libraries/LibWeb/HTML/AudioTrackList.cpp b/Libraries/LibWeb/HTML/AudioTrackList.cpp
index 9bfb1d270a9..5f64f632b90 100644
--- a/Libraries/LibWeb/HTML/AudioTrackList.cpp
+++ b/Libraries/LibWeb/HTML/AudioTrackList.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(AudioTrackList);
+GC_DEFINE_ALLOCATOR(AudioTrackList);
 
 AudioTrackList::AudioTrackList(JS::Realm& realm)
     : DOM::EventTarget(realm, MayInterfereWithIndexedPropertyAccess::Yes)
@@ -44,7 +44,7 @@ JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> AudioTrackList::internal
     return Base::internal_get_own_property(property_name);
 }
 
-void AudioTrackList::add_track(Badge<HTMLMediaElement>, JS::NonnullGCPtr<AudioTrack> audio_track)
+void AudioTrackList::add_track(Badge<HTMLMediaElement>, GC::Ref<AudioTrack> audio_track)
 {
     m_audio_tracks.append(audio_track);
     audio_track->set_audio_track_list({}, this);
@@ -56,7 +56,7 @@ void AudioTrackList::remove_all_tracks(Badge<HTMLMediaElement>)
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-audiotracklist-gettrackbyid
-JS::GCPtr<AudioTrack> AudioTrackList::get_track_by_id(StringView id) const
+GC::Ptr<AudioTrack> AudioTrackList::get_track_by_id(StringView id) const
 {
     // The AudioTrackList getTrackById(id) and VideoTrackList getTrackById(id) methods must return the first AudioTrack
     // or VideoTrack object (respectively) in the AudioTrackList or VideoTrackList object (respectively) whose identifier
diff --git a/Libraries/LibWeb/HTML/AudioTrackList.h b/Libraries/LibWeb/HTML/AudioTrackList.h
index 8ae8695a4b2..5b0ff080e59 100644
--- a/Libraries/LibWeb/HTML/AudioTrackList.h
+++ b/Libraries/LibWeb/HTML/AudioTrackList.h
@@ -8,7 +8,7 @@
 
 #include <AK/Badge.h>
 #include <AK/String.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/AudioTrack.h>
 
@@ -16,16 +16,16 @@ namespace Web::HTML {
 
 class AudioTrackList final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(AudioTrackList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(AudioTrackList);
+    GC_DECLARE_ALLOCATOR(AudioTrackList);
 
 public:
-    void add_track(Badge<HTMLMediaElement>, JS::NonnullGCPtr<AudioTrack>);
+    void add_track(Badge<HTMLMediaElement>, GC::Ref<AudioTrack>);
     void remove_all_tracks(Badge<HTMLMediaElement>);
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-audiotracklist-length
     size_t length() const { return m_audio_tracks.size(); }
 
-    JS::GCPtr<AudioTrack> get_track_by_id(StringView id) const;
+    GC::Ptr<AudioTrack> get_track_by_id(StringView id) const;
     bool has_enabled_track() const;
 
     template<typename Callback>
@@ -54,7 +54,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> internal_get_own_property(JS::PropertyKey const& property_name) const override;
 
-    Vector<JS::NonnullGCPtr<AudioTrack>> m_audio_tracks;
+    Vector<GC::Ref<AudioTrack>> m_audio_tracks;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/BeforeUnloadEvent.cpp b/Libraries/LibWeb/HTML/BeforeUnloadEvent.cpp
index f61f06c3696..0c50c96f956 100644
--- a/Libraries/LibWeb/HTML/BeforeUnloadEvent.cpp
+++ b/Libraries/LibWeb/HTML/BeforeUnloadEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(BeforeUnloadEvent);
+GC_DEFINE_ALLOCATOR(BeforeUnloadEvent);
 
-JS::NonnullGCPtr<BeforeUnloadEvent> BeforeUnloadEvent::create(JS::Realm& realm, FlyString const& event_name, DOM::EventInit const& event_init)
+GC::Ref<BeforeUnloadEvent> BeforeUnloadEvent::create(JS::Realm& realm, FlyString const& event_name, DOM::EventInit const& event_init)
 {
     return realm.create<BeforeUnloadEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/BeforeUnloadEvent.h b/Libraries/LibWeb/HTML/BeforeUnloadEvent.h
index 93c520d5ad3..a44853d5ffa 100644
--- a/Libraries/LibWeb/HTML/BeforeUnloadEvent.h
+++ b/Libraries/LibWeb/HTML/BeforeUnloadEvent.h
@@ -13,10 +13,10 @@ namespace Web::HTML {
 
 class BeforeUnloadEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(BeforeUnloadEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(BeforeUnloadEvent);
+    GC_DECLARE_ALLOCATOR(BeforeUnloadEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<BeforeUnloadEvent> create(JS::Realm&, FlyString const& event_name, DOM::EventInit const& = {});
+    [[nodiscard]] static GC::Ref<BeforeUnloadEvent> create(JS::Realm&, FlyString const& event_name, DOM::EventInit const& = {});
 
     BeforeUnloadEvent(JS::Realm&, FlyString const& event_name, DOM::EventInit const&);
 
diff --git a/Libraries/LibWeb/HTML/BroadcastChannel.cpp b/Libraries/LibWeb/HTML/BroadcastChannel.cpp
index 859dbd78bf8..092eb4d3041 100644
--- a/Libraries/LibWeb/HTML/BroadcastChannel.cpp
+++ b/Libraries/LibWeb/HTML/BroadcastChannel.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(BroadcastChannel);
+GC_DEFINE_ALLOCATOR(BroadcastChannel);
 
-JS::NonnullGCPtr<BroadcastChannel> BroadcastChannel::construct_impl(JS::Realm& realm, FlyString const& name)
+GC::Ref<BroadcastChannel> BroadcastChannel::construct_impl(JS::Realm& realm, FlyString const& name)
 {
     return realm.create<BroadcastChannel>(realm, name);
 }
diff --git a/Libraries/LibWeb/HTML/BroadcastChannel.h b/Libraries/LibWeb/HTML/BroadcastChannel.h
index 1136b830df9..1c1b1193272 100644
--- a/Libraries/LibWeb/HTML/BroadcastChannel.h
+++ b/Libraries/LibWeb/HTML/BroadcastChannel.h
@@ -12,10 +12,10 @@ namespace Web::HTML {
 
 class BroadcastChannel final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(BroadcastChannel, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(BroadcastChannel);
+    GC_DECLARE_ALLOCATOR(BroadcastChannel);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<BroadcastChannel> construct_impl(JS::Realm&, FlyString const& name);
+    [[nodiscard]] static GC::Ref<BroadcastChannel> construct_impl(JS::Realm&, FlyString const& name);
 
     FlyString name();
 
diff --git a/Libraries/LibWeb/HTML/BrowsingContext.cpp b/Libraries/LibWeb/HTML/BrowsingContext.cpp
index bb05ee2d96e..9a8e88d0412 100644
--- a/Libraries/LibWeb/HTML/BrowsingContext.cpp
+++ b/Libraries/LibWeb/HTML/BrowsingContext.cpp
@@ -34,7 +34,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(BrowsingContext);
+GC_DEFINE_ALLOCATOR(BrowsingContext);
 
 // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#matches-about:blank
 bool url_matches_about_blank(URL::URL const& url)
@@ -90,7 +90,7 @@ URL::Origin determine_the_origin(Optional<URL::URL> const& url, SandboxingFlagSe
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-auxiliary-browsing-context
-WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_auxiliary_browsing_context_and_document(JS::NonnullGCPtr<Page> page, JS::NonnullGCPtr<HTML::BrowsingContext> opener)
+WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_auxiliary_browsing_context_and_document(GC::Ref<Page> page, GC::Ref<HTML::BrowsingContext> opener)
 {
     // 1. Let openerTopLevelBrowsingContext be opener's top-level traversable's active browsing context.
     auto opener_top_level_browsing_context = opener->top_level_traversable()->active_browsing_context();
@@ -123,7 +123,7 @@ WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext
     return BrowsingContext::BrowsingContextAndDocument { browsing_context, document };
 }
 
-static void populate_with_html_head_body(JS::NonnullGCPtr<DOM::Document> document)
+static void populate_with_html_head_body(GC::Ref<DOM::Document> document)
 {
     auto html_node = MUST(DOM::create_element(document, HTML::TagNames::html, Namespace::HTML));
     auto head_element = MUST(DOM::create_element(document, HTML::TagNames::head, Namespace::HTML));
@@ -134,12 +134,12 @@ static void populate_with_html_head_body(JS::NonnullGCPtr<DOM::Document> documen
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-browsing-context
-WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_browsing_context_and_document(JS::NonnullGCPtr<Page> page, JS::GCPtr<DOM::Document> creator, JS::GCPtr<DOM::Element> embedder, JS::NonnullGCPtr<BrowsingContextGroup> group)
+WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext::create_a_new_browsing_context_and_document(GC::Ref<Page> page, GC::Ptr<DOM::Document> creator, GC::Ptr<DOM::Element> embedder, GC::Ref<BrowsingContextGroup> group)
 {
     auto& vm = group->vm();
 
     // 1. Let browsingContext be a new browsing context.
-    JS::NonnullGCPtr<BrowsingContext> browsing_context = *vm.heap().allocate<BrowsingContext>(page);
+    GC::Ref<BrowsingContext> browsing_context = *vm.heap().allocate<BrowsingContext>(page);
 
     // 2. Let unsafeContextCreationTime be the unsafe shared current time.
     [[maybe_unused]] auto unsafe_context_creation_time = HighResolutionTime::unsafe_shared_current_time();
@@ -173,7 +173,7 @@ WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext
 
     // FIXME: 9. Let agent be the result of obtaining a similar-origin window agent given origin, group, and false.
 
-    JS::GCPtr<Window> window;
+    GC::Ptr<Window> window;
 
     // 10. Let realm execution context be the result of creating a new JavaScript realm given agent and the following customizations:
     auto realm_execution_context = Bindings::create_a_new_javascript_realm(
@@ -289,7 +289,7 @@ WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext
     return BrowsingContext::BrowsingContextAndDocument { browsing_context, document };
 }
 
-BrowsingContext::BrowsingContext(JS::NonnullGCPtr<Page> page)
+BrowsingContext::BrowsingContext(GC::Ref<Page> page)
     : m_page(page)
 {
 }
@@ -311,7 +311,7 @@ void BrowsingContext::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#bc-traversable
-JS::NonnullGCPtr<HTML::TraversableNavigable> BrowsingContext::top_level_traversable() const
+GC::Ref<HTML::TraversableNavigable> BrowsingContext::top_level_traversable() const
 {
     // A browsing context's top-level traversable is its active document's node navigable's top-level traversable.
     auto traversable = active_document()->navigable()->top_level_traversable();
@@ -329,7 +329,7 @@ bool BrowsingContext::is_top_level() const
     return active_document() != nullptr && active_document()->navigable() != nullptr && active_document()->navigable()->is_traversable();
 }
 
-JS::GCPtr<BrowsingContext> BrowsingContext::top_level_browsing_context() const
+GC::Ptr<BrowsingContext> BrowsingContext::top_level_browsing_context() const
 {
     auto const* start = this;
 
@@ -388,7 +388,7 @@ HTML::WindowProxy const* BrowsingContext::window_proxy() const
     return m_window_proxy.ptr();
 }
 
-void BrowsingContext::set_window_proxy(JS::GCPtr<WindowProxy> window_proxy)
+void BrowsingContext::set_window_proxy(GC::Ptr<WindowProxy> window_proxy)
 {
     m_window_proxy = move(window_proxy);
 }
@@ -415,7 +415,7 @@ void BrowsingContext::remove()
     VERIFY(group());
 
     // 2. Let group be browsingContext's group.
-    JS::NonnullGCPtr<BrowsingContextGroup> group = *this->group();
+    GC::Ref<BrowsingContextGroup> group = *this->group();
 
     // 3. Set browsingContext's group to null.
     set_group(nullptr);
@@ -434,11 +434,11 @@ BrowsingContext const* BrowsingContext::the_one_permitted_sandboxed_navigator()
     return nullptr;
 }
 
-JS::GCPtr<BrowsingContext> BrowsingContext::first_child() const
+GC::Ptr<BrowsingContext> BrowsingContext::first_child() const
 {
     return m_first_child;
 }
-JS::GCPtr<BrowsingContext> BrowsingContext::next_sibling() const
+GC::Ptr<BrowsingContext> BrowsingContext::next_sibling() const
 {
     return m_next_sibling;
 }
@@ -504,7 +504,7 @@ bool BrowsingContext::is_familiar_with(BrowsingContext const& other) const
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#snapshotting-target-snapshot-params
-SandboxingFlagSet determine_the_creation_sandboxing_flags(BrowsingContext const&, JS::GCPtr<DOM::Element>)
+SandboxingFlagSet determine_the_creation_sandboxing_flags(BrowsingContext const&, GC::Ptr<DOM::Element>)
 {
     // FIXME: Populate this once we have the proper flag sets on BrowsingContext
     return {};
diff --git a/Libraries/LibWeb/HTML/BrowsingContext.h b/Libraries/LibWeb/HTML/BrowsingContext.h
index 2eff98f111b..368db1b6aac 100644
--- a/Libraries/LibWeb/HTML/BrowsingContext.h
+++ b/Libraries/LibWeb/HTML/BrowsingContext.h
@@ -28,24 +28,24 @@
 namespace Web::HTML {
 
 class BrowsingContext final : public JS::Cell {
-    JS_CELL(BrowsingContext, JS::Cell);
-    JS_DECLARE_ALLOCATOR(BrowsingContext);
+    GC_CELL(BrowsingContext, JS::Cell);
+    GC_DECLARE_ALLOCATOR(BrowsingContext);
 
 public:
     struct BrowsingContextAndDocument {
-        JS::NonnullGCPtr<BrowsingContext> browsing_context;
-        JS::NonnullGCPtr<DOM::Document> document;
+        GC::Ref<BrowsingContext> browsing_context;
+        GC::Ref<DOM::Document> document;
     };
 
-    static WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_browsing_context_and_document(JS::NonnullGCPtr<Page> page, JS::GCPtr<DOM::Document> creator, JS::GCPtr<DOM::Element> embedder, JS::NonnullGCPtr<BrowsingContextGroup> group);
-    static WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_auxiliary_browsing_context_and_document(JS::NonnullGCPtr<Page> page, JS::NonnullGCPtr<HTML::BrowsingContext> opener);
+    static WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_browsing_context_and_document(GC::Ref<Page> page, GC::Ptr<DOM::Document> creator, GC::Ptr<DOM::Element> embedder, GC::Ref<BrowsingContextGroup> group);
+    static WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_auxiliary_browsing_context_and_document(GC::Ref<Page> page, GC::Ref<HTML::BrowsingContext> opener);
 
     virtual ~BrowsingContext() override;
 
-    JS::NonnullGCPtr<HTML::TraversableNavigable> top_level_traversable() const;
+    GC::Ref<HTML::TraversableNavigable> top_level_traversable() const;
 
-    JS::GCPtr<BrowsingContext> first_child() const;
-    JS::GCPtr<BrowsingContext> next_sibling() const;
+    GC::Ptr<BrowsingContext> first_child() const;
+    GC::Ptr<BrowsingContext> next_sibling() const;
 
     bool is_ancestor_of(BrowsingContext const&) const;
     bool is_familiar_with(BrowsingContext const&) const;
@@ -103,7 +103,7 @@ public:
     HTML::WindowProxy* window_proxy();
     HTML::WindowProxy const* window_proxy() const;
 
-    void set_window_proxy(JS::GCPtr<WindowProxy>);
+    void set_window_proxy(GC::Ptr<WindowProxy>);
 
     HTML::Window* active_window();
     HTML::Window const* active_window() const;
@@ -113,7 +113,7 @@ public:
 
     u64 virtual_browsing_context_group_id() const { return m_virtual_browsing_context_group_id; }
 
-    JS::GCPtr<BrowsingContext> top_level_browsing_context() const;
+    GC::Ptr<BrowsingContext> top_level_browsing_context() const;
 
     BrowsingContextGroup* group();
     BrowsingContextGroup const* group() const;
@@ -127,23 +127,23 @@ public:
 
     bool has_navigable_been_destroyed() const;
 
-    JS::GCPtr<BrowsingContext> opener_browsing_context() const { return m_opener_browsing_context; }
-    void set_opener_browsing_context(JS::GCPtr<BrowsingContext> browsing_context) { m_opener_browsing_context = browsing_context; }
+    GC::Ptr<BrowsingContext> opener_browsing_context() const { return m_opener_browsing_context; }
+    void set_opener_browsing_context(GC::Ptr<BrowsingContext> browsing_context) { m_opener_browsing_context = browsing_context; }
 
     void set_is_popup(TokenizedFeature::Popup is_popup) { m_is_popup = is_popup; }
 
 private:
-    explicit BrowsingContext(JS::NonnullGCPtr<Page>);
+    explicit BrowsingContext(GC::Ref<Page>);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#browsing-context
-    JS::GCPtr<HTML::WindowProxy> m_window_proxy;
+    GC::Ptr<HTML::WindowProxy> m_window_proxy;
 
     // https://html.spec.whatwg.org/multipage/browsers.html#opener-browsing-context
-    JS::GCPtr<BrowsingContext> m_opener_browsing_context;
+    GC::Ptr<BrowsingContext> m_opener_browsing_context;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#opener-origin-at-creation
     Optional<URL::Origin> m_opener_origin_at_creation;
@@ -161,17 +161,17 @@ private:
     u64 m_virtual_browsing_context_group_id = { 0 };
 
     // https://html.spec.whatwg.org/multipage/browsers.html#tlbc-group
-    JS::GCPtr<BrowsingContextGroup> m_group;
+    GC::Ptr<BrowsingContextGroup> m_group;
 
-    JS::GCPtr<BrowsingContext> m_first_child;
-    JS::GCPtr<BrowsingContext> m_last_child;
-    JS::GCPtr<BrowsingContext> m_next_sibling;
-    JS::GCPtr<BrowsingContext> m_previous_sibling;
+    GC::Ptr<BrowsingContext> m_first_child;
+    GC::Ptr<BrowsingContext> m_last_child;
+    GC::Ptr<BrowsingContext> m_next_sibling;
+    GC::Ptr<BrowsingContext> m_previous_sibling;
 };
 
 URL::Origin determine_the_origin(Optional<URL::URL> const&, SandboxingFlagSet, Optional<URL::Origin> source_origin);
 
-SandboxingFlagSet determine_the_creation_sandboxing_flags(BrowsingContext const&, JS::GCPtr<DOM::Element> embedder);
+SandboxingFlagSet determine_the_creation_sandboxing_flags(BrowsingContext const&, GC::Ptr<DOM::Element> embedder);
 
 // FIXME: Find a better home for these
 bool url_matches_about_blank(URL::URL const& url);
diff --git a/Libraries/LibWeb/HTML/BrowsingContextGroup.cpp b/Libraries/LibWeb/HTML/BrowsingContextGroup.cpp
index 27dd518609b..5711d03fced 100644
--- a/Libraries/LibWeb/HTML/BrowsingContextGroup.cpp
+++ b/Libraries/LibWeb/HTML/BrowsingContextGroup.cpp
@@ -11,16 +11,16 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(BrowsingContextGroup);
+GC_DEFINE_ALLOCATOR(BrowsingContextGroup);
 
 // https://html.spec.whatwg.org/multipage/browsers.html#browsing-context-group-set
-static HashTable<JS::NonnullGCPtr<BrowsingContextGroup>>& user_agent_browsing_context_group_set()
+static HashTable<GC::Ref<BrowsingContextGroup>>& user_agent_browsing_context_group_set()
 {
-    static HashTable<JS::NonnullGCPtr<BrowsingContextGroup>> set;
+    static HashTable<GC::Ref<BrowsingContextGroup>> set;
     return set;
 }
 
-BrowsingContextGroup::BrowsingContextGroup(JS::NonnullGCPtr<Web::Page> page)
+BrowsingContextGroup::BrowsingContextGroup(GC::Ref<Web::Page> page)
     : m_page(page)
 {
     user_agent_browsing_context_group_set().set(*this);
@@ -39,7 +39,7 @@ void BrowsingContextGroup::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-browsing-context-group-and-document
-auto BrowsingContextGroup::create_a_new_browsing_context_group_and_document(JS::NonnullGCPtr<Page> page) -> WebIDL::ExceptionOr<BrowsingContextGroupAndDocument>
+auto BrowsingContextGroup::create_a_new_browsing_context_group_and_document(GC::Ref<Page> page) -> WebIDL::ExceptionOr<BrowsingContextGroupAndDocument>
 {
     // 1. Let group be a new browsing context group.
     // 2. Append group to the user agent's browsing context group set.
diff --git a/Libraries/LibWeb/HTML/BrowsingContextGroup.h b/Libraries/LibWeb/HTML/BrowsingContextGroup.h
index 8f3fd2bb678..1669518b036 100644
--- a/Libraries/LibWeb/HTML/BrowsingContextGroup.h
+++ b/Libraries/LibWeb/HTML/BrowsingContextGroup.h
@@ -15,15 +15,15 @@
 namespace Web::HTML {
 
 class BrowsingContextGroup final : public JS::Cell {
-    JS_CELL(BrowsingContextGroup, JS::Cell);
-    JS_DECLARE_ALLOCATOR(BrowsingContextGroup);
+    GC_CELL(BrowsingContextGroup, JS::Cell);
+    GC_DECLARE_ALLOCATOR(BrowsingContextGroup);
 
 public:
     struct BrowsingContextGroupAndDocument {
-        JS::NonnullGCPtr<HTML::BrowsingContextGroup> browsing_context;
-        JS::NonnullGCPtr<DOM::Document> document;
+        GC::Ref<HTML::BrowsingContextGroup> browsing_context;
+        GC::Ref<DOM::Document> document;
     };
-    static WebIDL::ExceptionOr<BrowsingContextGroupAndDocument> create_a_new_browsing_context_group_and_document(JS::NonnullGCPtr<Page>);
+    static WebIDL::ExceptionOr<BrowsingContextGroupAndDocument> create_a_new_browsing_context_group_and_document(GC::Ref<Page>);
 
     ~BrowsingContextGroup();
 
@@ -36,14 +36,14 @@ public:
     void append(BrowsingContext&);
 
 private:
-    explicit BrowsingContextGroup(JS::NonnullGCPtr<Web::Page>);
+    explicit BrowsingContextGroup(GC::Ref<Web::Page>);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://html.spec.whatwg.org/multipage/browsers.html#browsing-context-group-set
-    OrderedHashTable<JS::NonnullGCPtr<BrowsingContext>> m_browsing_context_set;
+    OrderedHashTable<GC::Ref<BrowsingContext>> m_browsing_context_set;
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.cpp b/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.cpp
index 21480e61da5..9c96199f66a 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.cpp
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.cpp
@@ -13,7 +13,7 @@ namespace Web::HTML {
 static void default_source_size(CanvasImageSource const& image, float& source_width, float& source_height)
 {
     image.visit(
-        [&source_width, &source_height](JS::Handle<HTMLImageElement> const& source) {
+        [&source_width, &source_height](GC::Root<HTMLImageElement> const& source) {
             if (source->immutable_bitmap()) {
                 source_width = source->immutable_bitmap()->width();
                 source_height = source->immutable_bitmap()->height();
@@ -23,7 +23,7 @@ static void default_source_size(CanvasImageSource const& image, float& source_wi
                 source_height = source->height();
             }
         },
-        [&source_width, &source_height](JS::Handle<SVG::SVGImageElement> const& source) {
+        [&source_width, &source_height](GC::Root<SVG::SVGImageElement> const& source) {
             if (source->current_image_bitmap()) {
                 source_width = source->current_image_bitmap()->width();
                 source_height = source->current_image_bitmap()->height();
@@ -33,7 +33,7 @@ static void default_source_size(CanvasImageSource const& image, float& source_wi
                 source_height = source->height()->anim_val()->value();
             }
         },
-        [&source_width, &source_height](JS::Handle<HTML::HTMLVideoElement> const& source) {
+        [&source_width, &source_height](GC::Root<HTML::HTMLVideoElement> const& source) {
             if (auto const bitmap = source->bitmap(); bitmap) {
                 source_width = bitmap->width();
                 source_height = bitmap->height();
@@ -42,7 +42,7 @@ static void default_source_size(CanvasImageSource const& image, float& source_wi
                 source_height = source->video_height();
             }
         },
-        [&source_width, &source_height](JS::Handle<HTMLCanvasElement> const& source) {
+        [&source_width, &source_height](GC::Root<HTMLCanvasElement> const& source) {
             if (source->surface()) {
                 source_width = source->surface()->size().width();
                 source_height = source->surface()->size().height();
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.h b/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.h
index d1b90186f92..3c20a55f2fc 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasDrawImage.h
@@ -16,7 +16,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/canvas.html#canvasimagesource
 // NOTE: This is the Variant created by the IDL wrapper generator, and needs to be updated accordingly.
-using CanvasImageSource = Variant<JS::Handle<HTMLImageElement>, JS::Handle<SVG::SVGImageElement>, JS::Handle<HTMLCanvasElement>, JS::Handle<ImageBitmap>, JS::Handle<HTMLVideoElement>>;
+using CanvasImageSource = Variant<GC::Root<HTMLImageElement>, GC::Root<SVG::SVGImageElement>, GC::Root<HTMLCanvasElement>, GC::Root<ImageBitmap>, GC::Root<HTMLVideoElement>>;
 
 // https://html.spec.whatwg.org/multipage/canvas.html#canvasdrawimage
 class CanvasDrawImage {
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasFillStrokeStyles.h b/Libraries/LibWeb/HTML/Canvas/CanvasFillStrokeStyles.h
index 315153258c2..b25788a7b56 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasFillStrokeStyles.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasFillStrokeStyles.h
@@ -22,7 +22,7 @@ template<typename IncludingClass>
 class CanvasFillStrokeStyles {
 public:
     ~CanvasFillStrokeStyles() = default;
-    using FillOrStrokeStyleVariant = Variant<String, JS::Handle<CanvasGradient>, JS::Handle<CanvasPattern>>;
+    using FillOrStrokeStyleVariant = Variant<String, GC::Root<CanvasGradient>, GC::Root<CanvasPattern>>;
 
     void set_fill_style(FillOrStrokeStyleVariant style)
     {
@@ -107,25 +107,25 @@ public:
         return my_drawing_state().stroke_style.to_js_fill_or_stroke_style();
     }
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> create_radial_gradient(double x0, double y0, double r0, double x1, double y1, double r1)
+    WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> create_radial_gradient(double x0, double y0, double r0, double x1, double y1, double r1)
     {
         auto& realm = static_cast<IncludingClass&>(*this).realm();
         return CanvasGradient::create_radial(realm, x0, y0, r0, x1, y1, r1);
     }
 
-    JS::NonnullGCPtr<CanvasGradient> create_linear_gradient(double x0, double y0, double x1, double y1)
+    GC::Ref<CanvasGradient> create_linear_gradient(double x0, double y0, double x1, double y1)
     {
         auto& realm = static_cast<IncludingClass&>(*this).realm();
         return CanvasGradient::create_linear(realm, x0, y0, x1, y1).release_value_but_fixme_should_propagate_errors();
     }
 
-    JS::NonnullGCPtr<CanvasGradient> create_conic_gradient(double start_angle, double x, double y)
+    GC::Ref<CanvasGradient> create_conic_gradient(double start_angle, double x, double y)
     {
         auto& realm = static_cast<IncludingClass&>(*this).realm();
         return CanvasGradient::create_conic(realm, start_angle, x, y).release_value_but_fixme_should_propagate_errors();
     }
 
-    WebIDL::ExceptionOr<JS::GCPtr<CanvasPattern>> create_pattern(CanvasImageSource const& image, StringView repetition)
+    WebIDL::ExceptionOr<GC::Ptr<CanvasPattern>> create_pattern(CanvasImageSource const& image, StringView repetition)
     {
         auto& realm = static_cast<IncludingClass&>(*this).realm();
         return CanvasPattern::create(realm, image, repetition);
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasImageData.h b/Libraries/LibWeb/HTML/Canvas/CanvasImageData.h
index e365220e024..ff110c30321 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasImageData.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasImageData.h
@@ -15,9 +15,9 @@ class CanvasImageData {
 public:
     virtual ~CanvasImageData() = default;
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const = 0;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create_image_data(ImageData const&) const = 0;
-    virtual WebIDL::ExceptionOr<JS::GCPtr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const = 0;
+    virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const = 0;
+    virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(ImageData const&) const = 0;
+    virtual WebIDL::ExceptionOr<GC::Ptr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const = 0;
     virtual void put_image_data(ImageData const&, float x, float y) = 0;
 
 protected:
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasPath.h b/Libraries/LibWeb/HTML/Canvas/CanvasPath.h
index e729abfa419..a5738af5eb6 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasPath.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasPath.h
@@ -50,7 +50,7 @@ private:
 
     void ensure_subpath(float x, float y);
 
-    JS::NonnullGCPtr<Bindings::PlatformObject> m_self;
+    GC::Ref<Bindings::PlatformObject> m_self;
     Optional<CanvasState const&> m_canvas_state;
     Gfx::Path m_path;
 };
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasState.h b/Libraries/LibWeb/HTML/Canvas/CanvasState.h
index f028a2e7a15..3a5ec3e79cc 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasState.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasState.h
@@ -34,7 +34,7 @@ public:
     void reset();
     bool is_context_lost();
 
-    using FillOrStrokeVariant = Variant<Gfx::Color, JS::Handle<CanvasGradient>, JS::Handle<CanvasPattern>>;
+    using FillOrStrokeVariant = Variant<Gfx::Color, GC::Root<CanvasGradient>, GC::Root<CanvasPattern>>;
 
     struct FillOrStrokeStyle {
         FillOrStrokeStyle(Gfx::Color color)
@@ -42,12 +42,12 @@ public:
         {
         }
 
-        FillOrStrokeStyle(JS::Handle<CanvasGradient> gradient)
+        FillOrStrokeStyle(GC::Root<CanvasGradient> gradient)
             : m_fill_or_stroke_style(gradient)
         {
         }
 
-        FillOrStrokeStyle(JS::Handle<CanvasPattern> pattern)
+        FillOrStrokeStyle(GC::Root<CanvasPattern> pattern)
             : m_fill_or_stroke_style(pattern)
         {
         }
@@ -57,7 +57,7 @@ public:
         Optional<Gfx::Color> as_color() const;
         Gfx::Color to_color_but_fixme_should_accept_any_paint_style() const;
 
-        using JsFillOrStrokeStyle = Variant<String, JS::Handle<CanvasGradient>, JS::Handle<CanvasPattern>>;
+        using JsFillOrStrokeStyle = Variant<String, GC::Root<CanvasGradient>, GC::Root<CanvasPattern>>;
 
         JsFillOrStrokeStyle to_js_fill_or_stroke_style() const
         {
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasText.h b/Libraries/LibWeb/HTML/Canvas/CanvasText.h
index 262bca9f275..c19aac6fa40 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasText.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasText.h
@@ -19,7 +19,7 @@ public:
 
     virtual void fill_text(StringView, float x, float y, Optional<double> max_width) = 0;
     virtual void stroke_text(StringView, float x, float y, Optional<double> max_width) = 0;
-    virtual JS::NonnullGCPtr<TextMetrics> measure_text(StringView text) = 0;
+    virtual GC::Ref<TextMetrics> measure_text(StringView text) = 0;
 
 protected:
     CanvasText() = default;
diff --git a/Libraries/LibWeb/HTML/Canvas/CanvasTransform.h b/Libraries/LibWeb/HTML/Canvas/CanvasTransform.h
index e040aa674cd..1aeb945aab4 100644
--- a/Libraries/LibWeb/HTML/Canvas/CanvasTransform.h
+++ b/Libraries/LibWeb/HTML/Canvas/CanvasTransform.h
@@ -75,7 +75,7 @@ public:
     }
 
     // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-gettransform
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Geometry::DOMMatrix>> get_transform()
+    WebIDL::ExceptionOr<GC::Ref<Geometry::DOMMatrix>> get_transform()
     {
         auto& realm = static_cast<IncludingClass&>(*this).realm();
         auto transform = my_drawing_state().transform;
diff --git a/Libraries/LibWeb/HTML/CanvasGradient.cpp b/Libraries/LibWeb/HTML/CanvasGradient.cpp
index ec9eee1d129..d15f89dfd36 100644
--- a/Libraries/LibWeb/HTML/CanvasGradient.cpp
+++ b/Libraries/LibWeb/HTML/CanvasGradient.cpp
@@ -13,10 +13,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CanvasGradient);
+GC_DEFINE_ALLOCATOR(CanvasGradient);
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createradialgradient
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> CanvasGradient::create_radial(JS::Realm& realm, double x0, double y0, double r0, double x1, double y1, double r1)
+WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> CanvasGradient::create_radial(JS::Realm& realm, double x0, double y0, double r0, double x1, double y1, double r1)
 {
     // If either of r0 or r1 are negative, then an "IndexSizeError" DOMException must be thrown.
     if (r0 < 0)
@@ -29,14 +29,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> CanvasGradient::create_rad
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createlineargradient
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> CanvasGradient::create_linear(JS::Realm& realm, double x0, double y0, double x1, double y1)
+WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> CanvasGradient::create_linear(JS::Realm& realm, double x0, double y0, double x1, double y1)
 {
     auto linear_gradient = TRY_OR_THROW_OOM(realm.vm(), Gfx::CanvasLinearGradientPaintStyle::create(Gfx::FloatPoint { x0, y0 }, Gfx::FloatPoint { x1, y1 }));
     return realm.create<CanvasGradient>(realm, *linear_gradient);
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createconicgradient
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> CanvasGradient::create_conic(JS::Realm& realm, double start_angle, double x, double y)
+WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> CanvasGradient::create_conic(JS::Realm& realm, double start_angle, double x, double y)
 {
     auto conic_gradient = TRY_OR_THROW_OOM(realm.vm(), Gfx::CanvasConicGradientPaintStyle::create(Gfx::FloatPoint { x, y }, start_angle));
     return realm.create<CanvasGradient>(realm, *conic_gradient);
diff --git a/Libraries/LibWeb/HTML/CanvasGradient.h b/Libraries/LibWeb/HTML/CanvasGradient.h
index 55e100d3f9e..79f04bcfa92 100644
--- a/Libraries/LibWeb/HTML/CanvasGradient.h
+++ b/Libraries/LibWeb/HTML/CanvasGradient.h
@@ -14,12 +14,12 @@ namespace Web::HTML {
 
 class CanvasGradient final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CanvasGradient, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CanvasGradient);
+    GC_DECLARE_ALLOCATOR(CanvasGradient);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> create_radial(JS::Realm&, double x0, double y0, double r0, double x1, double y1, double r1);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> create_linear(JS::Realm&, double x0, double y0, double x1, double y1);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CanvasGradient>> create_conic(JS::Realm&, double start_angle, double x, double y);
+    static WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> create_radial(JS::Realm&, double x0, double y0, double r0, double x1, double y1, double r1);
+    static WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> create_linear(JS::Realm&, double x0, double y0, double x1, double y1);
+    static WebIDL::ExceptionOr<GC::Ref<CanvasGradient>> create_conic(JS::Realm&, double start_angle, double x, double y);
 
     WebIDL::ExceptionOr<void> add_color_stop(double offset, StringView color);
 
diff --git a/Libraries/LibWeb/HTML/CanvasPattern.cpp b/Libraries/LibWeb/HTML/CanvasPattern.cpp
index 2b67c5586d6..ea2e9967110 100644
--- a/Libraries/LibWeb/HTML/CanvasPattern.cpp
+++ b/Libraries/LibWeb/HTML/CanvasPattern.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CanvasPattern);
+GC_DEFINE_ALLOCATOR(CanvasPattern);
 
 void CanvasPatternPaintStyle::paint(Gfx::IntRect physical_bounding_box, PaintFunction paint) const
 {
@@ -93,7 +93,7 @@ CanvasPattern::CanvasPattern(JS::Realm& realm, CanvasPatternPaintStyle& pattern)
 CanvasPattern::~CanvasPattern() = default;
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createpattern
-WebIDL::ExceptionOr<JS::GCPtr<CanvasPattern>> CanvasPattern::create(JS::Realm& realm, CanvasImageSource const& image, StringView repetition)
+WebIDL::ExceptionOr<GC::Ptr<CanvasPattern>> CanvasPattern::create(JS::Realm& realm, CanvasImageSource const& image, StringView repetition)
 {
     auto parse_repetition = [&](auto repetition) -> Optional<CanvasPatternPaintStyle::Repetition> {
         if (repetition == "repeat"sv)
@@ -112,7 +112,7 @@ WebIDL::ExceptionOr<JS::GCPtr<CanvasPattern>> CanvasPattern::create(JS::Realm& r
 
     // 2. If usability is bad, then return null.
     if (usability == CanvasImageSourceUsability::Bad)
-        return JS::GCPtr<CanvasPattern> {};
+        return GC::Ptr<CanvasPattern> {};
 
     // 3. Assert: usability is good.
     VERIFY(usability == CanvasImageSourceUsability::Good);
@@ -129,11 +129,11 @@ WebIDL::ExceptionOr<JS::GCPtr<CanvasPattern>> CanvasPattern::create(JS::Realm& r
 
     // Note: Bitmap won't be null here, as if it were it would have "bad" usability.
     auto bitmap = image.visit(
-        [](JS::Handle<HTMLImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return source->immutable_bitmap(); },
-        [](JS::Handle<SVG::SVGImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return source->current_image_bitmap(); },
-        [](JS::Handle<HTMLCanvasElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create_snapshot_from_painting_surface(*source->surface()); },
-        [](JS::Handle<HTMLVideoElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); },
-        [](JS::Handle<ImageBitmap> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); });
+        [](GC::Root<HTMLImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return source->immutable_bitmap(); },
+        [](GC::Root<SVG::SVGImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return source->current_image_bitmap(); },
+        [](GC::Root<HTMLCanvasElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create_snapshot_from_painting_surface(*source->surface()); },
+        [](GC::Root<HTMLVideoElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); },
+        [](GC::Root<ImageBitmap> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); });
 
     // 6. Let pattern be a new CanvasPattern object with the image image and the repetition behavior given by repetition.
     auto pattern = TRY_OR_THROW_OOM(realm.vm(), CanvasPatternPaintStyle::create(*bitmap, *repetition_value));
diff --git a/Libraries/LibWeb/HTML/CanvasPattern.h b/Libraries/LibWeb/HTML/CanvasPattern.h
index c67f2ee91ac..bdba5dbf1aa 100644
--- a/Libraries/LibWeb/HTML/CanvasPattern.h
+++ b/Libraries/LibWeb/HTML/CanvasPattern.h
@@ -41,10 +41,10 @@ private:
 
 class CanvasPattern final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CanvasPattern, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CanvasPattern);
+    GC_DECLARE_ALLOCATOR(CanvasPattern);
 
 public:
-    static WebIDL::ExceptionOr<JS::GCPtr<CanvasPattern>> create(JS::Realm&, CanvasImageSource const& image, StringView repetition);
+    static WebIDL::ExceptionOr<GC::Ptr<CanvasPattern>> create(JS::Realm&, CanvasImageSource const& image, StringView repetition);
 
     ~CanvasPattern();
 
diff --git a/Libraries/LibWeb/HTML/CanvasRenderingContext2D.cpp b/Libraries/LibWeb/HTML/CanvasRenderingContext2D.cpp
index 64be502b023..c8e169f4d29 100644
--- a/Libraries/LibWeb/HTML/CanvasRenderingContext2D.cpp
+++ b/Libraries/LibWeb/HTML/CanvasRenderingContext2D.cpp
@@ -31,9 +31,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CanvasRenderingContext2D);
+GC_DEFINE_ALLOCATOR(CanvasRenderingContext2D);
 
-JS::NonnullGCPtr<CanvasRenderingContext2D> CanvasRenderingContext2D::create(JS::Realm& realm, HTMLCanvasElement& element)
+GC::Ref<CanvasRenderingContext2D> CanvasRenderingContext2D::create(JS::Realm& realm, HTMLCanvasElement& element)
 {
     return realm.create<CanvasRenderingContext2D>(realm, element);
 }
@@ -69,7 +69,7 @@ HTMLCanvasElement const& CanvasRenderingContext2D::canvas_element() const
     return *m_element;
 }
 
-JS::NonnullGCPtr<HTMLCanvasElement> CanvasRenderingContext2D::canvas_for_binding() const
+GC::Ref<HTMLCanvasElement> CanvasRenderingContext2D::canvas_for_binding() const
 {
     return *m_element;
 }
@@ -124,20 +124,20 @@ WebIDL::ExceptionOr<void> CanvasRenderingContext2D::draw_image_internal(CanvasIm
         return {};
 
     auto bitmap = image.visit(
-        [](JS::Handle<HTMLImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
+        [](GC::Root<HTMLImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
             return source->immutable_bitmap();
         },
-        [](JS::Handle<SVG::SVGImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
+        [](GC::Root<SVG::SVGImageElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
             return source->current_image_bitmap();
         },
-        [](JS::Handle<HTMLCanvasElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
+        [](GC::Root<HTMLCanvasElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
             auto surface = source->surface();
             if (!surface)
                 return {};
             return Gfx::ImmutableBitmap::create_snapshot_from_painting_surface(*surface);
         },
-        [](JS::Handle<HTMLVideoElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); },
-        [](JS::Handle<ImageBitmap> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
+        [](GC::Root<HTMLVideoElement> const& source) -> RefPtr<Gfx::ImmutableBitmap> { return Gfx::ImmutableBitmap::create(*source->bitmap()); },
+        [](GC::Root<ImageBitmap> const& source) -> RefPtr<Gfx::ImmutableBitmap> {
             return Gfx::ImmutableBitmap::create(*source->bitmap());
         });
     if (!bitmap)
@@ -346,7 +346,7 @@ void CanvasRenderingContext2D::fill(Path2D& path, StringView fill_rule)
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createimagedata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> CanvasRenderingContext2D::create_image_data(int width, int height, Optional<ImageDataSettings> const& settings) const
+WebIDL::ExceptionOr<GC::Ref<ImageData>> CanvasRenderingContext2D::create_image_data(int width, int height, Optional<ImageDataSettings> const& settings) const
 {
     // 1. If one or both of sw and sh are zero, then throw an "IndexSizeError" DOMException.
     if (width == 0 || height == 0)
@@ -367,7 +367,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> CanvasRenderingContext2D::creat
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createimagedata-imagedata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> CanvasRenderingContext2D::create_image_data(ImageData const& image_data) const
+WebIDL::ExceptionOr<GC::Ref<ImageData>> CanvasRenderingContext2D::create_image_data(ImageData const& image_data) const
 {
     // 1. Let newImageData be a new ImageData object.
     // 2. Initialize newImageData given the value of imagedata's width attribute, the value of imagedata's height attribute, and defaultColorSpace set to the value of imagedata's colorSpace attribute.
@@ -379,7 +379,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> CanvasRenderingContext2D::creat
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-getimagedata
-WebIDL::ExceptionOr<JS::GCPtr<ImageData>> CanvasRenderingContext2D::get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings) const
+WebIDL::ExceptionOr<GC::Ptr<ImageData>> CanvasRenderingContext2D::get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings) const
 {
     // 1. If either the sw or sh arguments are zero, then throw an "IndexSizeError" DOMException.
     if (width == 0 || height == 0)
@@ -464,7 +464,7 @@ void CanvasRenderingContext2D::reset_to_default_state()
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-measuretext
-JS::NonnullGCPtr<TextMetrics> CanvasRenderingContext2D::measure_text(StringView text)
+GC::Ref<TextMetrics> CanvasRenderingContext2D::measure_text(StringView text)
 {
     // The measureText(text) method steps are to run the text preparation
     // algorithm, passing it text and the object implementing the CanvasText
@@ -625,7 +625,7 @@ WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasI
     // 1. Switch on image:
     auto usability = TRY(image.visit(
         // HTMLOrSVGImageElement
-        [](JS::Handle<HTMLImageElement> const& image_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
+        [](GC::Root<HTMLImageElement> const& image_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
             // FIXME: If image's current request's state is broken, then throw an "InvalidStateError" DOMException.
 
             // If image is not fully decodable, then return bad.
@@ -638,7 +638,7 @@ WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasI
             return Optional<CanvasImageSourceUsability> {};
         },
         // FIXME: Don't duplicate this for HTMLImageElement and SVGImageElement.
-        [](JS::Handle<SVG::SVGImageElement> const& image_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
+        [](GC::Root<SVG::SVGImageElement> const& image_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
             // FIXME: If image's current request's state is broken, then throw an "InvalidStateError" DOMException.
 
             // If image is not fully decodable, then return bad.
@@ -651,7 +651,7 @@ WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasI
             return Optional<CanvasImageSourceUsability> {};
         },
 
-        [](JS::Handle<HTML::HTMLVideoElement> const& video_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
+        [](GC::Root<HTML::HTMLVideoElement> const& video_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
             // If image's readyState attribute is either HAVE_NOTHING or HAVE_METADATA, then return bad.
             if (video_element->ready_state() == HTML::HTMLMediaElement::ReadyState::HaveNothing || video_element->ready_state() == HTML::HTMLMediaElement::ReadyState::HaveMetadata) {
                 return { CanvasImageSourceUsability::Bad };
@@ -661,7 +661,7 @@ WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasI
 
         // HTMLCanvasElement
         // FIXME: OffscreenCanvas
-        [](JS::Handle<HTMLCanvasElement> const& canvas_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
+        [](GC::Root<HTMLCanvasElement> const& canvas_element) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
             // If image has either a horizontal dimension or a vertical dimension equal to zero, then throw an "InvalidStateError" DOMException.
             if (canvas_element->width() == 0 || canvas_element->height() == 0)
                 return WebIDL::InvalidStateError::create(canvas_element->realm(), "Canvas width or height is zero"_string);
@@ -670,7 +670,7 @@ WebIDL::ExceptionOr<CanvasImageSourceUsability> check_usability_of_image(CanvasI
 
         // ImageBitmap
         // FIXME: VideoFrame
-        [](JS::Handle<ImageBitmap> const& image_bitmap) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
+        [](GC::Root<ImageBitmap> const& image_bitmap) -> WebIDL::ExceptionOr<Optional<CanvasImageSourceUsability>> {
             if (image_bitmap->is_detached())
                 return WebIDL::InvalidStateError::create(image_bitmap->realm(), "Image bitmap is detached"_string);
             return Optional<CanvasImageSourceUsability> {};
@@ -688,20 +688,20 @@ bool image_is_not_origin_clean(CanvasImageSource const& image)
     // An object image is not origin-clean if, switching on image's type:
     return image.visit(
         // HTMLOrSVGImageElement
-        [](JS::Handle<HTMLImageElement> const&) {
+        [](GC::Root<HTMLImageElement> const&) {
             // FIXME: image's current request's image data is CORS-cross-origin.
             return false;
         },
-        [](JS::Handle<SVG::SVGImageElement> const&) {
+        [](GC::Root<SVG::SVGImageElement> const&) {
             // FIXME: image's current request's image data is CORS-cross-origin.
             return false;
         },
-        [](JS::Handle<HTML::HTMLVideoElement> const&) {
+        [](GC::Root<HTML::HTMLVideoElement> const&) {
             // FIXME: image's media data is CORS-cross-origin.
             return false;
         },
         // HTMLCanvasElement
-        [](OneOf<JS::Handle<HTMLCanvasElement>, JS::Handle<ImageBitmap>> auto const&) {
+        [](OneOf<GC::Root<HTMLCanvasElement>, GC::Root<ImageBitmap>> auto const&) {
             // FIXME: image's bitmap's origin-clean flag is false.
             return false;
         });
diff --git a/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h b/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h
index d39ebef8de0..52dfb48994b 100644
--- a/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h
+++ b/Libraries/LibWeb/HTML/CanvasRenderingContext2D.h
@@ -54,10 +54,10 @@ class CanvasRenderingContext2D
     , public CanvasTextDrawingStyles<CanvasRenderingContext2D> {
 
     WEB_PLATFORM_OBJECT(CanvasRenderingContext2D, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CanvasRenderingContext2D);
+    GC_DECLARE_ALLOCATOR(CanvasRenderingContext2D);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CanvasRenderingContext2D> create(JS::Realm&, HTMLCanvasElement&);
+    [[nodiscard]] static GC::Ref<CanvasRenderingContext2D> create(JS::Realm&, HTMLCanvasElement&);
     virtual ~CanvasRenderingContext2D() override;
 
     virtual void fill_rect(float x, float y, float width, float height) override;
@@ -76,16 +76,16 @@ public:
     virtual void fill(StringView fill_rule) override;
     virtual void fill(Path2D& path, StringView fill_rule) override;
 
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
-    virtual WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create_image_data(ImageData const& image_data) const override;
-    virtual WebIDL::ExceptionOr<JS::GCPtr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
+    virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
+    virtual WebIDL::ExceptionOr<GC::Ref<ImageData>> create_image_data(ImageData const& image_data) const override;
+    virtual WebIDL::ExceptionOr<GC::Ptr<ImageData>> get_image_data(int x, int y, int width, int height, Optional<ImageDataSettings> const& settings = {}) const override;
     virtual void put_image_data(ImageData const&, float x, float y) override;
 
     virtual void reset_to_default_state() override;
 
-    JS::NonnullGCPtr<HTMLCanvasElement> canvas_for_binding() const;
+    GC::Ref<HTMLCanvasElement> canvas_for_binding() const;
 
-    virtual JS::NonnullGCPtr<TextMetrics> measure_text(StringView text) override;
+    virtual GC::Ref<TextMetrics> measure_text(StringView text) override;
 
     virtual void clip(StringView fill_rule) override;
     virtual void clip(Path2D& path, StringView fill_rule) override;
@@ -143,7 +143,7 @@ private:
     void paint_shadow_for_fill_internal(Gfx::Path const&, Gfx::WindingRule);
     void paint_shadow_for_stroke_internal(Gfx::Path const&);
 
-    JS::NonnullGCPtr<HTMLCanvasElement> m_element;
+    GC::Ref<HTMLCanvasElement> m_element;
     OwnPtr<Gfx::Painter> m_painter;
 
     // https://html.spec.whatwg.org/multipage/canvas.html#concept-canvas-origin-clean
diff --git a/Libraries/LibWeb/HTML/CloseEvent.cpp b/Libraries/LibWeb/HTML/CloseEvent.cpp
index d3cabefb30c..52539532241 100644
--- a/Libraries/LibWeb/HTML/CloseEvent.cpp
+++ b/Libraries/LibWeb/HTML/CloseEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CloseEvent);
+GC_DEFINE_ALLOCATOR(CloseEvent);
 
-JS::NonnullGCPtr<CloseEvent> CloseEvent::create(JS::Realm& realm, FlyString const& event_name, CloseEventInit const& event_init)
+GC::Ref<CloseEvent> CloseEvent::create(JS::Realm& realm, FlyString const& event_name, CloseEventInit const& event_init)
 {
     return realm.create<CloseEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CloseEvent>> CloseEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CloseEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<CloseEvent>> CloseEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CloseEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/CloseEvent.h b/Libraries/LibWeb/HTML/CloseEvent.h
index 479ee682c24..e34f4f8053f 100644
--- a/Libraries/LibWeb/HTML/CloseEvent.h
+++ b/Libraries/LibWeb/HTML/CloseEvent.h
@@ -20,11 +20,11 @@ struct CloseEventInit : public DOM::EventInit {
 
 class CloseEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(CloseEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(CloseEvent);
+    GC_DECLARE_ALLOCATOR(CloseEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CloseEvent> create(JS::Realm&, FlyString const& event_name, CloseEventInit const& event_init = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CloseEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CloseEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<CloseEvent> create(JS::Realm&, FlyString const& event_name, CloseEventInit const& event_init = {});
+    static WebIDL::ExceptionOr<GC::Ref<CloseEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CloseEventInit const& event_init);
 
     virtual ~CloseEvent() override;
 
diff --git a/Libraries/LibWeb/HTML/CloseWatcher.cpp b/Libraries/LibWeb/HTML/CloseWatcher.cpp
index 07ade54086f..f162b8be3eb 100644
--- a/Libraries/LibWeb/HTML/CloseWatcher.cpp
+++ b/Libraries/LibWeb/HTML/CloseWatcher.cpp
@@ -18,10 +18,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CloseWatcher);
+GC_DEFINE_ALLOCATOR(CloseWatcher);
 
 // https://html.spec.whatwg.org/multipage/interaction.html#establish-a-close-watcher
-JS::NonnullGCPtr<CloseWatcher> CloseWatcher::establish(HTML::Window& window)
+GC::Ref<CloseWatcher> CloseWatcher::establish(HTML::Window& window)
 {
     // 1. Assert: window's associated Document is fully active.
     VERIFY(window.associated_document().is_fully_active());
@@ -40,7 +40,7 @@ JS::NonnullGCPtr<CloseWatcher> CloseWatcher::establish(HTML::Window& window)
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#dom-closewatcher
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CloseWatcher>> CloseWatcher::construct_impl(JS::Realm& realm, CloseWatcherOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<CloseWatcher>> CloseWatcher::construct_impl(JS::Realm& realm, CloseWatcherOptions const& options)
 {
     auto& window = verify_cast<HTML::Window>(realm.global_object());
 
diff --git a/Libraries/LibWeb/HTML/CloseWatcher.h b/Libraries/LibWeb/HTML/CloseWatcher.h
index 105acc72658..6a83d734c5a 100644
--- a/Libraries/LibWeb/HTML/CloseWatcher.h
+++ b/Libraries/LibWeb/HTML/CloseWatcher.h
@@ -13,17 +13,17 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/interaction.html#closewatcheroptions
 struct CloseWatcherOptions {
-    JS::GCPtr<DOM::AbortSignal> signal;
+    GC::Ptr<DOM::AbortSignal> signal;
 };
 
 // https://html.spec.whatwg.org/multipage/interaction.html#the-closewatcher-interface
 class CloseWatcher final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(CloseWatcher, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(CloseWatcher);
+    GC_DECLARE_ALLOCATOR(CloseWatcher);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CloseWatcher>> construct_impl(JS::Realm&, CloseWatcherOptions const& = {});
-    [[nodiscard]] static JS::NonnullGCPtr<CloseWatcher> establish(HTML::Window&);
+    static WebIDL::ExceptionOr<GC::Ref<CloseWatcher>> construct_impl(JS::Realm&, CloseWatcherOptions const& = {});
+    [[nodiscard]] static GC::Ref<CloseWatcher> establish(HTML::Window&);
 
     bool request_close();
     void close();
diff --git a/Libraries/LibWeb/HTML/CloseWatcherManager.cpp b/Libraries/LibWeb/HTML/CloseWatcherManager.cpp
index fc1285be3c4..dedb66a4623 100644
--- a/Libraries/LibWeb/HTML/CloseWatcherManager.cpp
+++ b/Libraries/LibWeb/HTML/CloseWatcherManager.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CloseWatcherManager);
+GC_DEFINE_ALLOCATOR(CloseWatcherManager);
 
-JS::NonnullGCPtr<CloseWatcherManager> CloseWatcherManager::create(JS::Realm& realm)
+GC::Ref<CloseWatcherManager> CloseWatcherManager::create(JS::Realm& realm)
 {
     return realm.create<CloseWatcherManager>(realm);
 }
@@ -26,12 +26,12 @@ CloseWatcherManager::CloseWatcherManager(JS::Realm& realm)
 {
 }
 
-void CloseWatcherManager::add(JS::NonnullGCPtr<CloseWatcher> close_watcher)
+void CloseWatcherManager::add(GC::Ref<CloseWatcher> close_watcher)
 {
     // If manager's groups's size is less than manager's allowed number of groups
     if (m_groups.size() < m_allowed_number_of_groups) {
         // then append « closeWatcher » to manager's groups.
-        JS::MarkedVector<JS::NonnullGCPtr<CloseWatcher>> new_group(realm().heap());
+        GC::MarkedVector<GC::Ref<CloseWatcher>> new_group(realm().heap());
         new_group.append(close_watcher);
         m_groups.append(move(new_group));
     } else {
@@ -49,7 +49,7 @@ void CloseWatcherManager::remove(CloseWatcher const& close_watcher)
 {
     // 2. For each group of manager's groups: remove closeWatcher from group
     for (auto& group : m_groups) {
-        group.remove_first_matching([&close_watcher](JS::NonnullGCPtr<CloseWatcher>& entry) {
+        group.remove_first_matching([&close_watcher](GC::Ref<CloseWatcher>& entry) {
             return entry.ptr() == &close_watcher;
         });
     }
@@ -68,7 +68,7 @@ bool CloseWatcherManager::process_close_watchers()
         auto& group = m_groups.last();
         // Ambiguous spec wording. We copy the groups to avoid modifying the original while iterating.
         // See https://github.com/whatwg/html/issues/10240
-        JS::MarkedVector<JS::NonnullGCPtr<CloseWatcher>> group_copy(realm().heap());
+        GC::MarkedVector<GC::Ref<CloseWatcher>> group_copy(realm().heap());
         group_copy.ensure_capacity(group.size());
         for (auto& close_watcher : group) {
             group_copy.append(close_watcher);
diff --git a/Libraries/LibWeb/HTML/CloseWatcherManager.h b/Libraries/LibWeb/HTML/CloseWatcherManager.h
index a08cdd96e61..318f786dcde 100644
--- a/Libraries/LibWeb/HTML/CloseWatcherManager.h
+++ b/Libraries/LibWeb/HTML/CloseWatcherManager.h
@@ -14,12 +14,12 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/interaction.html#close-watcher-manager
 class CloseWatcherManager final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CloseWatcherManager, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CloseWatcherManager);
+    GC_DECLARE_ALLOCATOR(CloseWatcherManager);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CloseWatcherManager> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<CloseWatcherManager> create(JS::Realm&);
 
-    void add(JS::NonnullGCPtr<CloseWatcher>);
+    void add(GC::Ref<CloseWatcher>);
     void remove(CloseWatcher const&);
 
     bool process_close_watchers();
@@ -32,7 +32,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<Vector<JS::NonnullGCPtr<CloseWatcher>>> m_groups;
+    Vector<Vector<GC::Ref<CloseWatcher>>> m_groups;
     uint32_t m_allowed_number_of_groups { 1 };
     bool m_next_user_interaction_allows_a_new_group { true };
 };
diff --git a/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.cpp b/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.cpp
index 795c2d9f59f..b1791c71e61 100644
--- a/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.cpp
+++ b/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.cpp
@@ -136,7 +136,7 @@ Optional<JS::PropertyDescriptor> cross_origin_get_own_property_helper(Variant<HT
             // 2. If IsCallable(value) is true, then set value to an anonymous built-in function, created in the current Realm Record, that performs the same steps as the IDL operation P on object O.
             if (value->is_function()) {
                 value = JS::NativeFunction::create(
-                    realm, [function = JS::make_handle(*value)](auto& vm) {
+                    realm, [function = GC::make_root(*value)](auto& vm) {
                         return JS::call(vm, function.value(), JS::js_undefined(), vm.running_execution_context().arguments.span());
                     },
                     0, "");
@@ -148,24 +148,24 @@ Optional<JS::PropertyDescriptor> cross_origin_get_own_property_helper(Variant<HT
         // 5. Otherwise:
         else {
             // 1. Let crossOriginGet be undefined.
-            Optional<JS::GCPtr<JS::FunctionObject>> cross_origin_get;
+            Optional<GC::Ptr<JS::FunctionObject>> cross_origin_get;
 
             // 2. If e.[[NeedsGet]] is true, then set crossOriginGet to an anonymous built-in function, created in the current Realm Record, that performs the same steps as the getter of the IDL attribute P on object O.
             if (*entry.needs_get) {
                 cross_origin_get = JS::NativeFunction::create(
-                    realm, [object_ptr, getter = JS::make_handle(*original_descriptor->get)](auto& vm) {
+                    realm, [object_ptr, getter = GC::make_root(*original_descriptor->get)](auto& vm) {
                         return JS::call(vm, getter.cell(), object_ptr, vm.running_execution_context().arguments.span());
                     },
                     0, "");
             }
 
             // 3. Let crossOriginSet be undefined.
-            Optional<JS::GCPtr<JS::FunctionObject>> cross_origin_set;
+            Optional<GC::Ptr<JS::FunctionObject>> cross_origin_set;
 
             // If e.[[NeedsSet]] is true, then set crossOriginSet to an anonymous built-in function, created in the current Realm Record, that performs the same steps as the setter of the IDL attribute P on object O.
             if (*entry.needs_set) {
                 cross_origin_set = JS::NativeFunction::create(
-                    realm, [object_ptr, setter = JS::make_handle(*original_descriptor->set)](auto& vm) {
+                    realm, [object_ptr, setter = GC::make_root(*original_descriptor->set)](auto& vm) {
                         return JS::call(vm, setter.cell(), object_ptr, vm.running_execution_context().arguments.span());
                     },
                     0, "");
@@ -237,13 +237,13 @@ JS::ThrowCompletionOr<bool> cross_origin_set(JS::VM& vm, JS::Object& object, JS:
 }
 
 // 7.2.3.7 CrossOriginOwnPropertyKeys ( O ), https://html.spec.whatwg.org/multipage/browsers.html#crossoriginownpropertykeys-(-o-)
-JS::MarkedVector<JS::Value> cross_origin_own_property_keys(Variant<HTML::Location const*, HTML::Window const*> const& object)
+GC::MarkedVector<JS::Value> cross_origin_own_property_keys(Variant<HTML::Location const*, HTML::Window const*> const& object)
 {
     auto& event_loop = HTML::main_thread_event_loop();
     auto& vm = event_loop.vm();
 
     // 1. Let keys be a new empty List.
-    auto keys = JS::MarkedVector<JS::Value> { vm.heap() };
+    auto keys = GC::MarkedVector<JS::Value> { vm.heap() };
 
     // 2. For each e of CrossOriginProperties(O), append e.[[Property]] to keys.
     for (auto& entry : cross_origin_properties(object))
diff --git a/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.h b/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.h
index 5a846c701eb..d2a60fcfc70 100644
--- a/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.h
+++ b/Libraries/LibWeb/HTML/CrossOrigin/AbstractOperations.h
@@ -21,6 +21,6 @@ bool is_platform_object_same_origin(JS::Object const&);
 Optional<JS::PropertyDescriptor> cross_origin_get_own_property_helper(Variant<HTML::Location*, HTML::Window*> const&, JS::PropertyKey const&);
 JS::ThrowCompletionOr<JS::Value> cross_origin_get(JS::VM&, JS::Object const&, JS::PropertyKey const&, JS::Value receiver);
 JS::ThrowCompletionOr<bool> cross_origin_set(JS::VM&, JS::Object&, JS::PropertyKey const&, JS::Value, JS::Value receiver);
-JS::MarkedVector<JS::Value> cross_origin_own_property_keys(Variant<HTML::Location const*, HTML::Window const*> const&);
+GC::MarkedVector<JS::Value> cross_origin_own_property_keys(Variant<HTML::Location const*, HTML::Window const*> const&);
 
 }
diff --git a/Libraries/LibWeb/HTML/CustomElements/CustomElementDefinition.h b/Libraries/LibWeb/HTML/CustomElements/CustomElementDefinition.h
index b7df4db234d..7af0a4a044c 100644
--- a/Libraries/LibWeb/HTML/CustomElements/CustomElementDefinition.h
+++ b/Libraries/LibWeb/HTML/CustomElements/CustomElementDefinition.h
@@ -17,13 +17,13 @@ struct AlreadyConstructedCustomElementMarker {
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#custom-element-definition
 class CustomElementDefinition : public JS::Cell {
-    JS_CELL(CustomElementDefinition, JS::Cell);
-    JS_DECLARE_ALLOCATOR(CustomElementDefinition);
+    GC_CELL(CustomElementDefinition, JS::Cell);
+    GC_DECLARE_ALLOCATOR(CustomElementDefinition);
 
-    using LifecycleCallbacksStorage = OrderedHashMap<FlyString, JS::GCPtr<WebIDL::CallbackType>>;
-    using ConstructionStackStorage = Vector<Variant<JS::Handle<DOM::Element>, AlreadyConstructedCustomElementMarker>>;
+    using LifecycleCallbacksStorage = OrderedHashMap<FlyString, GC::Ptr<WebIDL::CallbackType>>;
+    using ConstructionStackStorage = Vector<Variant<GC::Root<DOM::Element>, AlreadyConstructedCustomElementMarker>>;
 
-    static JS::NonnullGCPtr<CustomElementDefinition> create(JS::Realm& realm, String const& name, String const& local_name, WebIDL::CallbackType& constructor, Vector<String>&& observed_attributes, LifecycleCallbacksStorage&& lifecycle_callbacks, bool form_associated, bool disable_internals, bool disable_shadow)
+    static GC::Ref<CustomElementDefinition> create(JS::Realm& realm, String const& name, String const& local_name, WebIDL::CallbackType& constructor, Vector<String>&& observed_attributes, LifecycleCallbacksStorage&& lifecycle_callbacks, bool form_associated, bool disable_internals, bool disable_shadow)
     {
         return realm.create<CustomElementDefinition>(name, local_name, constructor, move(observed_attributes), move(lifecycle_callbacks), form_associated, disable_internals, disable_shadow);
     }
@@ -74,7 +74,7 @@ private:
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#concept-custom-element-definition-constructor
     // A Web IDL CustomElementConstructor callback function type value wrapping the custom element constructor
-    JS::NonnullGCPtr<WebIDL::CallbackType> m_constructor;
+    GC::Ref<WebIDL::CallbackType> m_constructor;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#concept-custom-element-definition-observed-attributes
     // A list of observed attributes
diff --git a/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.cpp b/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.cpp
index afbd051e82d..8aa4b4e1826 100644
--- a/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.cpp
+++ b/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.cpp
@@ -20,8 +20,8 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(CustomElementRegistry);
-JS_DEFINE_ALLOCATOR(CustomElementDefinition);
+GC_DEFINE_ALLOCATOR(CustomElementRegistry);
+GC_DEFINE_ALLOCATOR(CustomElementDefinition);
 
 CustomElementRegistry::CustomElementRegistry(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -44,7 +44,7 @@ void CustomElementRegistry::visit_edges(Visitor& visitor)
 }
 
 // https://webidl.spec.whatwg.org/#es-callback-function
-static JS::ThrowCompletionOr<JS::NonnullGCPtr<WebIDL::CallbackType>> convert_value_to_callback_function(JS::VM& vm, JS::Value value)
+static JS::ThrowCompletionOr<GC::Ref<WebIDL::CallbackType>> convert_value_to_callback_function(JS::VM& vm, JS::Value value)
 {
     // FIXME: De-duplicate this from the IDL generator.
     // 1. If the result of calling IsCallable(V) is false and the conversion to an IDL value is not being performed due to V being assigned to an attribute whose type is a nullable callback function that is annotated with [LegacyTreatNonObjectAsNull], then throw a TypeError.
@@ -288,7 +288,7 @@ JS::ThrowCompletionOr<void> CustomElementRegistry::define(String const& name, We
 
     // 18. Let upgrade candidates be all elements that are shadow-including descendants of document, whose namespace is the HTML namespace and whose local name is localName, in shadow-including tree order.
     //     Additionally, if extends is non-null, only include elements whose is value is equal to name.
-    Vector<JS::Handle<DOM::Element>> upgrade_candidates;
+    Vector<GC::Root<DOM::Element>> upgrade_candidates;
 
     document.for_each_shadow_including_descendant([&](DOM::Node& inclusive_descendant) {
         if (!is<DOM::Element>(inclusive_descendant))
@@ -297,7 +297,7 @@ JS::ThrowCompletionOr<void> CustomElementRegistry::define(String const& name, We
         auto& inclusive_descendant_element = static_cast<DOM::Element&>(inclusive_descendant);
 
         if (inclusive_descendant_element.namespace_uri() == Namespace::HTML && inclusive_descendant_element.local_name() == local_name && (!extends.has_value() || inclusive_descendant_element.is_value() == name))
-            upgrade_candidates.append(JS::make_handle(inclusive_descendant_element));
+            upgrade_candidates.append(GC::make_root(inclusive_descendant_element));
 
         return TraversalDecision::Continue;
     });
@@ -323,7 +323,7 @@ JS::ThrowCompletionOr<void> CustomElementRegistry::define(String const& name, We
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-get
-Variant<JS::Handle<WebIDL::CallbackType>, JS::Value> CustomElementRegistry::get(String const& name) const
+Variant<GC::Root<WebIDL::CallbackType>, JS::Value> CustomElementRegistry::get(String const& name) const
 {
     // 1. If this CustomElementRegistry contains an entry with name name, then return that entry's constructor.
     auto existing_definition_iterator = m_custom_element_definitions.find_if([&name](auto const& definition) {
@@ -331,14 +331,14 @@ Variant<JS::Handle<WebIDL::CallbackType>, JS::Value> CustomElementRegistry::get(
     });
 
     if (!existing_definition_iterator.is_end())
-        return JS::make_handle((*existing_definition_iterator)->constructor());
+        return GC::make_root((*existing_definition_iterator)->constructor());
 
     // 2. Otherwise, return undefined.
     return JS::js_undefined();
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-getname
-Optional<String> CustomElementRegistry::get_name(JS::Handle<WebIDL::CallbackType> const& constructor) const
+Optional<String> CustomElementRegistry::get_name(GC::Root<WebIDL::CallbackType> const& constructor) const
 {
     // 1. If this CustomElementRegistry contains an entry with constructor constructor, then return that entry's name.
     auto existing_definition_iterator = m_custom_element_definitions.find_if([&constructor](auto const& definition) {
@@ -353,7 +353,7 @@ Optional<String> CustomElementRegistry::get_name(JS::Handle<WebIDL::CallbackType
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-whendefined
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> CustomElementRegistry::when_defined(String const& name)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> CustomElementRegistry::when_defined(String const& name)
 {
     auto& realm = this->realm();
 
@@ -362,7 +362,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> CustomElementRegistry::wh
         return WebIDL::create_rejected_promise(realm, WebIDL::SyntaxError::create(realm, MUST(String::formatted("'{}' is not a valid custom element name"sv, name))));
 
     // 2. If this CustomElementRegistry contains an entry with name name, then return a new promise resolved with that entry's constructor.
-    auto existing_definition_iterator = m_custom_element_definitions.find_if([&name](JS::Handle<CustomElementDefinition> const& definition) {
+    auto existing_definition_iterator = m_custom_element_definitions.find_if([&name](GC::Root<CustomElementDefinition> const& definition) {
         return definition->name() == name;
     });
 
@@ -374,7 +374,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> CustomElementRegistry::wh
 
     // 4. If map does not contain an entry with key name, create an entry in map with key name and whose value is a new promise.
     // 5. Let promise be the value of the entry in map with key name.
-    JS::GCPtr<WebIDL::Promise> promise;
+    GC::Ptr<WebIDL::Promise> promise;
 
     auto existing_promise_iterator = m_when_defined_promise_map.find(name);
     if (existing_promise_iterator != m_when_defined_promise_map.end()) {
@@ -386,21 +386,21 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> CustomElementRegistry::wh
 
     // 5. Return promise.
     VERIFY(promise);
-    return JS::NonnullGCPtr { *promise };
+    return GC::Ref { *promise };
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-upgrade
-void CustomElementRegistry::upgrade(JS::NonnullGCPtr<DOM::Node> root) const
+void CustomElementRegistry::upgrade(GC::Ref<DOM::Node> root) const
 {
     // 1. Let candidates be a list of all of root's shadow-including inclusive descendant elements, in shadow-including tree order.
-    Vector<JS::Handle<DOM::Element>> candidates;
+    Vector<GC::Root<DOM::Element>> candidates;
 
     root->for_each_shadow_including_inclusive_descendant([&](DOM::Node& inclusive_descendant) {
         if (!is<DOM::Element>(inclusive_descendant))
             return TraversalDecision::Continue;
 
         auto& inclusive_descendant_element = static_cast<DOM::Element&>(inclusive_descendant);
-        candidates.append(JS::make_handle(inclusive_descendant_element));
+        candidates.append(GC::make_root(inclusive_descendant_element));
 
         return TraversalDecision::Continue;
     });
@@ -410,18 +410,18 @@ void CustomElementRegistry::upgrade(JS::NonnullGCPtr<DOM::Node> root) const
         candidate->try_to_upgrade();
 }
 
-JS::GCPtr<CustomElementDefinition> CustomElementRegistry::get_definition_with_name_and_local_name(String const& name, String const& local_name) const
+GC::Ptr<CustomElementDefinition> CustomElementRegistry::get_definition_with_name_and_local_name(String const& name, String const& local_name) const
 {
-    auto definition_iterator = m_custom_element_definitions.find_if([&](JS::Handle<CustomElementDefinition> const& definition) {
+    auto definition_iterator = m_custom_element_definitions.find_if([&](GC::Root<CustomElementDefinition> const& definition) {
         return definition->name() == name && definition->local_name() == local_name;
     });
 
     return definition_iterator.is_end() ? nullptr : definition_iterator->ptr();
 }
 
-JS::GCPtr<CustomElementDefinition> CustomElementRegistry::get_definition_from_new_target(JS::FunctionObject const& new_target) const
+GC::Ptr<CustomElementDefinition> CustomElementRegistry::get_definition_from_new_target(JS::FunctionObject const& new_target) const
 {
-    auto definition_iterator = m_custom_element_definitions.find_if([&](JS::Handle<CustomElementDefinition> const& definition) {
+    auto definition_iterator = m_custom_element_definitions.find_if([&](GC::Root<CustomElementDefinition> const& definition) {
         return definition->constructor().callback.ptr() == &new_target;
     });
 
diff --git a/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.h b/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.h
index a6fc34c68bf..464229ba79d 100644
--- a/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.h
+++ b/Libraries/LibWeb/HTML/CustomElements/CustomElementRegistry.h
@@ -19,19 +19,19 @@ struct ElementDefinitionOptions {
 // https://html.spec.whatwg.org/multipage/custom-elements.html#customelementregistry
 class CustomElementRegistry : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CustomElementRegistry, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CustomElementRegistry);
+    GC_DECLARE_ALLOCATOR(CustomElementRegistry);
 
 public:
     virtual ~CustomElementRegistry() override;
 
     JS::ThrowCompletionOr<void> define(String const& name, WebIDL::CallbackType* constructor, ElementDefinitionOptions options);
-    Variant<JS::Handle<WebIDL::CallbackType>, JS::Value> get(String const& name) const;
-    Optional<String> get_name(JS::Handle<WebIDL::CallbackType> const& constructor) const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> when_defined(String const& name);
-    void upgrade(JS::NonnullGCPtr<DOM::Node> root) const;
+    Variant<GC::Root<WebIDL::CallbackType>, JS::Value> get(String const& name) const;
+    Optional<String> get_name(GC::Root<WebIDL::CallbackType> const& constructor) const;
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> when_defined(String const& name);
+    void upgrade(GC::Ref<DOM::Node> root) const;
 
-    JS::GCPtr<CustomElementDefinition> get_definition_with_name_and_local_name(String const& name, String const& local_name) const;
-    JS::GCPtr<CustomElementDefinition> get_definition_from_new_target(JS::FunctionObject const& new_target) const;
+    GC::Ptr<CustomElementDefinition> get_definition_with_name_and_local_name(String const& name, String const& local_name) const;
+    GC::Ptr<CustomElementDefinition> get_definition_from_new_target(JS::FunctionObject const& new_target) const;
 
 private:
     CustomElementRegistry(JS::Realm&);
@@ -40,7 +40,7 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     // Every CustomElementRegistry has a set of custom element definitions, initially empty. In general, algorithms in this specification look up elements in the registry by any of name, local name, or constructor.
-    Vector<JS::NonnullGCPtr<CustomElementDefinition>> m_custom_element_definitions;
+    Vector<GC::Ref<CustomElementDefinition>> m_custom_element_definitions;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#element-definition-is-running
     // Every CustomElementRegistry also has an element definition is running flag which is used to prevent reentrant invocations of element definition. It is initially unset.
@@ -48,7 +48,7 @@ private:
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#when-defined-promise-map
     // Every CustomElementRegistry also has a when-defined promise map, mapping valid custom element names to promises. It is used to implement the whenDefined() method.
-    OrderedHashMap<String, JS::NonnullGCPtr<WebIDL::Promise>> m_when_defined_promise_map;
+    OrderedHashMap<String, GC::Ref<WebIDL::Promise>> m_when_defined_promise_map;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/DOMParser.cpp b/Libraries/LibWeb/HTML/DOMParser.cpp
index c9ca80a0121..83f502e0b2e 100644
--- a/Libraries/LibWeb/HTML/DOMParser.cpp
+++ b/Libraries/LibWeb/HTML/DOMParser.cpp
@@ -16,9 +16,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DOMParser);
+GC_DEFINE_ALLOCATOR(DOMParser);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMParser>> DOMParser::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<DOMParser>> DOMParser::construct_impl(JS::Realm& realm)
 {
     return realm.create<DOMParser>(realm);
 }
@@ -37,12 +37,12 @@ void DOMParser::initialize(JS::Realm& realm)
 }
 
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring
-JS::NonnullGCPtr<DOM::Document> DOMParser::parse_from_string(StringView string, Bindings::DOMParserSupportedType type)
+GC::Ref<DOM::Document> DOMParser::parse_from_string(StringView string, Bindings::DOMParserSupportedType type)
 {
     // FIXME: 1. Let compliantString to the result of invoking the Get Trusted Type compliant string algorithm with TrustedHTML, this's relevant global object, string, "DOMParser parseFromString", and "script".
 
     // 2. Let document be a new Document, whose content type is type and url is this's relevant global object's associated Document's URL.
-    JS::GCPtr<DOM::Document> document;
+    GC::Ptr<DOM::Document> document;
 
     // 3. Switch on type:
     if (type == Bindings::DOMParserSupportedType::Text_Html) {
diff --git a/Libraries/LibWeb/HTML/DOMParser.h b/Libraries/LibWeb/HTML/DOMParser.h
index 7bd2dc69dbd..7ef8ce9eab6 100644
--- a/Libraries/LibWeb/HTML/DOMParser.h
+++ b/Libraries/LibWeb/HTML/DOMParser.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/Forward.h>
@@ -17,14 +17,14 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparser
 class DOMParser final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMParser, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMParser);
+    GC_DECLARE_ALLOCATOR(DOMParser);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DOMParser>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<DOMParser>> construct_impl(JS::Realm&);
 
     virtual ~DOMParser() override;
 
-    JS::NonnullGCPtr<DOM::Document> parse_from_string(StringView, Bindings::DOMParserSupportedType type);
+    GC::Ref<DOM::Document> parse_from_string(StringView, Bindings::DOMParserSupportedType type);
 
 private:
     explicit DOMParser(JS::Realm&);
diff --git a/Libraries/LibWeb/HTML/DOMStringList.cpp b/Libraries/LibWeb/HTML/DOMStringList.cpp
index 49a42cd3080..ba112438e6d 100644
--- a/Libraries/LibWeb/HTML/DOMStringList.cpp
+++ b/Libraries/LibWeb/HTML/DOMStringList.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DOMStringList);
+GC_DEFINE_ALLOCATOR(DOMStringList);
 
-JS::NonnullGCPtr<DOMStringList> DOMStringList::create(JS::Realm& realm, Vector<String> list)
+GC::Ref<DOMStringList> DOMStringList::create(JS::Realm& realm, Vector<String> list)
 {
     return realm.create<DOMStringList>(realm, list);
 }
diff --git a/Libraries/LibWeb/HTML/DOMStringList.h b/Libraries/LibWeb/HTML/DOMStringList.h
index 38551d7b3a7..1afd6b72a36 100644
--- a/Libraries/LibWeb/HTML/DOMStringList.h
+++ b/Libraries/LibWeb/HTML/DOMStringList.h
@@ -13,10 +13,10 @@ namespace Web::HTML {
 
 class DOMStringList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMStringList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMStringList);
+    GC_DECLARE_ALLOCATOR(DOMStringList);
 
 public:
-    static JS::NonnullGCPtr<DOMStringList> create(JS::Realm&, Vector<String>);
+    static GC::Ref<DOMStringList> create(JS::Realm&, Vector<String>);
 
     u32 length() const;
     Optional<String> item(u32 index) const;
diff --git a/Libraries/LibWeb/HTML/DOMStringMap.cpp b/Libraries/LibWeb/HTML/DOMStringMap.cpp
index f2a045f3326..bdf641de153 100644
--- a/Libraries/LibWeb/HTML/DOMStringMap.cpp
+++ b/Libraries/LibWeb/HTML/DOMStringMap.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DOMStringMap);
+GC_DEFINE_ALLOCATOR(DOMStringMap);
 
-JS::NonnullGCPtr<DOMStringMap> DOMStringMap::create(DOM::Element& element)
+GC::Ref<DOMStringMap> DOMStringMap::create(DOM::Element& element)
 {
     auto& realm = element.realm();
     return realm.create<DOMStringMap>(element);
diff --git a/Libraries/LibWeb/HTML/DOMStringMap.h b/Libraries/LibWeb/HTML/DOMStringMap.h
index 4e0146da31f..1bf01ad27b9 100644
--- a/Libraries/LibWeb/HTML/DOMStringMap.h
+++ b/Libraries/LibWeb/HTML/DOMStringMap.h
@@ -15,10 +15,10 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/dom.html#domstringmap
 class DOMStringMap final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMStringMap, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMStringMap);
+    GC_DECLARE_ALLOCATOR(DOMStringMap);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DOMStringMap> create(DOM::Element&);
+    [[nodiscard]] static GC::Ref<DOMStringMap> create(DOM::Element&);
 
     virtual ~DOMStringMap() override;
 
@@ -47,7 +47,7 @@ private:
     Vector<NameValuePair> get_name_value_pairs() const;
 
     // https://html.spec.whatwg.org/multipage/dom.html#concept-domstringmap-element
-    JS::NonnullGCPtr<DOM::Element> m_associated_element;
+    GC::Ref<DOM::Element> m_associated_element;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/DataTransfer.cpp b/Libraries/LibWeb/HTML/DataTransfer.cpp
index 27c48ac51c4..ca731ed030e 100644
--- a/Libraries/LibWeb/HTML/DataTransfer.cpp
+++ b/Libraries/LibWeb/HTML/DataTransfer.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DataTransfer);
+GC_DEFINE_ALLOCATOR(DataTransfer);
 
 namespace DataTransferEffect {
 
@@ -29,13 +29,13 @@ ENUMERATE_DATA_TRANSFER_EFFECTS
 
 }
 
-JS::NonnullGCPtr<DataTransfer> DataTransfer::create(JS::Realm& realm, NonnullRefPtr<DragDataStore> drag_data_store)
+GC::Ref<DataTransfer> DataTransfer::create(JS::Realm& realm, NonnullRefPtr<DragDataStore> drag_data_store)
 {
     return realm.create<DataTransfer>(realm, move(drag_data_store));
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer
-JS::NonnullGCPtr<DataTransfer> DataTransfer::construct_impl(JS::Realm& realm)
+GC::Ref<DataTransfer> DataTransfer::construct_impl(JS::Realm& realm)
 {
     // 1. Set the drag data store's item list to be an empty list.
     auto drag_data_store = DragDataStore::create();
@@ -115,7 +115,7 @@ void DataTransfer::set_effect_allowed_internal(FlyString effect_allowed)
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer-items
-JS::NonnullGCPtr<DataTransferItemList> DataTransfer::items()
+GC::Ref<DataTransferItemList> DataTransfer::items()
 {
     // The items attribute must return a DataTransferItemList object associated with the DataTransfer object.
     if (!m_items)
@@ -181,7 +181,7 @@ String DataTransfer::get_data(String const& format_argument) const
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer-files
-JS::NonnullGCPtr<FileAPI::FileList> DataTransfer::files() const
+GC::Ref<FileAPI::FileList> DataTransfer::files() const
 {
     auto& realm = this->realm();
 
@@ -212,7 +212,7 @@ JS::NonnullGCPtr<FileAPI::FileList> DataTransfer::files() const
         FileAPI::FilePropertyBag options {};
         options.type = item.type_string;
 
-        auto file = MUST(FileAPI::File::create(realm, { JS::make_handle(blob) }, file_name, move(options)));
+        auto file = MUST(FileAPI::File::create(realm, { GC::make_root(blob) }, file_name, move(options)));
         files->add_file(file);
     }
 
@@ -233,7 +233,7 @@ void DataTransfer::disassociate_with_drag_data_store()
     update_data_transfer_types_list();
 }
 
-JS::NonnullGCPtr<DataTransferItem> DataTransfer::add_item(DragDataStoreItem item)
+GC::Ref<DataTransferItem> DataTransfer::add_item(DragDataStoreItem item)
 {
     auto& realm = this->realm();
 
@@ -260,7 +260,7 @@ bool DataTransfer::contains_item_with_type(DragDataStoreItem::Kind kind, String
     return false;
 }
 
-JS::NonnullGCPtr<DataTransferItem> DataTransfer::item(size_t index) const
+GC::Ref<DataTransferItem> DataTransfer::item(size_t index) const
 {
     VERIFY(index < m_item_list.size());
     return m_item_list[index];
diff --git a/Libraries/LibWeb/HTML/DataTransfer.h b/Libraries/LibWeb/HTML/DataTransfer.h
index 950b695cadb..6972f6a520b 100644
--- a/Libraries/LibWeb/HTML/DataTransfer.h
+++ b/Libraries/LibWeb/HTML/DataTransfer.h
@@ -34,11 +34,11 @@ ENUMERATE_DATA_TRANSFER_EFFECTS
 // https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface
 class DataTransfer : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DataTransfer, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DataTransfer);
+    GC_DECLARE_ALLOCATOR(DataTransfer);
 
 public:
-    static JS::NonnullGCPtr<DataTransfer> create(JS::Realm&, NonnullRefPtr<DragDataStore>);
-    static JS::NonnullGCPtr<DataTransfer> construct_impl(JS::Realm&);
+    static GC::Ref<DataTransfer> create(JS::Realm&, NonnullRefPtr<DragDataStore>);
+    static GC::Ref<DataTransfer> construct_impl(JS::Realm&);
     virtual ~DataTransfer() override;
 
     FlyString const& drop_effect() const { return m_drop_effect; }
@@ -50,18 +50,18 @@ public:
     void set_effect_allowed(FlyString);
     void set_effect_allowed_internal(FlyString);
 
-    JS::NonnullGCPtr<DataTransferItemList> items();
+    GC::Ref<DataTransferItemList> items();
 
     ReadonlySpan<String> types() const;
     String get_data(String const& format) const;
-    JS::NonnullGCPtr<FileAPI::FileList> files() const;
+    GC::Ref<FileAPI::FileList> files() const;
 
     Optional<DragDataStore::Mode> mode() const;
     void disassociate_with_drag_data_store();
 
-    JS::NonnullGCPtr<DataTransferItem> add_item(DragDataStoreItem item);
+    GC::Ref<DataTransferItem> add_item(DragDataStoreItem item);
     bool contains_item_with_type(DragDataStoreItem::Kind, String const& type) const;
-    JS::NonnullGCPtr<DataTransferItem> item(size_t index) const;
+    GC::Ref<DataTransferItem> item(size_t index) const;
     DragDataStoreItem const& drag_data(size_t index) const;
     size_t length() const;
 
@@ -80,8 +80,8 @@ private:
     FlyString m_effect_allowed { DataTransferEffect::none };
 
     // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer-items
-    JS::GCPtr<DataTransferItemList> m_items;
-    Vector<JS::NonnullGCPtr<DataTransferItem>> m_item_list;
+    GC::Ptr<DataTransferItemList> m_items;
+    Vector<GC::Ref<DataTransferItem>> m_item_list;
 
     // https://html.spec.whatwg.org/multipage/dnd.html#concept-datatransfer-types
     Vector<String> m_types;
diff --git a/Libraries/LibWeb/HTML/DataTransferItem.cpp b/Libraries/LibWeb/HTML/DataTransferItem.cpp
index 56b8f1c4f84..27395435606 100644
--- a/Libraries/LibWeb/HTML/DataTransferItem.cpp
+++ b/Libraries/LibWeb/HTML/DataTransferItem.cpp
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/DataTransferItemPrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
@@ -17,14 +17,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DataTransferItem);
+GC_DEFINE_ALLOCATOR(DataTransferItem);
 
-JS::NonnullGCPtr<DataTransferItem> DataTransferItem::create(JS::Realm& realm, JS::NonnullGCPtr<DataTransfer> data_transfer, size_t item_index)
+GC::Ref<DataTransferItem> DataTransferItem::create(JS::Realm& realm, GC::Ref<DataTransfer> data_transfer, size_t item_index)
 {
     return realm.create<DataTransferItem>(realm, data_transfer, item_index);
 }
 
-DataTransferItem::DataTransferItem(JS::Realm& realm, JS::NonnullGCPtr<DataTransfer> data_transfer, size_t item_index)
+DataTransferItem::DataTransferItem(JS::Realm& realm, GC::Ref<DataTransfer> data_transfer, size_t item_index)
     : PlatformObject(realm)
     , m_data_transfer(data_transfer)
     , m_item_index(item_index)
@@ -91,7 +91,7 @@ Optional<DragDataStore::Mode> DataTransferItem::mode() const
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransferitem-getasstring
-void DataTransferItem::get_as_string(JS::GCPtr<WebIDL::CallbackType> callback) const
+void DataTransferItem::get_as_string(GC::Ptr<WebIDL::CallbackType> callback) const
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
@@ -116,13 +116,13 @@ void DataTransferItem::get_as_string(JS::GCPtr<WebIDL::CallbackType> callback) c
     auto data = JS::PrimitiveString::create(vm, MUST(String::from_utf8({ item.data })));
 
     HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr,
-        JS::HeapFunction<void()>::create(realm.heap(), [callback, data]() {
+        GC::Function<void()>::create(realm.heap(), [callback, data]() {
             (void)WebIDL::invoke_callback(*callback, {}, data);
         }));
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransferitem-getasfile
-JS::GCPtr<FileAPI::File> DataTransferItem::get_as_file() const
+GC::Ptr<FileAPI::File> DataTransferItem::get_as_file() const
 {
     auto& realm = this->realm();
 
@@ -146,11 +146,11 @@ JS::GCPtr<FileAPI::File> DataTransferItem::get_as_file() const
     FileAPI::FilePropertyBag options {};
     options.type = item.type_string;
 
-    return MUST(FileAPI::File::create(realm, { JS::make_handle(blob) }, file_name, move(options)));
+    return MUST(FileAPI::File::create(realm, { GC::make_root(blob) }, file_name, move(options)));
 }
 
 // https://wicg.github.io/entries-api/#dom-datatransferitem-webkitgetasentry
-JS::GCPtr<EntriesAPI::FileSystemEntry> DataTransferItem::webkit_get_as_entry() const
+GC::Ptr<EntriesAPI::FileSystemEntry> DataTransferItem::webkit_get_as_entry() const
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/HTML/DataTransferItem.h b/Libraries/LibWeb/HTML/DataTransferItem.h
index a536d3bfec6..149b234eb0f 100644
--- a/Libraries/LibWeb/HTML/DataTransferItem.h
+++ b/Libraries/LibWeb/HTML/DataTransferItem.h
@@ -17,29 +17,29 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/dnd.html#the-datatransferitem-interface
 class DataTransferItem : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DataTransferItem, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DataTransferItem);
+    GC_DECLARE_ALLOCATOR(DataTransferItem);
 
 public:
-    static JS::NonnullGCPtr<DataTransferItem> create(JS::Realm&, JS::NonnullGCPtr<DataTransfer>, size_t item_index);
+    static GC::Ref<DataTransferItem> create(JS::Realm&, GC::Ref<DataTransfer>, size_t item_index);
     virtual ~DataTransferItem() override;
 
     String kind() const;
     String type() const;
 
-    void get_as_string(JS::GCPtr<WebIDL::CallbackType>) const;
-    JS::GCPtr<FileAPI::File> get_as_file() const;
+    void get_as_string(GC::Ptr<WebIDL::CallbackType>) const;
+    GC::Ptr<FileAPI::File> get_as_file() const;
 
-    JS::GCPtr<EntriesAPI::FileSystemEntry> webkit_get_as_entry() const;
+    GC::Ptr<EntriesAPI::FileSystemEntry> webkit_get_as_entry() const;
 
 private:
-    DataTransferItem(JS::Realm&, JS::NonnullGCPtr<DataTransfer>, size_t item_index);
+    DataTransferItem(JS::Realm&, GC::Ref<DataTransfer>, size_t item_index);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     Optional<DragDataStore::Mode> mode() const;
 
-    JS::NonnullGCPtr<DataTransfer> m_data_transfer;
+    GC::Ref<DataTransfer> m_data_transfer;
     Optional<size_t> m_item_index;
 };
 
diff --git a/Libraries/LibWeb/HTML/DataTransferItemList.cpp b/Libraries/LibWeb/HTML/DataTransferItemList.cpp
index 037d8d02d79..55c574809a2 100644
--- a/Libraries/LibWeb/HTML/DataTransferItemList.cpp
+++ b/Libraries/LibWeb/HTML/DataTransferItemList.cpp
@@ -15,14 +15,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DataTransferItemList);
+GC_DEFINE_ALLOCATOR(DataTransferItemList);
 
-JS::NonnullGCPtr<DataTransferItemList> DataTransferItemList::create(JS::Realm& realm, JS::NonnullGCPtr<DataTransfer> data_transfer)
+GC::Ref<DataTransferItemList> DataTransferItemList::create(JS::Realm& realm, GC::Ref<DataTransfer> data_transfer)
 {
     return realm.create<DataTransferItemList>(realm, data_transfer);
 }
 
-DataTransferItemList::DataTransferItemList(JS::Realm& realm, JS::NonnullGCPtr<DataTransfer> data_transfer)
+DataTransferItemList::DataTransferItemList(JS::Realm& realm, GC::Ref<DataTransfer> data_transfer)
     : PlatformObject(realm)
     , m_data_transfer(data_transfer)
 {
@@ -52,7 +52,7 @@ WebIDL::UnsignedLong DataTransferItemList::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransferitemlist-add
-WebIDL::ExceptionOr<JS::GCPtr<DataTransferItem>> DataTransferItemList::add(String const& data, String const& type)
+WebIDL::ExceptionOr<GC::Ptr<DataTransferItem>> DataTransferItemList::add(String const& data, String const& type)
 {
     auto& realm = this->realm();
 
@@ -87,7 +87,7 @@ WebIDL::ExceptionOr<JS::GCPtr<DataTransferItem>> DataTransferItemList::add(Strin
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransferitemlist-add
-JS::GCPtr<DataTransferItem> DataTransferItemList::add(JS::NonnullGCPtr<FileAPI::File> file)
+GC::Ptr<DataTransferItem> DataTransferItemList::add(GC::Ref<FileAPI::File> file)
 {
     // 1. If the DataTransferItemList object is not in the read/write mode, return null.
     if (m_data_transfer->mode() != DragDataStore::Mode::ReadWrite)
diff --git a/Libraries/LibWeb/HTML/DataTransferItemList.h b/Libraries/LibWeb/HTML/DataTransferItemList.h
index d1a6d39a6ad..a6e9872e212 100644
--- a/Libraries/LibWeb/HTML/DataTransferItemList.h
+++ b/Libraries/LibWeb/HTML/DataTransferItemList.h
@@ -16,26 +16,26 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/dnd.html#the-datatransferitemlist-interface
 class DataTransferItemList : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DataTransferItemList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DataTransferItemList);
+    GC_DECLARE_ALLOCATOR(DataTransferItemList);
 
 public:
-    static JS::NonnullGCPtr<DataTransferItemList> create(JS::Realm&, JS::NonnullGCPtr<DataTransfer>);
+    static GC::Ref<DataTransferItemList> create(JS::Realm&, GC::Ref<DataTransfer>);
     virtual ~DataTransferItemList() override;
 
     WebIDL::UnsignedLong length() const;
 
-    WebIDL::ExceptionOr<JS::GCPtr<DataTransferItem>> add(String const& data, String const& type);
-    JS::GCPtr<DataTransferItem> add(JS::NonnullGCPtr<FileAPI::File>);
+    WebIDL::ExceptionOr<GC::Ptr<DataTransferItem>> add(String const& data, String const& type);
+    GC::Ptr<DataTransferItem> add(GC::Ref<FileAPI::File>);
 
 private:
-    DataTransferItemList(JS::Realm&, JS::NonnullGCPtr<DataTransfer>);
+    DataTransferItemList(JS::Realm&, GC::Ref<DataTransfer>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     virtual Optional<JS::Value> item_value(size_t index) const override;
 
-    JS::NonnullGCPtr<DataTransfer> m_data_transfer;
+    GC::Ref<DataTransfer> m_data_transfer;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Dates.cpp b/Libraries/LibWeb/HTML/Dates.cpp
index 75f3291c5eb..70ca3b58730 100644
--- a/Libraries/LibWeb/HTML/Dates.cpp
+++ b/Libraries/LibWeb/HTML/Dates.cpp
@@ -129,7 +129,7 @@ bool is_valid_date_string(StringView value)
 }
 
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-date-string
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Date>> parse_date_string(JS::Realm& realm, StringView value)
+WebIDL::ExceptionOr<GC::Ref<JS::Date>> parse_date_string(JS::Realm& realm, StringView value)
 {
     // FIXME: Implement spec compliant date string parsing
     auto parts = value.split_view('-', SplitBehavior::KeepEmpty);
@@ -225,7 +225,7 @@ bool is_valid_time_string(StringView value)
 }
 
 // https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#parse-a-time-string
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Date>> parse_time_string(JS::Realm& realm, StringView value)
+WebIDL::ExceptionOr<GC::Ref<JS::Date>> parse_time_string(JS::Realm& realm, StringView value)
 {
     // FIXME: Implement spec compliant time string parsing
     auto parts = value.split_view(':', SplitBehavior::KeepEmpty);
diff --git a/Libraries/LibWeb/HTML/Dates.h b/Libraries/LibWeb/HTML/Dates.h
index fc3403ea56f..170cdb7441f 100644
--- a/Libraries/LibWeb/HTML/Dates.h
+++ b/Libraries/LibWeb/HTML/Dates.h
@@ -17,10 +17,10 @@ u32 week_number_of_the_last_day(u64 year);
 bool is_valid_week_string(StringView value);
 bool is_valid_month_string(StringView value);
 bool is_valid_date_string(StringView value);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Date>> parse_date_string(JS::Realm& realm, StringView value);
+WebIDL::ExceptionOr<GC::Ref<JS::Date>> parse_date_string(JS::Realm& realm, StringView value);
 bool is_valid_local_date_and_time_string(StringView value);
 String normalize_local_date_and_time_string(String const& value);
 bool is_valid_time_string(StringView value);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Date>> parse_time_string(JS::Realm& realm, StringView value);
+WebIDL::ExceptionOr<GC::Ref<JS::Date>> parse_time_string(JS::Realm& realm, StringView value);
 
 }
diff --git a/Libraries/LibWeb/HTML/DecodedImageData.h b/Libraries/LibWeb/HTML/DecodedImageData.h
index d4bfff6d9a7..dd09c2981f3 100644
--- a/Libraries/LibWeb/HTML/DecodedImageData.h
+++ b/Libraries/LibWeb/HTML/DecodedImageData.h
@@ -15,7 +15,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/images.html#img-req-data
 class DecodedImageData : public JS::Cell {
-    JS_CELL(DecodedImageData, JS::Cell);
+    GC_CELL(DecodedImageData, JS::Cell);
 
 public:
     virtual ~DecodedImageData();
diff --git a/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.cpp b/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.cpp
index d8189d32c48..e1ce50677fd 100644
--- a/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.cpp
+++ b/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DedicatedWorkerGlobalScope);
+GC_DEFINE_ALLOCATOR(DedicatedWorkerGlobalScope);
 
-DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(JS::Realm& realm, JS::NonnullGCPtr<Web::Page> page)
+DedicatedWorkerGlobalScope::DedicatedWorkerGlobalScope(JS::Realm& realm, GC::Ref<Web::Page> page)
     : WorkerGlobalScope(realm, page)
 {
     m_legacy_platform_object_flags = LegacyPlatformObjectFlags { .has_global_interface_extended_attribute = true };
@@ -58,7 +58,7 @@ WebIDL::ExceptionOr<void> DedicatedWorkerGlobalScope::post_message(JS::Value mes
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-dedicatedworkerglobalscope-postmessage
-WebIDL::ExceptionOr<void> DedicatedWorkerGlobalScope::post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer)
+WebIDL::ExceptionOr<void> DedicatedWorkerGlobalScope::post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer)
 {
     // The postMessage(message, transfer) and postMessage(message, options) methods on DedicatedWorkerGlobalScope objects act as if,
     // when invoked, it immediately invoked the respective postMessage(message, transfer) and postMessage(message, options)
diff --git a/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.h b/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.h
index 438a11b2f68..f6548ddd681 100644
--- a/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.h
+++ b/Libraries/LibWeb/HTML/DedicatedWorkerGlobalScope.h
@@ -20,13 +20,13 @@ class DedicatedWorkerGlobalScope
     : public WorkerGlobalScope
     , public Bindings::DedicatedWorkerGlobalScopeGlobalMixin {
     WEB_PLATFORM_OBJECT(DedicatedWorkerGlobalScope, WorkerGlobalScope);
-    JS_DECLARE_ALLOCATOR(DedicatedWorkerGlobalScope);
+    GC_DECLARE_ALLOCATOR(DedicatedWorkerGlobalScope);
 
 public:
     virtual ~DedicatedWorkerGlobalScope() override;
 
     WebIDL::ExceptionOr<void> post_message(JS::Value message, StructuredSerializeOptions const&);
-    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer);
+    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer);
 
     void set_name(String name) { m_name = move(name); }
     String name() const { return m_name; }
@@ -43,7 +43,7 @@ public:
     virtual void finalize() override;
 
 private:
-    DedicatedWorkerGlobalScope(JS::Realm&, JS::NonnullGCPtr<Web::Page>);
+    DedicatedWorkerGlobalScope(JS::Realm&, GC::Ref<Web::Page>);
 
     virtual void initialize_web_interfaces_impl() override;
 
diff --git a/Libraries/LibWeb/HTML/DocumentState.cpp b/Libraries/LibWeb/HTML/DocumentState.cpp
index 8ed1dbd82c3..4e50c2f4b92 100644
--- a/Libraries/LibWeb/HTML/DocumentState.cpp
+++ b/Libraries/LibWeb/HTML/DocumentState.cpp
@@ -10,15 +10,15 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DocumentState);
+GC_DEFINE_ALLOCATOR(DocumentState);
 
 DocumentState::DocumentState() = default;
 
 DocumentState::~DocumentState() = default;
 
-JS::NonnullGCPtr<DocumentState> DocumentState::clone() const
+GC::Ref<DocumentState> DocumentState::clone() const
 {
-    JS::NonnullGCPtr<DocumentState> cloned = *heap().allocate<DocumentState>();
+    GC::Ref<DocumentState> cloned = *heap().allocate<DocumentState>();
     cloned->m_document = m_document;
     cloned->m_history_policy_container = m_history_policy_container;
     cloned->m_request_referrer = m_request_referrer;
diff --git a/Libraries/LibWeb/HTML/DocumentState.h b/Libraries/LibWeb/HTML/DocumentState.h
index a1d6798f730..04477379dba 100644
--- a/Libraries/LibWeb/HTML/DocumentState.h
+++ b/Libraries/LibWeb/HTML/DocumentState.h
@@ -20,25 +20,25 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#document-state-2
 class DocumentState final : public JS::Cell {
-    JS_CELL(DocumentState, JS::Cell);
-    JS_DECLARE_ALLOCATOR(DocumentState);
+    GC_CELL(DocumentState, JS::Cell);
+    GC_DECLARE_ALLOCATOR(DocumentState);
 
 public:
     struct NestedHistory {
         String id;
-        Vector<JS::NonnullGCPtr<SessionHistoryEntry>> entries;
+        Vector<GC::Ref<SessionHistoryEntry>> entries;
     };
 
     virtual ~DocumentState();
 
-    JS::NonnullGCPtr<DocumentState> clone() const;
+    GC::Ref<DocumentState> clone() const;
 
     enum class Client {
         Tag,
     };
 
-    [[nodiscard]] JS::GCPtr<DOM::Document> document() const { return m_document; }
-    void set_document(JS::GCPtr<DOM::Document> document) { m_document = document; }
+    [[nodiscard]] GC::Ptr<DOM::Document> document() const { return m_document; }
+    void set_document(GC::Ptr<DOM::Document> document) { m_document = document; }
 
     [[nodiscard]] Variant<PolicyContainer, Client> history_policy_container() const { return m_history_policy_container; }
     void set_history_policy_container(Variant<PolicyContainer, Client> history_policy_container) { m_history_policy_container = move(history_policy_container); }
@@ -79,7 +79,7 @@ private:
     void visit_edges(Cell::Visitor&) override;
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#document-state-document
-    JS::GCPtr<DOM::Document> m_document;
+    GC::Ptr<DOM::Document> m_document;
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#document-state-history-policy-container
     Variant<PolicyContainer, Client> m_history_policy_container { Client::Tag };
diff --git a/Libraries/LibWeb/HTML/DragEvent.cpp b/Libraries/LibWeb/HTML/DragEvent.cpp
index 1b79e2cc647..dde9404a1ad 100644
--- a/Libraries/LibWeb/HTML/DragEvent.cpp
+++ b/Libraries/LibWeb/HTML/DragEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(DragEvent);
+GC_DEFINE_ALLOCATOR(DragEvent);
 
-JS::NonnullGCPtr<DragEvent> DragEvent::create(JS::Realm& realm, FlyString const& event_name, DragEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
+GC::Ref<DragEvent> DragEvent::create(JS::Realm& realm, FlyString const& event_name, DragEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
 {
     return realm.create<DragEvent>(realm, event_name, event_init, page_x, page_y, offset_x, offset_y);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DragEvent>> DragEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, DragEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<DragEvent>> DragEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, DragEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/DragEvent.h b/Libraries/LibWeb/HTML/DragEvent.h
index ec48373cdff..8db7fd0ba11 100644
--- a/Libraries/LibWeb/HTML/DragEvent.h
+++ b/Libraries/LibWeb/HTML/DragEvent.h
@@ -14,21 +14,21 @@
 namespace Web::HTML {
 
 struct DragEventInit : public UIEvents::MouseEventInit {
-    JS::GCPtr<DataTransfer> data_transfer;
+    GC::Ptr<DataTransfer> data_transfer;
 };
 
 // https://html.spec.whatwg.org/multipage/dnd.html#the-dragevent-interface
 class DragEvent : public UIEvents::MouseEvent {
     WEB_PLATFORM_OBJECT(DragEvent, UIEvents::MouseEvent);
-    JS_DECLARE_ALLOCATOR(DragEvent);
+    GC_DECLARE_ALLOCATOR(DragEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<DragEvent> create(JS::Realm&, FlyString const& event_name, DragEventInit const& event_init = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DragEvent>> construct_impl(JS::Realm&, FlyString const& event_name, DragEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<DragEvent> create(JS::Realm&, FlyString const& event_name, DragEventInit const& event_init = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
+    static WebIDL::ExceptionOr<GC::Ref<DragEvent>> construct_impl(JS::Realm&, FlyString const& event_name, DragEventInit const& event_init);
 
     virtual ~DragEvent() override;
 
-    JS::GCPtr<DataTransfer> data_transfer() { return m_data_transfer; }
+    GC::Ptr<DataTransfer> data_transfer() { return m_data_transfer; }
 
 private:
     DragEvent(JS::Realm&, FlyString const& event_name, DragEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y);
@@ -36,7 +36,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::GCPtr<DataTransfer> m_data_transfer;
+    GC::Ptr<DataTransfer> m_data_transfer;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/ElementInternals.cpp b/Libraries/LibWeb/HTML/ElementInternals.cpp
index 3d1fb721c25..78281d3b13d 100644
--- a/Libraries/LibWeb/HTML/ElementInternals.cpp
+++ b/Libraries/LibWeb/HTML/ElementInternals.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ElementInternals);
+GC_DEFINE_ALLOCATOR(ElementInternals);
 
-JS::NonnullGCPtr<ElementInternals> ElementInternals::create(JS::Realm& realm, HTMLElement& target_element)
+GC::Ref<ElementInternals> ElementInternals::create(JS::Realm& realm, HTMLElement& target_element)
 {
     return realm.create<ElementInternals>(realm, target_element);
 }
@@ -26,7 +26,7 @@ ElementInternals::ElementInternals(JS::Realm& realm, HTMLElement& target_element
 }
 
 // https://html.spec.whatwg.org/#dom-elementinternals-shadowroot
-JS::GCPtr<DOM::ShadowRoot> ElementInternals::shadow_root() const
+GC::Ptr<DOM::ShadowRoot> ElementInternals::shadow_root() const
 {
     // 1. Let target be this's target element.
     auto target = m_target_element;
diff --git a/Libraries/LibWeb/HTML/ElementInternals.h b/Libraries/LibWeb/HTML/ElementInternals.h
index 6c957875f3c..4079d3a06ec 100644
--- a/Libraries/LibWeb/HTML/ElementInternals.h
+++ b/Libraries/LibWeb/HTML/ElementInternals.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/WeakPtr.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 
@@ -16,12 +16,12 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/custom-elements.html#elementinternals
 class ElementInternals final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ElementInternals, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ElementInternals);
+    GC_DECLARE_ALLOCATOR(ElementInternals);
 
 public:
-    static JS::NonnullGCPtr<ElementInternals> create(JS::Realm&, HTMLElement& target_element);
+    static GC::Ref<ElementInternals> create(JS::Realm&, HTMLElement& target_element);
 
-    JS::GCPtr<DOM::ShadowRoot> shadow_root() const;
+    GC::Ptr<DOM::ShadowRoot> shadow_root() const;
 
 private:
     explicit ElementInternals(JS::Realm&, HTMLElement& target_element);
@@ -30,7 +30,7 @@ private:
     virtual void visit_edges(JS::Cell::Visitor& visitor) override;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#internals-target
-    JS::NonnullGCPtr<HTMLElement> m_target_element;
+    GC::Ref<HTMLElement> m_target_element;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/ErrorEvent.cpp b/Libraries/LibWeb/HTML/ErrorEvent.cpp
index e5a56d48a61..9005bbb4798 100644
--- a/Libraries/LibWeb/HTML/ErrorEvent.cpp
+++ b/Libraries/LibWeb/HTML/ErrorEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ErrorEvent);
+GC_DEFINE_ALLOCATOR(ErrorEvent);
 
-JS::NonnullGCPtr<ErrorEvent> ErrorEvent::create(JS::Realm& realm, FlyString const& event_name, ErrorEventInit const& event_init)
+GC::Ref<ErrorEvent> ErrorEvent::create(JS::Realm& realm, FlyString const& event_name, ErrorEventInit const& event_init)
 {
     return realm.create<ErrorEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ErrorEvent>> ErrorEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ErrorEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<ErrorEvent>> ErrorEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ErrorEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/ErrorEvent.h b/Libraries/LibWeb/HTML/ErrorEvent.h
index d5d7642c101..50c6a691924 100644
--- a/Libraries/LibWeb/HTML/ErrorEvent.h
+++ b/Libraries/LibWeb/HTML/ErrorEvent.h
@@ -23,11 +23,11 @@ struct ErrorEventInit : public DOM::EventInit {
 // https://html.spec.whatwg.org/multipage/webappapis.html#errorevent
 class ErrorEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(ErrorEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(ErrorEvent);
+    GC_DECLARE_ALLOCATOR(ErrorEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ErrorEvent> create(JS::Realm&, FlyString const& event_name, ErrorEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ErrorEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ErrorEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<ErrorEvent> create(JS::Realm&, FlyString const& event_name, ErrorEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<ErrorEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ErrorEventInit const& event_init);
 
     virtual ~ErrorEvent() override;
 
diff --git a/Libraries/LibWeb/HTML/EventHandler.cpp b/Libraries/LibWeb/HTML/EventHandler.cpp
index 1e5362d4b8b..65e34d929d5 100644
--- a/Libraries/LibWeb/HTML/EventHandler.cpp
+++ b/Libraries/LibWeb/HTML/EventHandler.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(EventHandler);
+GC_DEFINE_ALLOCATOR(EventHandler);
 
 EventHandler::EventHandler(ByteString s)
     : value(move(s))
@@ -26,7 +26,7 @@ void EventHandler::visit_edges(Cell::Visitor& visitor)
     Base::visit_edges(visitor);
     visitor.visit(listener);
 
-    if (auto* callback = value.get_pointer<JS::GCPtr<WebIDL::CallbackType>>())
+    if (auto* callback = value.get_pointer<GC::Ptr<WebIDL::CallbackType>>())
         visitor.visit(*callback);
 }
 
diff --git a/Libraries/LibWeb/HTML/EventHandler.h b/Libraries/LibWeb/HTML/EventHandler.h
index 060b74b47ff..301892cac16 100644
--- a/Libraries/LibWeb/HTML/EventHandler.h
+++ b/Libraries/LibWeb/HTML/EventHandler.h
@@ -8,15 +8,15 @@
 
 #include <AK/ByteString.h>
 #include <AK/Variant.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibWeb/WebIDL/CallbackType.h>
 
 namespace Web::HTML {
 
 class EventHandler final : public JS::Cell {
-    JS_CELL(EventHandler, JS::Cell);
-    JS_DECLARE_ALLOCATOR(EventHandler);
+    GC_CELL(EventHandler, JS::Cell);
+    GC_DECLARE_ALLOCATOR(EventHandler);
 
 public:
     explicit EventHandler(ByteString);
@@ -27,10 +27,10 @@ public:
     // NOTE: This does not contain Empty as part of the optimization of not allocating all event handler attributes up front.
     // FIXME: The string should actually be an "internal raw uncompiled handler" struct. This struct is just the uncompiled source code plus a source location for reporting parse errors.
     //        https://html.spec.whatwg.org/multipage/webappapis.html#internal-raw-uncompiled-handler
-    Variant<ByteString, JS::GCPtr<WebIDL::CallbackType>> value;
+    Variant<ByteString, GC::Ptr<WebIDL::CallbackType>> value;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#event-handler-listener
-    JS::GCPtr<DOM::DOMEventListener> listener;
+    GC::Ptr<DOM::DOMEventListener> listener;
 
 private:
     virtual void visit_edges(Cell::Visitor&) override;
diff --git a/Libraries/LibWeb/HTML/EventLoop/EventLoop.cpp b/Libraries/LibWeb/HTML/EventLoop/EventLoop.cpp
index 9cb3b9410d7..6d596a0c9de 100644
--- a/Libraries/LibWeb/HTML/EventLoop/EventLoop.cpp
+++ b/Libraries/LibWeb/HTML/EventLoop/EventLoop.cpp
@@ -25,7 +25,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(EventLoop);
+GC_DEFINE_ALLOCATOR(EventLoop);
 
 EventLoop::EventLoop(Type type)
     : m_type(type)
@@ -33,7 +33,7 @@ EventLoop::EventLoop(Type type)
     m_task_queue = heap().allocate<TaskQueue>(*this);
     m_microtask_queue = heap().allocate<TaskQueue>(*this);
 
-    m_rendering_task_function = JS::create_heap_function(heap(), [this] {
+    m_rendering_task_function = GC::create_function(heap(), [this] {
         update_the_rendering();
     });
 }
@@ -54,7 +54,7 @@ void EventLoop::visit_edges(Visitor& visitor)
 void EventLoop::schedule()
 {
     if (!m_system_event_loop_timer) {
-        m_system_event_loop_timer = Platform::Timer::create_single_shot(heap(), 0, JS::create_heap_function(heap(), [this] {
+        m_system_event_loop_timer = Platform::Timer::create_single_shot(heap(), 0, GC::create_function(heap(), [this] {
             process();
         }));
     }
@@ -69,7 +69,7 @@ EventLoop& main_thread_event_loop()
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#spin-the-event-loop
-void EventLoop::spin_until(JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condition)
+void EventLoop::spin_until(GC::Ref<GC::Function<bool()>> goal_condition)
 {
     // FIXME: The spec wants us to do the rest of the enclosing algorithm (i.e. the caller)
     //    in the context of the currently running task on entry. That's not possible with this implementation.
@@ -92,7 +92,7 @@ void EventLoop::spin_until(JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condi
     //       2. Perform any steps that appear after this spin the event loop instance in the original algorithm.
     //       NOTE: This is achieved by returning from the function.
 
-    Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(heap(), [this, goal_condition] {
+    Platform::EventLoopPlugin::the().spin_until(GC::create_function(heap(), [this, goal_condition] {
         if (goal_condition->function()())
             return true;
         if (m_task_queue->has_runnable_tasks()) {
@@ -109,7 +109,7 @@ void EventLoop::spin_until(JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condi
     // NOTE: This is achieved by returning from the function.
 }
 
-void EventLoop::spin_processing_tasks_with_source_until(Task::Source source, JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condition)
+void EventLoop::spin_processing_tasks_with_source_until(Task::Source source, GC::Ref<GC::Function<bool()>> goal_condition)
 {
     auto& vm = this->vm();
     vm.save_execution_context_stack();
@@ -120,7 +120,7 @@ void EventLoop::spin_processing_tasks_with_source_until(Task::Source source, JS:
     // NOTE: HTML event loop processing steps could run a task with arbitrary source
     m_skip_event_loop_processing_steps = true;
 
-    Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(heap(), [this, source, goal_condition] {
+    Platform::EventLoopPlugin::the().spin_until(GC::create_function(heap(), [this, source, goal_condition] {
         if (goal_condition->function()())
             return true;
         if (m_task_queue->has_runnable_tasks()) {
@@ -154,7 +154,7 @@ void EventLoop::process()
         return;
 
     // 1. Let oldestTask and taskStartTime be null.
-    JS::GCPtr<Task> oldest_task;
+    GC::Ptr<Task> oldest_task;
     [[maybe_unused]] double task_start_time = 0;
 
     // 2. If the event loop has a task queue with at least one runnable task, then:
@@ -404,7 +404,7 @@ void EventLoop::update_the_rendering()
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#queue-a-task
-TaskID queue_a_task(HTML::Task::Source source, JS::GCPtr<EventLoop> event_loop, JS::GCPtr<DOM::Document> document, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+TaskID queue_a_task(HTML::Task::Source source, GC::Ptr<EventLoop> event_loop, GC::Ptr<DOM::Document> document, GC::Ref<GC::Function<void()>> steps)
 {
     // 1. If event loop was not given, set event loop to the implied event loop.
     if (!event_loop)
@@ -429,7 +429,7 @@ TaskID queue_a_task(HTML::Task::Source source, JS::GCPtr<EventLoop> event_loop,
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#queue-a-global-task
-TaskID queue_global_task(HTML::Task::Source source, JS::Object& global_object, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+TaskID queue_global_task(HTML::Task::Source source, JS::Object& global_object, GC::Ref<GC::Function<void()>> steps)
 {
     // 1. Let event loop be global's relevant agent's event loop.
     auto& global_custom_data = verify_cast<Bindings::WebEngineCustomData>(*global_object.vm().custom_data());
@@ -447,7 +447,7 @@ TaskID queue_global_task(HTML::Task::Source source, JS::Object& global_object, J
 }
 
 // https://html.spec.whatwg.org/#queue-a-microtask
-void queue_a_microtask(DOM::Document const* document, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+void queue_a_microtask(DOM::Document const* document, GC::Ref<GC::Function<void()>> steps)
 {
     // 1. If event loop was not given, set event loop to the implied event loop.
     auto& event_loop = HTML::main_thread_event_loop();
@@ -515,14 +515,14 @@ void EventLoop::perform_a_microtask_checkpoint()
     // FIXME: 8. Record timing info for microtask checkpoint.
 }
 
-Vector<JS::Handle<DOM::Document>> EventLoop::documents_in_this_event_loop() const
+Vector<GC::Root<DOM::Document>> EventLoop::documents_in_this_event_loop() const
 {
-    Vector<JS::Handle<DOM::Document>> documents;
+    Vector<GC::Root<DOM::Document>> documents;
     for (auto& document : m_documents) {
         VERIFY(document);
         if (document->is_decoded_svg())
             continue;
-        documents.append(JS::make_handle(*document));
+        documents.append(GC::make_root(*document));
     }
     return documents;
 }
@@ -565,12 +565,12 @@ void EventLoop::unregister_environment_settings_object(Badge<EnvironmentSettings
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#same-loop-windows
-Vector<JS::Handle<HTML::Window>> EventLoop::same_loop_windows() const
+Vector<GC::Root<HTML::Window>> EventLoop::same_loop_windows() const
 {
-    Vector<JS::Handle<HTML::Window>> windows;
+    Vector<GC::Root<HTML::Window>> windows;
     for (auto& document : documents_in_this_event_loop()) {
         if (document->is_fully_active())
-            windows.append(JS::make_handle(document->window()));
+            windows.append(GC::make_root(document->window()));
     }
     return windows;
 }
diff --git a/Libraries/LibWeb/HTML/EventLoop/EventLoop.h b/Libraries/LibWeb/HTML/EventLoop/EventLoop.h
index f33ca7faa99..0da37deb25e 100644
--- a/Libraries/LibWeb/HTML/EventLoop/EventLoop.h
+++ b/Libraries/LibWeb/HTML/EventLoop/EventLoop.h
@@ -10,16 +10,16 @@
 #include <AK/Noncopyable.h>
 #include <AK/WeakPtr.h>
 #include <LibCore/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/HTML/EventLoop/TaskQueue.h>
 #include <LibWeb/HighResolutionTime/DOMHighResTimeStamp.h>
 
 namespace Web::HTML {
 
 class EventLoop : public JS::Cell {
-    JS_CELL(EventLoop, JS::Cell);
-    JS_DECLARE_ALLOCATOR(EventLoop);
+    GC_CELL(EventLoop, JS::Cell);
+    GC_DECLARE_ALLOCATOR(EventLoop);
 
     struct PauseHandle {
         PauseHandle(EventLoop&, JS::Object const& global, HighResolutionTime::DOMHighResTimeStamp);
@@ -28,8 +28,8 @@ class EventLoop : public JS::Cell {
         AK_MAKE_NONCOPYABLE(PauseHandle);
         AK_MAKE_NONMOVABLE(PauseHandle);
 
-        JS::NonnullGCPtr<EventLoop> event_loop;
-        JS::NonnullGCPtr<JS::Object const> global;
+        GC::Ref<EventLoop> event_loop;
+        GC::Ref<JS::Object const> global;
         HighResolutionTime::DOMHighResTimeStamp const time_before_pause;
     };
 
@@ -53,8 +53,8 @@ public:
     TaskQueue& microtask_queue() { return *m_microtask_queue; }
     TaskQueue const& microtask_queue() const { return *m_microtask_queue; }
 
-    void spin_until(JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condition);
-    void spin_processing_tasks_with_source_until(Task::Source, JS::NonnullGCPtr<JS::HeapFunction<bool()>> goal_condition);
+    void spin_until(GC::Ref<GC::Function<bool()>> goal_condition);
+    void spin_processing_tasks_with_source_until(Task::Source, GC::Ref<GC::Function<bool()>> goal_condition);
     void process();
     void queue_task_to_update_the_rendering();
 
@@ -72,9 +72,9 @@ public:
     void register_document(Badge<DOM::Document>, DOM::Document&);
     void unregister_document(Badge<DOM::Document>, DOM::Document&);
 
-    Vector<JS::Handle<DOM::Document>> documents_in_this_event_loop() const;
+    Vector<GC::Root<DOM::Document>> documents_in_this_event_loop() const;
 
-    Vector<JS::Handle<HTML::Window>> same_loop_windows() const;
+    Vector<GC::Root<HTML::Window>> same_loop_windows() const;
 
     void push_onto_backup_incumbent_realm_stack(JS::Realm&);
     void pop_backup_incumbent_realm_stack();
@@ -99,18 +99,18 @@ private:
 
     Type m_type { Type::Window };
 
-    JS::GCPtr<TaskQueue> m_task_queue;
-    JS::GCPtr<TaskQueue> m_microtask_queue;
+    GC::Ptr<TaskQueue> m_task_queue;
+    GC::Ptr<TaskQueue> m_microtask_queue;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#currently-running-task
-    JS::GCPtr<Task> m_currently_running_task { nullptr };
+    GC::Ptr<Task> m_currently_running_task { nullptr };
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#last-render-opportunity-time
     double m_last_render_opportunity_time { 0 };
     // https://html.spec.whatwg.org/multipage/webappapis.html#last-idle-period-start-time
     double m_last_idle_period_start_time { 0 };
 
-    JS::GCPtr<Platform::Timer> m_system_event_loop_timer;
+    GC::Ptr<Platform::Timer> m_system_event_loop_timer;
 
     // https://html.spec.whatwg.org/#performing-a-microtask-checkpoint
     bool m_performing_a_microtask_checkpoint { false };
@@ -123,7 +123,7 @@ private:
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#backup-incumbent-settings-object-stack
     // https://whatpr.org/html/9893/webappapis.html#backup-incumbent-realm-stack
-    Vector<JS::NonnullGCPtr<JS::Realm>> m_backup_incumbent_realm_stack;
+    Vector<GC::Ref<JS::Realm>> m_backup_incumbent_realm_stack;
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#termination-nesting-level
     size_t m_termination_nesting_level { 0 };
@@ -134,13 +134,13 @@ private:
 
     bool m_is_running_rendering_task { false };
 
-    JS::GCPtr<JS::HeapFunction<void()>> m_rendering_task_function;
+    GC::Ptr<GC::Function<void()>> m_rendering_task_function;
 };
 
 EventLoop& main_thread_event_loop();
-TaskID queue_a_task(HTML::Task::Source, JS::GCPtr<EventLoop>, JS::GCPtr<DOM::Document>, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
-TaskID queue_global_task(HTML::Task::Source, JS::Object&, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
-void queue_a_microtask(DOM::Document const*, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
+TaskID queue_a_task(HTML::Task::Source, GC::Ptr<EventLoop>, GC::Ptr<DOM::Document>, GC::Ref<GC::Function<void()>> steps);
+TaskID queue_global_task(HTML::Task::Source, JS::Object&, GC::Ref<GC::Function<void()>> steps);
+void queue_a_microtask(DOM::Document const*, GC::Ref<GC::Function<void()>> steps);
 void perform_a_microtask_checkpoint();
 
 }
diff --git a/Libraries/LibWeb/HTML/EventLoop/Task.cpp b/Libraries/LibWeb/HTML/EventLoop/Task.cpp
index 220f7eb9f77..c7b0dc7c700 100644
--- a/Libraries/LibWeb/HTML/EventLoop/Task.cpp
+++ b/Libraries/LibWeb/HTML/EventLoop/Task.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Task);
+GC_DEFINE_ALLOCATOR(Task);
 
 static IDAllocator s_unique_task_source_allocator { static_cast<int>(Task::Source::UniqueTaskSourceStart) };
 
@@ -20,12 +20,12 @@ static IDAllocator s_unique_task_source_allocator { static_cast<int>(Task::Sourc
     return next_task_id++;
 }
 
-JS::NonnullGCPtr<Task> Task::create(JS::VM& vm, Source source, JS::GCPtr<DOM::Document const> document, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+GC::Ref<Task> Task::create(JS::VM& vm, Source source, GC::Ptr<DOM::Document const> document, GC::Ref<GC::Function<void()>> steps)
 {
     return vm.heap().allocate<Task>(source, document, move(steps));
 }
 
-Task::Task(Source source, JS::GCPtr<DOM::Document const> document, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+Task::Task(Source source, GC::Ptr<DOM::Document const> document, GC::Ref<GC::Function<void()>> steps)
     : m_id(allocate_task_id())
     , m_source(source)
     , m_steps(steps)
diff --git a/Libraries/LibWeb/HTML/EventLoop/Task.h b/Libraries/LibWeb/HTML/EventLoop/Task.h
index d31653057b8..54cda396238 100644
--- a/Libraries/LibWeb/HTML/EventLoop/Task.h
+++ b/Libraries/LibWeb/HTML/EventLoop/Task.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/DistinctNumeric.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
@@ -18,8 +18,8 @@ struct UniqueTaskSource;
 AK_TYPEDEF_DISTINCT_NUMERIC_GENERAL(u64, TaskID, Comparison);
 
 class Task final : public JS::Cell {
-    JS_CELL(Task, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Task);
+    GC_CELL(Task, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Task);
 
 public:
     // https://html.spec.whatwg.org/multipage/webappapis.html#generic-task-sources
@@ -74,7 +74,7 @@ public:
         UniqueTaskSourceStart
     };
 
-    static JS::NonnullGCPtr<Task> create(JS::VM&, Source, JS::GCPtr<DOM::Document const>, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
+    static GC::Ref<Task> create(JS::VM&, Source, GC::Ptr<DOM::Document const>, GC::Ref<GC::Function<void()>> steps);
 
     virtual ~Task() override;
 
@@ -87,14 +87,14 @@ public:
     bool is_runnable() const;
 
 private:
-    Task(Source, JS::GCPtr<DOM::Document const>, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
+    Task(Source, GC::Ptr<DOM::Document const>, GC::Ref<GC::Function<void()>> steps);
 
     virtual void visit_edges(Visitor&) override;
 
     TaskID m_id {};
     Source m_source { Source::Unspecified };
-    JS::NonnullGCPtr<JS::HeapFunction<void()>> m_steps;
-    JS::GCPtr<DOM::Document const> m_document;
+    GC::Ref<GC::Function<void()>> m_steps;
+    GC::Ptr<DOM::Document const> m_document;
 };
 
 struct UniqueTaskSource {
diff --git a/Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp b/Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp
index 5e82c32645f..ea31788859a 100644
--- a/Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp
+++ b/Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp
@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/HTML/EventLoop/EventLoop.h>
 #include <LibWeb/HTML/EventLoop/TaskQueue.h>
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TaskQueue);
+GC_DEFINE_ALLOCATOR(TaskQueue);
 
 TaskQueue::TaskQueue(HTML::EventLoop& event_loop)
     : m_event_loop(event_loop)
@@ -26,13 +26,13 @@ void TaskQueue::visit_edges(Visitor& visitor)
     visitor.visit(m_tasks);
 }
 
-void TaskQueue::add(JS::NonnullGCPtr<Task> task)
+void TaskQueue::add(GC::Ref<Task> task)
 {
     m_tasks.append(task);
     m_event_loop->schedule();
 }
 
-JS::GCPtr<Task> TaskQueue::take_first_runnable()
+GC::Ptr<Task> TaskQueue::take_first_runnable()
 {
     if (m_event_loop->execution_paused())
         return nullptr;
@@ -63,9 +63,9 @@ void TaskQueue::remove_tasks_matching(Function<bool(HTML::Task const&)> filter)
     });
 }
 
-JS::MarkedVector<JS::NonnullGCPtr<Task>> TaskQueue::take_tasks_matching(Function<bool(HTML::Task const&)> filter)
+GC::MarkedVector<GC::Ref<Task>> TaskQueue::take_tasks_matching(Function<bool(HTML::Task const&)> filter)
 {
-    JS::MarkedVector<JS::NonnullGCPtr<Task>> matching_tasks(heap());
+    GC::MarkedVector<GC::Ref<Task>> matching_tasks(heap());
 
     for (size_t i = 0; i < m_tasks.size();) {
         auto& task = m_tasks.at(i);
diff --git a/Libraries/LibWeb/HTML/EventLoop/TaskQueue.h b/Libraries/LibWeb/HTML/EventLoop/TaskQueue.h
index 940d5efd9c8..c14bcf9aeb2 100644
--- a/Libraries/LibWeb/HTML/EventLoop/TaskQueue.h
+++ b/Libraries/LibWeb/HTML/EventLoop/TaskQueue.h
@@ -13,8 +13,8 @@
 namespace Web::HTML {
 
 class TaskQueue : public JS::Cell {
-    JS_CELL(TaskQueue, JS::Cell);
-    JS_DECLARE_ALLOCATOR(TaskQueue);
+    GC_CELL(TaskQueue, JS::Cell);
+    GC_DECLARE_ALLOCATOR(TaskQueue);
 
 public:
     explicit TaskQueue(HTML::EventLoop&);
@@ -25,11 +25,11 @@ public:
     bool has_runnable_tasks() const;
     bool has_rendering_tasks() const;
 
-    void add(JS::NonnullGCPtr<HTML::Task>);
-    JS::GCPtr<HTML::Task> take_first_runnable();
+    void add(GC::Ref<HTML::Task>);
+    GC::Ptr<HTML::Task> take_first_runnable();
 
-    void enqueue(JS::NonnullGCPtr<HTML::Task> task) { add(task); }
-    JS::GCPtr<HTML::Task> dequeue()
+    void enqueue(GC::Ref<HTML::Task> task) { add(task); }
+    GC::Ptr<HTML::Task> dequeue()
     {
         if (m_tasks.is_empty())
             return {};
@@ -37,16 +37,16 @@ public:
     }
 
     void remove_tasks_matching(Function<bool(HTML::Task const&)>);
-    JS::MarkedVector<JS::NonnullGCPtr<Task>> take_tasks_matching(Function<bool(HTML::Task const&)>);
+    GC::MarkedVector<GC::Ref<Task>> take_tasks_matching(Function<bool(HTML::Task const&)>);
 
     Task const* last_added_task() const;
 
 private:
     virtual void visit_edges(Visitor&) override;
 
-    JS::NonnullGCPtr<HTML::EventLoop> m_event_loop;
+    GC::Ref<HTML::EventLoop> m_event_loop;
 
-    Vector<JS::NonnullGCPtr<HTML::Task>> m_tasks;
+    Vector<GC::Ref<HTML::Task>> m_tasks;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/EventSource.cpp b/Libraries/LibWeb/HTML/EventSource.cpp
index 66dd6b70ce3..639b536ab05 100644
--- a/Libraries/LibWeb/HTML/EventSource.cpp
+++ b/Libraries/LibWeb/HTML/EventSource.cpp
@@ -6,7 +6,7 @@
 
 #include <AK/ScopeGuard.h>
 #include <LibCore/EventLoop.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Bindings/EventSourcePrototype.h>
@@ -29,10 +29,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(EventSource);
+GC_DEFINE_ALLOCATOR(EventSource);
 
 // https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource
-WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> EventSource::construct_impl(JS::Realm& realm, StringView url, EventSourceInit event_source_init_dict)
+WebIDL::ExceptionOr<GC::Ref<EventSource>> EventSource::construct_impl(JS::Realm& realm, StringView url, EventSourceInit event_source_init_dict)
 {
     auto& vm = realm.vm();
 
@@ -87,7 +87,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> EventSource::construct_impl(J
 
     // 14. Let processEventSourceEndOfBody given response res be the following step: if res is not a network error, then
     //     reestablish the connection.
-    auto process_event_source_end_of_body = [event_source](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+    auto process_event_source_end_of_body = [event_source](GC::Ref<Fetch::Infrastructure::Response> response) {
         if (!response->is_network_error())
             event_source->reestablish_the_connection();
     };
@@ -97,7 +97,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> EventSource::construct_impl(J
     Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
     fetch_algorithms_input.process_response_end_of_body = move(process_event_source_end_of_body);
 
-    fetch_algorithms_input.process_response = [event_source](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+    fetch_algorithms_input.process_response = [event_source](GC::Ref<Fetch::Infrastructure::Response> response) {
         auto& realm = event_source->realm();
 
         // FIXME: If the response is CORS cross-origin, we must use its internal response to query any of its data. See:
@@ -130,7 +130,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> EventSource::construct_impl(J
         else {
             event_source->announce_the_connection();
 
-            auto process_body_chunk = JS::create_heap_function(realm.heap(), [event_source, pending_data = ByteBuffer()](ByteBuffer body) mutable {
+            auto process_body_chunk = GC::create_function(realm.heap(), [event_source, pending_data = ByteBuffer()](ByteBuffer body) mutable {
                 if (pending_data.is_empty())
                     pending_data = move(body);
                 else
@@ -146,10 +146,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> EventSource::construct_impl(J
                 pending_data = MUST(pending_data.slice(end_index, pending_data.size() - end_index));
             });
 
-            auto process_end_of_body = JS::create_heap_function(realm.heap(), []() {
+            auto process_end_of_body = GC::create_function(realm.heap(), []() {
                 // This case is handled by `process_event_source_end_of_body` above.
             });
-            auto process_body_error = JS::create_heap_function(realm.heap(), [](JS::Value) {
+            auto process_body_error = GC::create_function(realm.heap(), [](JS::Value) {
                 // This case is handled by `process_event_source_end_of_body` above.
             });
 
@@ -269,7 +269,7 @@ void EventSource::announce_the_connection()
     // When a user agent is to announce the connection, the user agent must queue a task which, if the readyState attribute
     // is set to a value other than CLOSED, sets the readyState attribute to OPEN and fires an event named open at the
     // EventSource object.
-    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, JS::create_heap_function(heap(), [this]() {
+    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, GC::create_function(heap(), [this]() {
         if (m_ready_state != ReadyState::Closed) {
             m_ready_state = ReadyState::Open;
             dispatch_event(DOM::Event::create(realm(), HTML::EventNames::open));
@@ -283,7 +283,7 @@ void EventSource::reestablish_the_connection()
     bool initial_task_has_run { false };
 
     // 1. Queue a task to run the following steps:
-    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, JS::create_heap_function(heap(), [&]() {
+    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, GC::create_function(heap(), [&]() {
         ScopeGuard guard { [&]() { initial_task_has_run = true; } };
 
         // 1. If the readyState attribute is set to CLOSED, abort the task.
@@ -298,7 +298,7 @@ void EventSource::reestablish_the_connection()
     }));
 
     // 2. Wait a delay equal to the reconnection time of the event source.
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&, delay_start = MonotonicTime::now()]() {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&, delay_start = MonotonicTime::now()]() {
         return (MonotonicTime::now() - delay_start) >= m_reconnection_time;
     }));
 
@@ -309,17 +309,17 @@ void EventSource::reestablish_the_connection()
 
     // 4. Wait until the aforementioned task has run, if it has not yet run.
     if (!initial_task_has_run) {
-        HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&]() { return initial_task_has_run; }));
+        HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&]() { return initial_task_has_run; }));
     }
 
     // 5. Queue a task to run the following steps:
-    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, JS::create_heap_function(heap(), [this]() {
+    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, GC::create_function(heap(), [this]() {
         // 1. If the EventSource object's readyState attribute is not set to CONNECTING, then return.
         if (m_ready_state != ReadyState::Connecting)
             return;
 
         // 2. Let request be the EventSource object's request.
-        JS::NonnullGCPtr request { *m_request };
+        GC::Ref request { *m_request };
 
         // 3. If the EventSource object's last event ID string is not the empty string, then:
         if (!m_last_event_id.is_empty()) {
@@ -340,7 +340,7 @@ void EventSource::fail_the_connection()
     // When a user agent is to fail the connection, the user agent must queue a task which, if the readyState attribute
     // is set to a value other than CLOSED, sets the readyState attribute to CLOSED and fires an event named error at the
     // EventSource object. Once the user agent has failed the connection, it does not attempt to reconnect.
-    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, JS::create_heap_function(heap(), [this]() {
+    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, GC::create_function(heap(), [this]() {
         if (m_ready_state != ReadyState::Closed) {
             m_ready_state = ReadyState::Closed;
             dispatch_event(DOM::Event::create(realm(), HTML::EventNames::error));
@@ -461,7 +461,7 @@ void EventSource::dispatch_the_event()
 
     // 8. Queue a task which, if the readyState attribute is set to a value other than CLOSED, dispatches the newly created
     //    event at the EventSource object.
-    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, JS::create_heap_function(heap(), [this, event]() {
+    HTML::queue_a_task(HTML::Task::Source::RemoteEvent, nullptr, nullptr, GC::create_function(heap(), [this, event]() {
         if (m_ready_state != ReadyState::Closed)
             dispatch_event(event);
     }));
diff --git a/Libraries/LibWeb/HTML/EventSource.h b/Libraries/LibWeb/HTML/EventSource.h
index b6185f3333c..9a3d77fab7a 100644
--- a/Libraries/LibWeb/HTML/EventSource.h
+++ b/Libraries/LibWeb/HTML/EventSource.h
@@ -10,8 +10,8 @@
 #include <AK/StringBuilder.h>
 #include <AK/StringView.h>
 #include <AK/Time.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibURL/URL.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/Forward.h>
@@ -26,12 +26,12 @@ struct EventSourceInit {
 
 class EventSource : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(EventSource, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(EventSource);
+    GC_DECLARE_ALLOCATOR(EventSource);
 
 public:
     virtual ~EventSource() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<EventSource>> construct_impl(JS::Realm&, StringView url, EventSourceInit event_source_init_dict = {});
+    static WebIDL::ExceptionOr<GC::Ref<EventSource>> construct_impl(JS::Realm&, StringView url, EventSourceInit event_source_init_dict = {});
 
     // https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-url
     String url() const { return MUST(String::from_byte_string(m_url.serialize())); }
@@ -79,7 +79,7 @@ private:
     URL::URL m_url;
 
     // https://html.spec.whatwg.org/multipage/server-sent-events.html#concept-event-stream-request
-    JS::GCPtr<Fetch::Infrastructure::Request> m_request;
+    GC::Ptr<Fetch::Infrastructure::Request> m_request;
 
     // https://html.spec.whatwg.org/multipage/server-sent-events.html#concept-event-stream-reconnection-time
     AK::Duration m_reconnection_time { AK::Duration::from_seconds(3) };
@@ -94,8 +94,8 @@ private:
 
     ReadyState m_ready_state { ReadyState::Connecting };
 
-    JS::GCPtr<Fetch::Infrastructure::FetchAlgorithms> m_fetch_algorithms;
-    JS::GCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ptr<Fetch::Infrastructure::FetchAlgorithms> m_fetch_algorithms;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Focus.cpp b/Libraries/LibWeb/HTML/Focus.cpp
index c21f423570e..9c50691d6d6 100644
--- a/Libraries/LibWeb/HTML/Focus.cpp
+++ b/Libraries/LibWeb/HTML/Focus.cpp
@@ -8,7 +8,7 @@
 
 #include <AK/TypeCasts.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/DOM/Element.h>
 #include <LibWeb/DOM/ShadowRoot.h>
@@ -20,7 +20,7 @@
 namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/interaction.html#fire-a-focus-event
-static void fire_a_focus_event(JS::GCPtr<DOM::EventTarget> focus_event_target, JS::GCPtr<DOM::EventTarget> related_focus_target, FlyString const& event_name, bool bubbles)
+static void fire_a_focus_event(GC::Ptr<DOM::EventTarget> focus_event_target, GC::Ptr<DOM::EventTarget> related_focus_target, FlyString const& event_name, bool bubbles)
 {
     // To fire a focus event named e at an element t with a given related target r, fire an event named e at t, using FocusEvent,
     // with the relatedTarget attribute initialized to r, the view attribute initialized to t's node document's relevant global
@@ -38,7 +38,7 @@ static void fire_a_focus_event(JS::GCPtr<DOM::EventTarget> focus_event_target, J
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#focus-update-steps
-static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vector<JS::Handle<DOM::Node>> new_chain, DOM::Node* new_focus_target)
+static void run_focus_update_steps(Vector<GC::Root<DOM::Node>> old_chain, Vector<GC::Root<DOM::Node>> new_chain, DOM::Node* new_focus_target)
 {
     // 1. If the last entry in old chain and the last entry in new chain are the same,
     //    pop the last entry from old chain and the last entry from new chain and redo this step.
@@ -67,7 +67,7 @@ static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vect
             }
         }
 
-        JS::GCPtr<DOM::EventTarget> blur_event_target;
+        GC::Ptr<DOM::EventTarget> blur_event_target;
         if (is<DOM::Element>(*entry)) {
             // 2. If entry is an element, let blur event target be entry.
             blur_event_target = entry.ptr();
@@ -80,7 +80,7 @@ static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vect
         //    and the last entry in new chain is also an Element,
         //    then let related blur target be the last entry in new chain.
         //    Otherwise, let related blur target be null.
-        JS::GCPtr<DOM::EventTarget> related_blur_target;
+        GC::Ptr<DOM::EventTarget> related_blur_target;
         if (!old_chain.is_empty()
             && &entry == &old_chain.last()
             && is<DOM::Element>(*entry)
@@ -112,7 +112,7 @@ static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vect
         else if (is<DOM::Document>(*entry))
             entry->document().set_focused_element(static_cast<DOM::Document&>(*entry).document_element());
 
-        JS::GCPtr<DOM::EventTarget> focus_event_target;
+        GC::Ptr<DOM::EventTarget> focus_event_target;
         if (is<DOM::Element>(*entry)) {
             // 2. If entry is an element, let focus event target be entry.
             focus_event_target = entry.ptr();
@@ -125,7 +125,7 @@ static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vect
         //    and the last entry in old chain is also an Element,
         //    then let related focus target be the last entry in old chain.
         //    Otherwise, let related focus target be null.
-        JS::GCPtr<DOM::EventTarget> related_focus_target;
+        GC::Ptr<DOM::EventTarget> related_focus_target;
         if (!new_chain.is_empty()
             && &entry == &new_chain.last()
             && is<DOM::Element>(*entry)
@@ -146,14 +146,14 @@ static void run_focus_update_steps(Vector<JS::Handle<DOM::Node>> old_chain, Vect
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#focus-chain
-static Vector<JS::Handle<DOM::Node>> focus_chain(DOM::Node* subject)
+static Vector<GC::Root<DOM::Node>> focus_chain(DOM::Node* subject)
 {
     // FIXME: Move this somewhere more spec-friendly.
     if (!subject)
         return {};
 
     // 1. Let output be an empty list.
-    Vector<JS::Handle<DOM::Node>> output;
+    Vector<GC::Root<DOM::Node>> output;
 
     // 2. Let currentObject be subject.
     auto* current_object = subject;
@@ -161,7 +161,7 @@ static Vector<JS::Handle<DOM::Node>> focus_chain(DOM::Node* subject)
     // 3. While true:
     while (true) {
         // 1. Append currentObject to output.
-        output.append(JS::make_handle(*current_object));
+        output.append(GC::make_root(*current_object));
 
         // FIXME: 2. If currentObject is an area element's shape, then append that area element to output.
 
diff --git a/Libraries/LibWeb/HTML/FormAssociatedElement.cpp b/Libraries/LibWeb/HTML/FormAssociatedElement.cpp
index 0520b3060be..a01eb99dd49 100644
--- a/Libraries/LibWeb/HTML/FormAssociatedElement.cpp
+++ b/Libraries/LibWeb/HTML/FormAssociatedElement.cpp
@@ -689,7 +689,7 @@ void FormAssociatedTextControlElement::select_all()
     selection_was_changed();
 }
 
-void FormAssociatedTextControlElement::set_selection_anchor(JS::NonnullGCPtr<DOM::Node> anchor_node, size_t anchor_offset)
+void FormAssociatedTextControlElement::set_selection_anchor(GC::Ref<DOM::Node> anchor_node, size_t anchor_offset)
 {
     auto text_node = form_associated_element_to_text_node();
     if (!text_node || anchor_node != text_node)
@@ -698,7 +698,7 @@ void FormAssociatedTextControlElement::set_selection_anchor(JS::NonnullGCPtr<DOM
     selection_was_changed();
 }
 
-void FormAssociatedTextControlElement::set_selection_focus(JS::NonnullGCPtr<DOM::Node> focus_node, size_t focus_offset)
+void FormAssociatedTextControlElement::set_selection_focus(GC::Ref<DOM::Node> focus_node, size_t focus_offset)
 {
     auto text_node = form_associated_element_to_text_node();
     if (!text_node || focus_node != text_node)
@@ -809,7 +809,7 @@ void FormAssociatedTextControlElement::decrement_cursor_position_to_previous_wor
     selection_was_changed();
 }
 
-JS::GCPtr<DOM::Position> FormAssociatedTextControlElement::cursor_position() const
+GC::Ptr<DOM::Position> FormAssociatedTextControlElement::cursor_position() const
 {
     auto const node = form_associated_element_to_text_node();
     if (!node)
diff --git a/Libraries/LibWeb/HTML/FormAssociatedElement.h b/Libraries/LibWeb/HTML/FormAssociatedElement.h
index bdba181e071..66e12a26eb7 100644
--- a/Libraries/LibWeb/HTML/FormAssociatedElement.h
+++ b/Libraries/LibWeb/HTML/FormAssociatedElement.h
@@ -172,15 +172,15 @@ public:
 
     virtual void did_edit_text_node() = 0;
 
-    virtual JS::GCPtr<DOM::Text> form_associated_element_to_text_node() = 0;
-    virtual JS::GCPtr<DOM::Text const> form_associated_element_to_text_node() const { return const_cast<FormAssociatedTextControlElement&>(*this).form_associated_element_to_text_node(); }
+    virtual GC::Ptr<DOM::Text> form_associated_element_to_text_node() = 0;
+    virtual GC::Ptr<DOM::Text const> form_associated_element_to_text_node() const { return const_cast<FormAssociatedTextControlElement&>(*this).form_associated_element_to_text_node(); }
 
     virtual void handle_insert(String const&) override;
     virtual void handle_delete(DeleteDirection) override;
     virtual void handle_return_key() override;
     virtual void select_all() override;
-    virtual void set_selection_anchor(JS::NonnullGCPtr<DOM::Node>, size_t offset) override;
-    virtual void set_selection_focus(JS::NonnullGCPtr<DOM::Node>, size_t offset) override;
+    virtual void set_selection_anchor(GC::Ref<DOM::Node>, size_t offset) override;
+    virtual void set_selection_focus(GC::Ref<DOM::Node>, size_t offset) override;
     virtual void move_cursor_to_start(CollapseSelection) override;
     virtual void move_cursor_to_end(CollapseSelection) override;
     virtual void increment_cursor_position_offset(CollapseSelection) override;
@@ -188,7 +188,7 @@ public:
     virtual void increment_cursor_position_to_next_word(CollapseSelection) override;
     virtual void decrement_cursor_position_to_previous_word(CollapseSelection) override;
 
-    JS::GCPtr<DOM::Position> cursor_position() const;
+    GC::Ptr<DOM::Position> cursor_position() const;
 
 protected:
     // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-textarea/input-relevant-value
diff --git a/Libraries/LibWeb/HTML/FormControlInfrastructure.cpp b/Libraries/LibWeb/HTML/FormControlInfrastructure.cpp
index 25b520ca8da..848621e9e62 100644
--- a/Libraries/LibWeb/HTML/FormControlInfrastructure.cpp
+++ b/Libraries/LibWeb/HTML/FormControlInfrastructure.cpp
@@ -19,7 +19,7 @@
 namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry
-WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
+WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
 {
     auto& vm = realm.vm();
 
@@ -28,18 +28,18 @@ WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String co
 
     auto entry_value = TRY(value.visit(
         // 2. If value is a string, then set value to the result of converting value into a scalar value string.
-        [&](String const& string) -> WebIDL::ExceptionOr<Variant<JS::Handle<FileAPI::File>, String>> {
+        [&](String const& string) -> WebIDL::ExceptionOr<Variant<GC::Root<FileAPI::File>, String>> {
             return TRY_OR_THROW_OOM(vm, Infra::convert_to_scalar_value_string(string));
         },
         // 3. Otherwise:
-        [&](JS::NonnullGCPtr<FileAPI::Blob> blob) -> WebIDL::ExceptionOr<Variant<JS::Handle<FileAPI::File>, String>> {
+        [&](GC::Ref<FileAPI::Blob> blob) -> WebIDL::ExceptionOr<Variant<GC::Root<FileAPI::File>, String>> {
             // 1. If value is not a File object, then set value to a new File object, representing the same bytes, whose
             //    name attribute value is "blob".
             if (!is<FileAPI::File>(*blob)) {
                 FileAPI::FilePropertyBag options {};
                 options.type = blob->type();
 
-                blob = TRY(FileAPI::File::create(realm, { JS::make_handle(*blob) }, "blob"_string, move(options)));
+                blob = TRY(FileAPI::File::create(realm, { GC::make_root(*blob) }, "blob"_string, move(options)));
             }
 
             // 2. If filename is given, then set value to a new File object, representing the same bytes, whose name
@@ -48,10 +48,10 @@ WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String co
                 FileAPI::FilePropertyBag options {};
                 options.type = blob->type();
 
-                blob = TRY(FileAPI::File::create(realm, { JS::make_handle(*blob) }, *filename, move(options)));
+                blob = TRY(FileAPI::File::create(realm, { GC::make_root(*blob) }, *filename, move(options)));
             }
 
-            return JS::make_handle(verify_cast<FileAPI::File>(*blob));
+            return GC::make_root(verify_cast<FileAPI::File>(*blob));
         }));
 
     // 4. Return an entry whose name is name and whose value is value.
@@ -62,7 +62,7 @@ WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String co
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-the-form-data-set
-WebIDL::ExceptionOr<Optional<Vector<XHR::FormDataEntry>>> construct_entry_list(JS::Realm& realm, HTMLFormElement& form, JS::GCPtr<HTMLElement> submitter, Optional<String> encoding)
+WebIDL::ExceptionOr<Optional<Vector<XHR::FormDataEntry>>> construct_entry_list(JS::Realm& realm, HTMLFormElement& form, GC::Ptr<HTMLElement> submitter, Optional<String> encoding)
 {
     // 1. If form's constructing entry list is true, then return null.
     if (form.constructing_entry_list())
@@ -165,13 +165,13 @@ WebIDL::ExceptionOr<Optional<Vector<XHR::FormDataEntry>>> construct_entry_list(J
                 FileAPI::FilePropertyBag options {};
                 options.type = "application/octet-stream"_string;
                 auto file = TRY(FileAPI::File::create(realm, {}, String {}, options));
-                entry_list.append(XHR::FormDataEntry { .name = name.to_string(), .value = JS::make_handle(file) });
+                entry_list.append(XHR::FormDataEntry { .name = name.to_string(), .value = GC::make_root(file) });
             }
             // 2. Otherwise, for each file in selected files, create an entry with name and a File object representing the file, and append it to entry list.
             else {
                 for (size_t i = 0; i < file_element->files()->length(); i++) {
-                    auto file = JS::NonnullGCPtr { *file_element->files()->item(i) };
-                    entry_list.append(XHR::FormDataEntry { .name = name.to_string(), .value = JS::make_handle(file) });
+                    auto file = GC::Ref { *file_element->files()->item(i) };
+                    entry_list.append(XHR::FormDataEntry { .name = name.to_string(), .value = GC::make_root(file) });
                 }
             }
         }
@@ -272,7 +272,7 @@ ErrorOr<SerializedFormData> serialize_to_multipart_form_data(Vector<XHR::FormDat
         auto escaped_name = TRY(escape_line_feed_carriage_return_double_quote(normalized_name));
 
         TRY(entry.value.visit(
-            [&](JS::Handle<FileAPI::File> const& file) -> ErrorOr<void> {
+            [&](GC::Root<FileAPI::File> const& file) -> ErrorOr<void> {
                 // For filenames replace any 0x0A (LF) bytes with the byte sequence `%0A`, 0x0D (CR) with `%0D` and 0x22 (") with `%22`
                 auto escaped_filename = TRY(escape_line_feed_carriage_return_double_quote(file->name()));
                 // Add a `Content-Disposition` header with a `name` set to entry's name and `filename` set to entry's filename.
diff --git a/Libraries/LibWeb/HTML/FormControlInfrastructure.h b/Libraries/LibWeb/HTML/FormControlInfrastructure.h
index b35262f1885..0867624637b 100644
--- a/Libraries/LibWeb/HTML/FormControlInfrastructure.h
+++ b/Libraries/LibWeb/HTML/FormControlInfrastructure.h
@@ -15,8 +15,8 @@ struct SerializedFormData {
     ByteBuffer serialized_data;
 };
 
-WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
-WebIDL::ExceptionOr<Optional<Vector<XHR::FormDataEntry>>> construct_entry_list(JS::Realm&, HTMLFormElement&, JS::GCPtr<HTMLElement> submitter = nullptr, Optional<String> encoding = Optional<String> {});
+WebIDL::ExceptionOr<XHR::FormDataEntry> create_entry(JS::Realm& realm, String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
+WebIDL::ExceptionOr<Optional<Vector<XHR::FormDataEntry>>> construct_entry_list(JS::Realm&, HTMLFormElement&, GC::Ptr<HTMLElement> submitter = nullptr, Optional<String> encoding = Optional<String> {});
 ErrorOr<String> normalize_line_breaks(StringView value);
 ErrorOr<SerializedFormData> serialize_to_multipart_form_data(Vector<XHR::FormDataEntry> const& entry_list);
 
diff --git a/Libraries/LibWeb/HTML/FormDataEvent.cpp b/Libraries/LibWeb/HTML/FormDataEvent.cpp
index 8265199d9a2..0ed27240202 100644
--- a/Libraries/LibWeb/HTML/FormDataEvent.cpp
+++ b/Libraries/LibWeb/HTML/FormDataEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(FormDataEvent);
+GC_DEFINE_ALLOCATOR(FormDataEvent);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FormDataEvent>> FormDataEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, FormDataEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<FormDataEvent>> FormDataEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, FormDataEventInit const& event_init)
 {
     return realm.create<FormDataEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/FormDataEvent.h b/Libraries/LibWeb/HTML/FormDataEvent.h
index da526f25547..b3e0593682f 100644
--- a/Libraries/LibWeb/HTML/FormDataEvent.h
+++ b/Libraries/LibWeb/HTML/FormDataEvent.h
@@ -12,19 +12,19 @@
 namespace Web::HTML {
 
 struct FormDataEventInit : public DOM::EventInit {
-    JS::GCPtr<XHR::FormData> form_data {};
+    GC::Ptr<XHR::FormData> form_data {};
 };
 
 class FormDataEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(FormDataEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(FormDataEvent);
+    GC_DECLARE_ALLOCATOR(FormDataEvent);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<FormDataEvent>> construct_impl(JS::Realm&, FlyString const& event_name, FormDataEventInit const& event_init);
+    static WebIDL::ExceptionOr<GC::Ref<FormDataEvent>> construct_impl(JS::Realm&, FlyString const& event_name, FormDataEventInit const& event_init);
 
     virtual ~FormDataEvent() override;
 
-    JS::GCPtr<XHR::FormData> form_data() const { return m_form_data; }
+    GC::Ptr<XHR::FormData> form_data() const { return m_form_data; }
 
 private:
     FormDataEvent(JS::Realm&, FlyString const& event_name, FormDataEventInit const& event_init);
@@ -33,7 +33,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<XHR::FormData> m_form_data;
+    GC::Ptr<XHR::FormData> m_form_data;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/GlobalEventHandlers.h b/Libraries/LibWeb/HTML/GlobalEventHandlers.h
index 32fdc0b5e8f..a092d4919a5 100644
--- a/Libraries/LibWeb/HTML/GlobalEventHandlers.h
+++ b/Libraries/LibWeb/HTML/GlobalEventHandlers.h
@@ -94,7 +94,7 @@ public:
 #undef __ENUMERATE
 
 protected:
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) = 0;
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) = 0;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLAllCollection.cpp b/Libraries/LibWeb/HTML/HTMLAllCollection.cpp
index 60fc4ba95a3..465b0f249bf 100644
--- a/Libraries/LibWeb/HTML/HTMLAllCollection.cpp
+++ b/Libraries/LibWeb/HTML/HTMLAllCollection.cpp
@@ -30,9 +30,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLAllCollection);
+GC_DEFINE_ALLOCATOR(HTMLAllCollection);
 
-JS::NonnullGCPtr<HTMLAllCollection> HTMLAllCollection::create(DOM::ParentNode& root, Scope scope, Function<bool(DOM::Element const&)> filter)
+GC::Ref<HTMLAllCollection> HTMLAllCollection::create(DOM::ParentNode& root, Scope scope, Function<bool(DOM::Element const&)> filter)
 {
     return root.realm().create<HTMLAllCollection>(root, scope, move(filter));
 }
@@ -84,9 +84,9 @@ static bool is_all_named_element(DOM::Element const& element)
         || is<HTML::HTMLTextAreaElement>(element);
 }
 
-JS::MarkedVector<JS::NonnullGCPtr<DOM::Element>> HTMLAllCollection::collect_matching_elements() const
+GC::MarkedVector<GC::Ref<DOM::Element>> HTMLAllCollection::collect_matching_elements() const
 {
-    JS::MarkedVector<JS::NonnullGCPtr<DOM::Element>> elements(m_root->heap());
+    GC::MarkedVector<GC::Ref<DOM::Element>> elements(m_root->heap());
     if (m_scope == Scope::Descendants) {
         m_root->for_each_in_subtree_of_type<DOM::Element>([&](auto& element) {
             if (m_filter(element))
@@ -111,7 +111,7 @@ size_t HTMLAllCollection::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#dom-htmlallcollection-item
-Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> HTMLAllCollection::item(Optional<FlyString> const& name_or_index) const
+Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> HTMLAllCollection::item(Optional<FlyString> const& name_or_index) const
 {
     // 1. If nameOrIndex was not provided, return null.
     if (!name_or_index.has_value())
@@ -122,7 +122,7 @@ Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, E
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#dom-htmlallcollection-nameditem
-Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> HTMLAllCollection::named_item(FlyString const& name) const
+Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> HTMLAllCollection::named_item(FlyString const& name) const
 {
     // The namedItem(name) method steps are to return the result of getting the "all"-named element(s) from this given name.
     return get_the_all_named_elements(name);
@@ -158,7 +158,7 @@ Vector<FlyString> HTMLAllCollection::supported_property_names() const
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#concept-get-all-named
-Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> HTMLAllCollection::get_the_all_named_elements(FlyString const& name) const
+Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> HTMLAllCollection::get_the_all_named_elements(FlyString const& name) const
 {
     // 1. If name is the empty string, return null.
     if (name.is_empty())
@@ -188,7 +188,7 @@ Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, E
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#concept-get-all-indexed
-JS::GCPtr<DOM::Element> HTMLAllCollection::get_the_all_indexed_element(u32 index) const
+GC::Ptr<DOM::Element> HTMLAllCollection::get_the_all_indexed_element(u32 index) const
 {
     // To get the "all"-indexed element from an HTMLAllCollection collection given an index index, return the indexth
     // element in collection, or null if there is no such indexth element.
@@ -199,7 +199,7 @@ JS::GCPtr<DOM::Element> HTMLAllCollection::get_the_all_indexed_element(u32 index
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#concept-get-all-indexed-or-named
-Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> HTMLAllCollection::get_the_all_indexed_or_named_elements(JS::PropertyKey const& name_or_index) const
+Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> HTMLAllCollection::get_the_all_indexed_or_named_elements(JS::PropertyKey const& name_or_index) const
 {
     // 1. If nameOrIndex, converted to a JavaScript String value, is an array index property name, return the result of getting the "all"-indexed element from
     //    collection given the number represented by nameOrIndex.
@@ -207,7 +207,7 @@ Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, E
         auto maybe_element = get_the_all_indexed_element(name_or_index.as_number());
         if (!maybe_element)
             return Empty {};
-        return JS::NonnullGCPtr<DOM::Element> { *maybe_element };
+        return GC::Ref<DOM::Element> { *maybe_element };
     }
 
     // 2. Return the result of getting the "all"-named element(s) from collection given nameOrIndex.
diff --git a/Libraries/LibWeb/HTML/HTMLAllCollection.h b/Libraries/LibWeb/HTML/HTMLAllCollection.h
index 9c443a6c7c1..460dab98e8e 100644
--- a/Libraries/LibWeb/HTML/HTMLAllCollection.h
+++ b/Libraries/LibWeb/HTML/HTMLAllCollection.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/DOM/HTMLCollection.h>
 #include <LibWeb/Forward.h>
@@ -17,22 +17,22 @@ namespace Web::HTML {
 
 class HTMLAllCollection : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(HTMLAllCollection, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(HTMLAllCollection);
+    GC_DECLARE_ALLOCATOR(HTMLAllCollection);
 
 public:
     enum class Scope {
         Children,
         Descendants,
     };
-    [[nodiscard]] static JS::NonnullGCPtr<HTMLAllCollection> create(DOM::ParentNode& root, Scope, ESCAPING Function<bool(DOM::Element const&)> filter);
+    [[nodiscard]] static GC::Ref<HTMLAllCollection> create(DOM::ParentNode& root, Scope, ESCAPING Function<bool(DOM::Element const&)> filter);
 
     virtual ~HTMLAllCollection() override;
 
     size_t length() const;
-    Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> item(Optional<FlyString> const& name_or_index) const;
-    Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> named_item(FlyString const& name) const;
+    Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> item(Optional<FlyString> const& name_or_index) const;
+    Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> named_item(FlyString const& name) const;
 
-    JS::MarkedVector<JS::NonnullGCPtr<DOM::Element>> collect_matching_elements() const;
+    GC::MarkedVector<GC::Ref<DOM::Element>> collect_matching_elements() const;
 
     virtual Optional<JS::Value> item_value(size_t index) const override;
     virtual JS::Value named_item_value(FlyString const& name) const override;
@@ -46,13 +46,13 @@ protected:
     virtual bool is_htmldda() const override { return true; }
 
 private:
-    Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> get_the_all_named_elements(FlyString const& name) const;
-    JS::GCPtr<DOM::Element> get_the_all_indexed_element(u32 index) const;
-    Variant<JS::NonnullGCPtr<DOM::HTMLCollection>, JS::NonnullGCPtr<DOM::Element>, Empty> get_the_all_indexed_or_named_elements(JS::PropertyKey const& name_or_index) const;
+    Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> get_the_all_named_elements(FlyString const& name) const;
+    GC::Ptr<DOM::Element> get_the_all_indexed_element(u32 index) const;
+    Variant<GC::Ref<DOM::HTMLCollection>, GC::Ref<DOM::Element>, Empty> get_the_all_indexed_or_named_elements(JS::PropertyKey const& name_or_index) const;
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<DOM::ParentNode> m_root;
+    GC::Ref<DOM::ParentNode> m_root;
     Function<bool(DOM::Element const&)> m_filter;
     Scope m_scope { Scope::Descendants };
 };
diff --git a/Libraries/LibWeb/HTML/HTMLAnchorElement.cpp b/Libraries/LibWeb/HTML/HTMLAnchorElement.cpp
index fff4f7e0313..8eb6ca51b21 100644
--- a/Libraries/LibWeb/HTML/HTMLAnchorElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLAnchorElement.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLAnchorElement);
+GC_DEFINE_ALLOCATOR(HTMLAnchorElement);
 
 HTMLAnchorElement::HTMLAnchorElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -155,7 +155,7 @@ Optional<ARIA::Role> HTMLAnchorElement::default_role() const
 }
 
 // https://html.spec.whatwg.org/multipage/text-level-semantics.html#dom-a-rellist
-JS::NonnullGCPtr<DOM::DOMTokenList> HTMLAnchorElement::rel_list()
+GC::Ref<DOM::DOMTokenList> HTMLAnchorElement::rel_list()
 {
     // The IDL attribute relList must reflect the rel content attribute.
     if (!m_rel_list)
diff --git a/Libraries/LibWeb/HTML/HTMLAnchorElement.h b/Libraries/LibWeb/HTML/HTMLAnchorElement.h
index 4735a8c86ff..feb2c28aa6f 100644
--- a/Libraries/LibWeb/HTML/HTMLAnchorElement.h
+++ b/Libraries/LibWeb/HTML/HTMLAnchorElement.h
@@ -15,7 +15,7 @@ class HTMLAnchorElement final
     : public HTMLElement
     , public HTMLHyperlinkElementUtils {
     WEB_PLATFORM_OBJECT(HTMLAnchorElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLAnchorElement);
+    GC_DECLARE_ALLOCATOR(HTMLAnchorElement);
 
 public:
     virtual ~HTMLAnchorElement() override;
@@ -24,7 +24,7 @@ public:
     String target() const { return get_attribute_value(HTML::AttributeNames::target); }
     String download() const { return get_attribute_value(HTML::AttributeNames::download); }
 
-    JS::NonnullGCPtr<DOM::DOMTokenList> rel_list();
+    GC::Ref<DOM::DOMTokenList> rel_list();
 
     String text() const;
     void set_text(String const&);
@@ -72,7 +72,7 @@ private:
 
     virtual Optional<ARIA::Role> default_role() const override;
 
-    JS::GCPtr<DOM::DOMTokenList> m_rel_list;
+    GC::Ptr<DOM::DOMTokenList> m_rel_list;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLAreaElement.cpp b/Libraries/LibWeb/HTML/HTMLAreaElement.cpp
index 4da0ae4343c..8449fc8b3cb 100644
--- a/Libraries/LibWeb/HTML/HTMLAreaElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLAreaElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLAreaElement);
+GC_DEFINE_ALLOCATOR(HTMLAreaElement);
 
 HTMLAreaElement::HTMLAreaElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -46,7 +46,7 @@ void HTMLAreaElement::attribute_changed(FlyString const& name, Optional<String>
 }
 
 // https://html.spec.whatwg.org/multipage/image-maps.html#dom-area-rellist
-JS::NonnullGCPtr<DOM::DOMTokenList> HTMLAreaElement::rel_list()
+GC::Ref<DOM::DOMTokenList> HTMLAreaElement::rel_list()
 {
     // The IDL attribute relList must reflect the rel content attribute.
     if (!m_rel_list)
diff --git a/Libraries/LibWeb/HTML/HTMLAreaElement.h b/Libraries/LibWeb/HTML/HTMLAreaElement.h
index c06423f3dc3..4c9803a83db 100644
--- a/Libraries/LibWeb/HTML/HTMLAreaElement.h
+++ b/Libraries/LibWeb/HTML/HTMLAreaElement.h
@@ -16,11 +16,11 @@ class HTMLAreaElement final
     : public HTMLElement
     , public HTMLHyperlinkElementUtils {
     WEB_PLATFORM_OBJECT(HTMLAreaElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLAreaElement);
+    GC_DECLARE_ALLOCATOR(HTMLAreaElement);
 
 public:
     virtual ~HTMLAreaElement() override;
-    JS::NonnullGCPtr<DOM::DOMTokenList> rel_list();
+    GC::Ref<DOM::DOMTokenList> rel_list();
 
 private:
     HTMLAreaElement(DOM::Document&, DOM::QualifiedName);
@@ -55,7 +55,7 @@ private:
 
     virtual Optional<ARIA::Role> default_role() const override;
 
-    JS::GCPtr<DOM::DOMTokenList> m_rel_list;
+    GC::Ptr<DOM::DOMTokenList> m_rel_list;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLAudioElement.cpp b/Libraries/LibWeb/HTML/HTMLAudioElement.cpp
index a064415f487..ca0cfc050df 100644
--- a/Libraries/LibWeb/HTML/HTMLAudioElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLAudioElement.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLAudioElement);
+GC_DEFINE_ALLOCATOR(HTMLAudioElement);
 
 HTMLAudioElement::HTMLAudioElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLMediaElement(document, move(qualified_name))
@@ -29,7 +29,7 @@ void HTMLAudioElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLAudioElement);
 }
 
-JS::GCPtr<Layout::Node> HTMLAudioElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLAudioElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::AudioBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/HTML/HTMLAudioElement.h b/Libraries/LibWeb/HTML/HTMLAudioElement.h
index 2056a18d98d..81b3bc87ca9 100644
--- a/Libraries/LibWeb/HTML/HTMLAudioElement.h
+++ b/Libraries/LibWeb/HTML/HTMLAudioElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLAudioElement final : public HTMLMediaElement {
     WEB_PLATFORM_OBJECT(HTMLAudioElement, HTMLMediaElement);
-    JS_DECLARE_ALLOCATOR(HTMLAudioElement);
+    GC_DECLARE_ALLOCATOR(HTMLAudioElement);
 
 public:
     virtual ~HTMLAudioElement() override;
@@ -25,7 +25,7 @@ private:
 
     virtual void initialize(JS::Realm&) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     virtual void on_playing() override;
diff --git a/Libraries/LibWeb/HTML/HTMLBRElement.cpp b/Libraries/LibWeb/HTML/HTMLBRElement.cpp
index 04ddfad830b..ff52f6fe78e 100644
--- a/Libraries/LibWeb/HTML/HTMLBRElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLBRElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLBRElement);
+GC_DEFINE_ALLOCATOR(HTMLBRElement);
 
 HTMLBRElement::HTMLBRElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -27,7 +27,7 @@ void HTMLBRElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLBRElement);
 }
 
-JS::GCPtr<Layout::Node> HTMLBRElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLBRElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::BreakNode>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/HTML/HTMLBRElement.h b/Libraries/LibWeb/HTML/HTMLBRElement.h
index afddaf81a32..897f32b4af4 100644
--- a/Libraries/LibWeb/HTML/HTMLBRElement.h
+++ b/Libraries/LibWeb/HTML/HTMLBRElement.h
@@ -12,12 +12,12 @@ namespace Web::HTML {
 
 class HTMLBRElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLBRElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLBRElement);
+    GC_DECLARE_ALLOCATOR(HTMLBRElement);
 
 public:
     virtual ~HTMLBRElement() override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
 private:
diff --git a/Libraries/LibWeb/HTML/HTMLBaseElement.cpp b/Libraries/LibWeb/HTML/HTMLBaseElement.cpp
index 9ad150120c4..64e7548ed42 100644
--- a/Libraries/LibWeb/HTML/HTMLBaseElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLBaseElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLBaseElement);
+GC_DEFINE_ALLOCATOR(HTMLBaseElement);
 
 HTMLBaseElement::HTMLBaseElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLBaseElement.h b/Libraries/LibWeb/HTML/HTMLBaseElement.h
index d30bb926a7f..3350a75174e 100644
--- a/Libraries/LibWeb/HTML/HTMLBaseElement.h
+++ b/Libraries/LibWeb/HTML/HTMLBaseElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLBaseElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLBaseElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLBaseElement);
+    GC_DECLARE_ALLOCATOR(HTMLBaseElement);
 
 public:
     virtual ~HTMLBaseElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLBodyElement.cpp b/Libraries/LibWeb/HTML/HTMLBodyElement.cpp
index d3aa37d705b..4055bc77762 100644
--- a/Libraries/LibWeb/HTML/HTMLBodyElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLBodyElement.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLBodyElement);
+GC_DEFINE_ALLOCATOR(HTMLBodyElement);
 
 HTMLBodyElement::HTMLBodyElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -96,7 +96,7 @@ void HTMLBodyElement::attribute_changed(FlyString const& name, Optional<String>
 #undef __ENUMERATE
 }
 
-JS::GCPtr<DOM::EventTarget> HTMLBodyElement::global_event_handlers_to_event_target(FlyString const& event_name)
+GC::Ptr<DOM::EventTarget> HTMLBodyElement::global_event_handlers_to_event_target(FlyString const& event_name)
 {
     // NOTE: This is a little weird, but IIUC document.body.onload actually refers to window.onload
     // NOTE: document.body can return either a HTMLBodyElement or HTMLFrameSetElement, so both these elements must support this mapping.
@@ -106,7 +106,7 @@ JS::GCPtr<DOM::EventTarget> HTMLBodyElement::global_event_handlers_to_event_targ
     return *this;
 }
 
-JS::GCPtr<DOM::EventTarget> HTMLBodyElement::window_event_handlers_to_event_target()
+GC::Ptr<DOM::EventTarget> HTMLBodyElement::window_event_handlers_to_event_target()
 {
     // All WindowEventHandlers on HTMLFrameSetElement (e.g. document.body.onrejectionhandled) are mapped to window.on{event}.
     // NOTE: document.body can return either a HTMLBodyElement or HTMLFrameSetElement, so both these elements must support this mapping.
diff --git a/Libraries/LibWeb/HTML/HTMLBodyElement.h b/Libraries/LibWeb/HTML/HTMLBodyElement.h
index 6938d898913..d28356cec47 100644
--- a/Libraries/LibWeb/HTML/HTMLBodyElement.h
+++ b/Libraries/LibWeb/HTML/HTMLBodyElement.h
@@ -16,7 +16,7 @@ class HTMLBodyElement final
     : public HTMLElement
     , public WindowEventHandlers {
     WEB_PLATFORM_OBJECT(HTMLBodyElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLBodyElement);
+    GC_DECLARE_ALLOCATOR(HTMLBodyElement);
 
 public:
     virtual ~HTMLBodyElement() override;
@@ -38,10 +38,10 @@ private:
     virtual void initialize(JS::Realm&) override;
 
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) override;
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) override;
 
     // ^HTML::WindowEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> window_event_handlers_to_event_target() override;
+    virtual GC::Ptr<DOM::EventTarget> window_event_handlers_to_event_target() override;
 
     RefPtr<CSS::ImageStyleValue> m_background_style_value;
 };
diff --git a/Libraries/LibWeb/HTML/HTMLButtonElement.cpp b/Libraries/LibWeb/HTML/HTMLButtonElement.cpp
index 3f9e2e2db1e..24ee0d86763 100644
--- a/Libraries/LibWeb/HTML/HTMLButtonElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLButtonElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLButtonElement);
+GC_DEFINE_ALLOCATOR(HTMLButtonElement);
 
 HTMLButtonElement::HTMLButtonElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLButtonElement.h b/Libraries/LibWeb/HTML/HTMLButtonElement.h
index f8664de7aba..a1a834645c1 100644
--- a/Libraries/LibWeb/HTML/HTMLButtonElement.h
+++ b/Libraries/LibWeb/HTML/HTMLButtonElement.h
@@ -21,7 +21,7 @@ class HTMLButtonElement final
     : public HTMLElement
     , public FormAssociatedElement {
     WEB_PLATFORM_OBJECT(HTMLButtonElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLButtonElement);
+    GC_DECLARE_ALLOCATOR(HTMLButtonElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLButtonElement)
 
 public:
diff --git a/Libraries/LibWeb/HTML/HTMLCanvasElement.cpp b/Libraries/LibWeb/HTML/HTMLCanvasElement.cpp
index 4c9d2635859..47f70665dda 100644
--- a/Libraries/LibWeb/HTML/HTMLCanvasElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLCanvasElement.cpp
@@ -29,7 +29,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLCanvasElement);
+GC_DEFINE_ALLOCATOR(HTMLCanvasElement);
 
 static constexpr auto max_canvas_area = 16384 * 16384;
 
@@ -50,10 +50,10 @@ void HTMLCanvasElement::visit_edges(Cell::Visitor& visitor)
 {
     Base::visit_edges(visitor);
     m_context.visit(
-        [&](JS::NonnullGCPtr<CanvasRenderingContext2D>& context) {
+        [&](GC::Ref<CanvasRenderingContext2D>& context) {
             visitor.visit(context);
         },
-        [&](JS::NonnullGCPtr<WebGL::WebGLRenderingContext>& context) {
+        [&](GC::Ref<WebGL::WebGLRenderingContext>& context) {
             visitor.visit(context);
         },
         [](Empty) {
@@ -103,10 +103,10 @@ unsigned HTMLCanvasElement::height() const
 void HTMLCanvasElement::reset_context_to_default_state()
 {
     m_context.visit(
-        [](JS::NonnullGCPtr<CanvasRenderingContext2D>& context) {
+        [](GC::Ref<CanvasRenderingContext2D>& context) {
             context->reset_to_default_state();
         },
-        [](JS::NonnullGCPtr<WebGL::WebGLRenderingContext>&) {
+        [](GC::Ref<WebGL::WebGLRenderingContext>&) {
             TODO();
         },
         [](Empty) {
@@ -130,7 +130,7 @@ WebIDL::ExceptionOr<void> HTMLCanvasElement::set_height(unsigned value)
     return {};
 }
 
-JS::GCPtr<Layout::Node> HTMLCanvasElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLCanvasElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::CanvasBox>(document(), *this, move(style));
 }
@@ -145,7 +145,7 @@ void HTMLCanvasElement::adjust_computed_style(CSS::StyleProperties& style)
 HTMLCanvasElement::HasOrCreatedContext HTMLCanvasElement::create_2d_context()
 {
     if (!m_context.has<Empty>())
-        return m_context.has<JS::NonnullGCPtr<CanvasRenderingContext2D>>() ? HasOrCreatedContext::Yes : HasOrCreatedContext::No;
+        return m_context.has<GC::Ref<CanvasRenderingContext2D>>() ? HasOrCreatedContext::Yes : HasOrCreatedContext::No;
 
     m_context = CanvasRenderingContext2D::create(realm(), *this);
     return HasOrCreatedContext::Yes;
@@ -154,13 +154,13 @@ HTMLCanvasElement::HasOrCreatedContext HTMLCanvasElement::create_2d_context()
 JS::ThrowCompletionOr<HTMLCanvasElement::HasOrCreatedContext> HTMLCanvasElement::create_webgl_context(JS::Value options)
 {
     if (!m_context.has<Empty>())
-        return m_context.has<JS::NonnullGCPtr<WebGL::WebGLRenderingContext>>() ? HasOrCreatedContext::Yes : HasOrCreatedContext::No;
+        return m_context.has<GC::Ref<WebGL::WebGLRenderingContext>>() ? HasOrCreatedContext::Yes : HasOrCreatedContext::No;
 
     auto maybe_context = TRY(WebGL::WebGLRenderingContext::create(realm(), *this, options));
     if (!maybe_context)
         return HasOrCreatedContext::No;
 
-    m_context = JS::NonnullGCPtr<WebGL::WebGLRenderingContext>(*maybe_context);
+    m_context = GC::Ref<WebGL::WebGLRenderingContext>(*maybe_context);
     return HasOrCreatedContext::Yes;
 }
 
@@ -178,7 +178,7 @@ JS::ThrowCompletionOr<HTMLCanvasElement::RenderingContext> HTMLCanvasElement::ge
     // NOTE: See the spec for the full table.
     if (type == "2d"sv) {
         if (create_2d_context() == HasOrCreatedContext::Yes)
-            return JS::make_handle(*m_context.get<JS::NonnullGCPtr<HTML::CanvasRenderingContext2D>>());
+            return GC::make_root(*m_context.get<GC::Ref<HTML::CanvasRenderingContext2D>>());
 
         return Empty {};
     }
@@ -186,7 +186,7 @@ JS::ThrowCompletionOr<HTMLCanvasElement::RenderingContext> HTMLCanvasElement::ge
     // NOTE: The WebGL spec says "experimental-webgl" is also acceptable and must be equivalent to "webgl". Other engines accept this, so we do too.
     if (type.is_one_of("webgl"sv, "experimental-webgl"sv)) {
         if (TRY(create_webgl_context(options)) == HasOrCreatedContext::Yes)
-            return JS::make_handle(*m_context.get<JS::NonnullGCPtr<WebGL::WebGLRenderingContext>>());
+            return GC::make_root(*m_context.get<GC::Ref<WebGL::WebGLRenderingContext>>());
 
         return Empty {};
     }
@@ -295,7 +295,7 @@ String HTMLCanvasElement::to_data_url(StringView type, JS::Value quality)
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-canvas-toblob
-WebIDL::ExceptionOr<void> HTMLCanvasElement::to_blob(JS::NonnullGCPtr<WebIDL::CallbackType> callback, StringView type, JS::Value quality)
+WebIDL::ExceptionOr<void> HTMLCanvasElement::to_blob(GC::Ref<WebIDL::CallbackType> callback, StringView type, JS::Value quality)
 {
     // It is possible the the canvas doesn't have a associated bitmap so create one
     if (!m_surface) {
@@ -315,7 +315,7 @@ WebIDL::ExceptionOr<void> HTMLCanvasElement::to_blob(JS::NonnullGCPtr<WebIDL::Ca
     }
 
     // 4. Run these steps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [this, callback, bitmap_result, type, quality] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this, callback, bitmap_result, type, quality] {
         // 1. If result is non-null, then set result to a serialization of result as a file with type and quality if given.
         Optional<SerializeBitmapResult> file_result;
         if (bitmap_result) {
@@ -327,7 +327,7 @@ WebIDL::ExceptionOr<void> HTMLCanvasElement::to_blob(JS::NonnullGCPtr<WebIDL::Ca
         queue_an_element_task(Task::Source::CanvasBlobSerializationTask, [this, callback, file_result = move(file_result)] {
             auto maybe_error = Bindings::throw_dom_exception_if_needed(vm(), [&]() -> WebIDL::ExceptionOr<void> {
                 // 1. If result is non-null, then set result to a new Blob object, created in the relevant realm of this canvas element, representing result. [FILEAPI]
-                JS::GCPtr<FileAPI::Blob> blob_result;
+                GC::Ptr<FileAPI::Blob> blob_result;
                 if (file_result.has_value())
                     blob_result = FileAPI::Blob::create(realm(), file_result->buffer, TRY_OR_THROW_OOM(vm(), String::from_utf8(file_result->mime_type)));
 
@@ -349,10 +349,10 @@ void HTMLCanvasElement::present()
     }
 
     m_context.visit(
-        [](JS::NonnullGCPtr<CanvasRenderingContext2D>&) {
+        [](GC::Ref<CanvasRenderingContext2D>&) {
             // Do nothing, CRC2D writes directly to the canvas bitmap.
         },
-        [](JS::NonnullGCPtr<WebGL::WebGLRenderingContext>& context) {
+        [](GC::Ref<WebGL::WebGLRenderingContext>& context) {
             context->present();
         },
         [](Empty) {
diff --git a/Libraries/LibWeb/HTML/HTMLCanvasElement.h b/Libraries/LibWeb/HTML/HTMLCanvasElement.h
index 06183f36094..3cc4d21fef0 100644
--- a/Libraries/LibWeb/HTML/HTMLCanvasElement.h
+++ b/Libraries/LibWeb/HTML/HTMLCanvasElement.h
@@ -16,10 +16,10 @@ namespace Web::HTML {
 
 class HTMLCanvasElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLCanvasElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLCanvasElement);
+    GC_DECLARE_ALLOCATOR(HTMLCanvasElement);
 
 public:
-    using RenderingContext = Variant<JS::Handle<CanvasRenderingContext2D>, JS::Handle<WebGL::WebGLRenderingContext>, Empty>;
+    using RenderingContext = Variant<GC::Root<CanvasRenderingContext2D>, GC::Root<WebGL::WebGLRenderingContext>, Empty>;
 
     virtual ~HTMLCanvasElement() override;
 
@@ -36,7 +36,7 @@ public:
     WebIDL::ExceptionOr<void> set_height(unsigned);
 
     String to_data_url(StringView type, JS::Value quality);
-    WebIDL::ExceptionOr<void> to_blob(JS::NonnullGCPtr<WebIDL::CallbackType> callback, StringView type, JS::Value quality);
+    WebIDL::ExceptionOr<void> to_blob(GC::Ref<WebIDL::CallbackType> callback, StringView type, JS::Value quality);
 
     void present();
 
@@ -48,7 +48,7 @@ private:
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     enum class HasOrCreatedContext {
@@ -62,7 +62,7 @@ private:
 
     RefPtr<Gfx::PaintingSurface> m_surface;
 
-    Variant<JS::NonnullGCPtr<HTML::CanvasRenderingContext2D>, JS::NonnullGCPtr<WebGL::WebGLRenderingContext>, Empty> m_context;
+    Variant<GC::Ref<HTML::CanvasRenderingContext2D>, GC::Ref<WebGL::WebGLRenderingContext>, Empty> m_context;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLDListElement.cpp b/Libraries/LibWeb/HTML/HTMLDListElement.cpp
index b785ba22545..3f9ca83d4f0 100644
--- a/Libraries/LibWeb/HTML/HTMLDListElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDListElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDListElement);
+GC_DEFINE_ALLOCATOR(HTMLDListElement);
 
 HTMLDListElement::HTMLDListElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLDListElement.h b/Libraries/LibWeb/HTML/HTMLDListElement.h
index 3047149bdff..d92a9084b42 100644
--- a/Libraries/LibWeb/HTML/HTMLDListElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDListElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLDListElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDListElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDListElement);
+    GC_DECLARE_ALLOCATOR(HTMLDListElement);
 
 public:
     virtual ~HTMLDListElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLDataElement.cpp b/Libraries/LibWeb/HTML/HTMLDataElement.cpp
index 55185e919a7..7bd471d16eb 100644
--- a/Libraries/LibWeb/HTML/HTMLDataElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDataElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDataElement);
+GC_DEFINE_ALLOCATOR(HTMLDataElement);
 
 HTMLDataElement::HTMLDataElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLDataElement.h b/Libraries/LibWeb/HTML/HTMLDataElement.h
index 5d5b65cbe9d..96b5c7826df 100644
--- a/Libraries/LibWeb/HTML/HTMLDataElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDataElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLDataElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDataElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDataElement);
+    GC_DECLARE_ALLOCATOR(HTMLDataElement);
 
 public:
     virtual ~HTMLDataElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLDataListElement.cpp b/Libraries/LibWeb/HTML/HTMLDataListElement.cpp
index 85eaa0e6e7f..be65842b6d6 100644
--- a/Libraries/LibWeb/HTML/HTMLDataListElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDataListElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDataListElement);
+GC_DEFINE_ALLOCATOR(HTMLDataListElement);
 
 HTMLDataListElement::HTMLDataListElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -33,7 +33,7 @@ void HTMLDataListElement::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-datalist-options
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLDataListElement::options()
+GC::Ref<DOM::HTMLCollection> HTMLDataListElement::options()
 {
     // The options IDL attribute must return an HTMLCollection rooted at the datalist node, whose filter matches option elements.
     if (!m_options) {
diff --git a/Libraries/LibWeb/HTML/HTMLDataListElement.h b/Libraries/LibWeb/HTML/HTMLDataListElement.h
index 2716a2468c9..1d955ddb6d6 100644
--- a/Libraries/LibWeb/HTML/HTMLDataListElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDataListElement.h
@@ -14,14 +14,14 @@ namespace Web::HTML {
 
 class HTMLDataListElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDataListElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDataListElement);
+    GC_DECLARE_ALLOCATOR(HTMLDataListElement);
 
 public:
     virtual ~HTMLDataListElement() override;
 
     virtual Optional<ARIA::Role> default_role() const override { return ARIA::Role::listbox; }
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> options();
+    GC::Ref<DOM::HTMLCollection> options();
 
 private:
     HTMLDataListElement(DOM::Document&, DOM::QualifiedName);
@@ -29,7 +29,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::HTMLCollection> m_options;
+    GC::Ptr<DOM::HTMLCollection> m_options;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLDetailsElement.cpp b/Libraries/LibWeb/HTML/HTMLDetailsElement.cpp
index d21a15bfeb8..1405494b93a 100644
--- a/Libraries/LibWeb/HTML/HTMLDetailsElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDetailsElement.cpp
@@ -20,7 +20,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDetailsElement);
+GC_DEFINE_ALLOCATOR(HTMLDetailsElement);
 
 HTMLDetailsElement::HTMLDetailsElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -153,7 +153,7 @@ void HTMLDetailsElement::update_shadow_tree_slots()
 
     auto* summary = first_child_of_type<HTMLSummaryElement>();
     if (summary != nullptr)
-        summary_assignment.append(JS::make_handle(static_cast<DOM::Element&>(*summary)));
+        summary_assignment.append(GC::make_root(static_cast<DOM::Element&>(*summary)));
 
     for_each_in_subtree([&](auto& child) {
         if (&child == summary)
@@ -162,7 +162,7 @@ void HTMLDetailsElement::update_shadow_tree_slots()
             return TraversalDecision::Continue;
 
         child.as_slottable().visit([&](auto& node) {
-            descendants_assignment.append(JS::make_handle(node));
+            descendants_assignment.append(GC::make_root(node));
         });
 
         return TraversalDecision::Continue;
diff --git a/Libraries/LibWeb/HTML/HTMLDetailsElement.h b/Libraries/LibWeb/HTML/HTMLDetailsElement.h
index 4803f5b3244..800328b46e8 100644
--- a/Libraries/LibWeb/HTML/HTMLDetailsElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDetailsElement.h
@@ -17,7 +17,7 @@ namespace Web::HTML {
 
 class HTMLDetailsElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDetailsElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDetailsElement);
+    GC_DECLARE_ALLOCATOR(HTMLDetailsElement);
 
 public:
     virtual ~HTMLDetailsElement() override;
@@ -45,8 +45,8 @@ private:
     // https://html.spec.whatwg.org/multipage/interactive-elements.html#details-toggle-task-tracker
     Optional<ToggleTaskTracker> m_details_toggle_task_tracker;
 
-    JS::GCPtr<HTML::HTMLSlotElement> m_summary_slot;
-    JS::GCPtr<HTML::HTMLSlotElement> m_descendants_slot;
+    GC::Ptr<HTML::HTMLSlotElement> m_summary_slot;
+    GC::Ptr<HTML::HTMLSlotElement> m_descendants_slot;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLDialogElement.cpp b/Libraries/LibWeb/HTML/HTMLDialogElement.cpp
index cce1c20986e..fa7c2e16ee7 100644
--- a/Libraries/LibWeb/HTML/HTMLDialogElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDialogElement.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDialogElement);
+GC_DEFINE_ALLOCATOR(HTMLDialogElement);
 
 HTMLDialogElement::HTMLDialogElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -324,7 +324,7 @@ void HTMLDialogElement::close_the_dialog(Optional<String> result)
 void HTMLDialogElement::run_dialog_focusing_steps()
 {
     // 1. Let control be null
-    JS::GCPtr<Element> control = nullptr;
+    GC::Ptr<Element> control = nullptr;
 
     // FIXME 2. If subject has the autofocus attribute, then set control to subject.
     // FIXME 3. If control is null, then set control to the focus delegate of subject.
diff --git a/Libraries/LibWeb/HTML/HTMLDialogElement.h b/Libraries/LibWeb/HTML/HTMLDialogElement.h
index 0596bead364..3d910ee4949 100644
--- a/Libraries/LibWeb/HTML/HTMLDialogElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDialogElement.h
@@ -15,7 +15,7 @@ namespace Web::HTML {
 
 class HTMLDialogElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDialogElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDialogElement);
+    GC_DECLARE_ALLOCATOR(HTMLDialogElement);
 
 public:
     virtual ~HTMLDialogElement() override;
@@ -48,7 +48,7 @@ private:
 
     String m_return_value;
     bool m_is_modal { false };
-    JS::GCPtr<CloseWatcher> m_close_watcher;
+    GC::Ptr<CloseWatcher> m_close_watcher;
 
     // https://html.spec.whatwg.org/multipage/interactive-elements.html#dialog-toggle-task-tracker
     Optional<ToggleTaskTracker> m_dialog_toggle_task_tracker;
diff --git a/Libraries/LibWeb/HTML/HTMLDirectoryElement.cpp b/Libraries/LibWeb/HTML/HTMLDirectoryElement.cpp
index 3551c32ae3d..122a77d0594 100644
--- a/Libraries/LibWeb/HTML/HTMLDirectoryElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDirectoryElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDirectoryElement);
+GC_DEFINE_ALLOCATOR(HTMLDirectoryElement);
 
 HTMLDirectoryElement::HTMLDirectoryElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLDirectoryElement.h b/Libraries/LibWeb/HTML/HTMLDirectoryElement.h
index 936915856dd..8a5ce74ef65 100644
--- a/Libraries/LibWeb/HTML/HTMLDirectoryElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDirectoryElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // NOTE: This element is marked as obsolete, but is still listed as required by the specification.
 class HTMLDirectoryElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDirectoryElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDirectoryElement);
+    GC_DECLARE_ALLOCATOR(HTMLDirectoryElement);
 
 public:
     virtual ~HTMLDirectoryElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLDivElement.cpp b/Libraries/LibWeb/HTML/HTMLDivElement.cpp
index ae7a7072bf5..5f0547aa812 100644
--- a/Libraries/LibWeb/HTML/HTMLDivElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDivElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDivElement);
+GC_DEFINE_ALLOCATOR(HTMLDivElement);
 
 HTMLDivElement::HTMLDivElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLDivElement.h b/Libraries/LibWeb/HTML/HTMLDivElement.h
index c28a8afe067..98199f606a8 100644
--- a/Libraries/LibWeb/HTML/HTMLDivElement.h
+++ b/Libraries/LibWeb/HTML/HTMLDivElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLDivElement : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLDivElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLDivElement);
+    GC_DECLARE_ALLOCATOR(HTMLDivElement);
 
 public:
     virtual ~HTMLDivElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLDocument.cpp b/Libraries/LibWeb/HTML/HTMLDocument.cpp
index a92f3390616..3080ce306be 100644
--- a/Libraries/LibWeb/HTML/HTMLDocument.cpp
+++ b/Libraries/LibWeb/HTML/HTMLDocument.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLDocument);
+GC_DEFINE_ALLOCATOR(HTMLDocument);
 
 HTMLDocument::HTMLDocument(JS::Realm& realm, URL::URL const& url)
     : Document(realm, url)
@@ -18,12 +18,12 @@ HTMLDocument::HTMLDocument(JS::Realm& realm, URL::URL const& url)
 
 HTMLDocument::~HTMLDocument() = default;
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLDocument>> HTMLDocument::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<HTMLDocument>> HTMLDocument::construct_impl(JS::Realm& realm)
 {
     return HTMLDocument::create(realm);
 }
 
-JS::NonnullGCPtr<HTMLDocument> HTMLDocument::create(JS::Realm& realm, URL::URL const& url)
+GC::Ref<HTMLDocument> HTMLDocument::create(JS::Realm& realm, URL::URL const& url)
 {
     return realm.create<HTMLDocument>(realm, url);
 }
diff --git a/Libraries/LibWeb/HTML/HTMLDocument.h b/Libraries/LibWeb/HTML/HTMLDocument.h
index 15d21150176..2c1e52325f3 100644
--- a/Libraries/LibWeb/HTML/HTMLDocument.h
+++ b/Libraries/LibWeb/HTML/HTMLDocument.h
@@ -16,13 +16,13 @@ namespace Web::HTML {
 //       https://github.com/whatwg/dom/issues/221
 class HTMLDocument final : public DOM::Document {
     WEB_PLATFORM_OBJECT(HTMLDocument, DOM::Document);
-    JS_DECLARE_ALLOCATOR(HTMLDocument);
+    GC_DECLARE_ALLOCATOR(HTMLDocument);
 
 public:
     virtual ~HTMLDocument() override;
 
-    [[nodiscard]] static JS::NonnullGCPtr<HTMLDocument> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLDocument>> construct_impl(JS::Realm&);
+    [[nodiscard]] static GC::Ref<HTMLDocument> create(JS::Realm&, URL::URL const& url = "about:blank"sv);
+    WebIDL::ExceptionOr<GC::Ref<HTMLDocument>> construct_impl(JS::Realm&);
 
 private:
     virtual void initialize(JS::Realm&) override;
diff --git a/Libraries/LibWeb/HTML/HTMLElement.cpp b/Libraries/LibWeb/HTML/HTMLElement.cpp
index affdc0668b5..4c5b1405604 100644
--- a/Libraries/LibWeb/HTML/HTMLElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLElement.cpp
@@ -41,7 +41,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLElement);
+GC_DEFINE_ALLOCATOR(HTMLElement);
 
 HTMLElement::HTMLElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : Element(document, move(qualified_name))
@@ -207,7 +207,7 @@ WebIDL::ExceptionOr<void> HTMLElement::set_outer_text(String const& value)
 }
 
 // https://html.spec.whatwg.org/multipage/dom.html#rendered-text-fragment
-JS::NonnullGCPtr<DOM::DocumentFragment> HTMLElement::rendered_text_fragment(StringView input)
+GC::Ref<DOM::DocumentFragment> HTMLElement::rendered_text_fragment(StringView input)
 {
     // 1. Let fragment be a new DocumentFragment whose node document is document.
     //    Instead of creating a DocumentFragment the nodes are appended directly.
@@ -411,7 +411,7 @@ String HTMLElement::outer_text()
 }
 
 // https://www.w3.org/TR/cssom-view-1/#dom-htmlelement-offsetparent
-JS::GCPtr<DOM::Element> HTMLElement::offset_parent() const
+GC::Ptr<DOM::Element> HTMLElement::offset_parent() const
 {
     const_cast<DOM::Document&>(document()).update_layout();
 
@@ -672,7 +672,7 @@ bool HTMLElement::fire_a_synthetic_pointer_event(FlyString const& type, DOM::Ele
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#dom-lfe-labels-dev
-JS::GCPtr<DOM::NodeList> HTMLElement::labels()
+GC::Ptr<DOM::NodeList> HTMLElement::labels()
 {
     // Labelable elements and all input elements have a live NodeList object associated with them that represents the list of label elements, in tree order,
     // whose labeled control is the element in question. The labels IDL attribute of labelable elements that are not form-associated custom elements,
@@ -841,7 +841,7 @@ TokenizedFeature::NoOpener HTMLElement::get_an_elements_noopener(StringView targ
     return TokenizedFeature::NoOpener::No;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ElementInternals>> HTMLElement::attach_internals()
+WebIDL::ExceptionOr<GC::Ref<ElementInternals>> HTMLElement::attach_internals()
 {
     // 1. If this's is value is not null, then throw a "NotSupportedError" DOMException.
     if (is_value().has_value())
diff --git a/Libraries/LibWeb/HTML/HTMLElement.h b/Libraries/LibWeb/HTML/HTMLElement.h
index 763ba078ffa..099e06aa41d 100644
--- a/Libraries/LibWeb/HTML/HTMLElement.h
+++ b/Libraries/LibWeb/HTML/HTMLElement.h
@@ -25,7 +25,7 @@ class HTMLElement
     , public HTML::GlobalEventHandlers
     , public HTML::HTMLOrSVGElement<HTMLElement> {
     WEB_PLATFORM_OBJECT(HTMLElement, DOM::Element);
-    JS_DECLARE_ALLOCATOR(HTMLElement);
+    GC_DECLARE_ALLOCATOR(HTMLElement);
 
 public:
     virtual ~HTMLElement() override;
@@ -51,7 +51,7 @@ public:
     int offset_left() const;
     int offset_width() const;
     int offset_height() const;
-    JS::GCPtr<Element> offset_parent() const;
+    GC::Ptr<Element> offset_parent() const;
 
     bool cannot_navigate() const;
 
@@ -64,14 +64,14 @@ public:
     // https://html.spec.whatwg.org/multipage/forms.html#category-label
     virtual bool is_labelable() const { return false; }
 
-    JS::GCPtr<DOM::NodeList> labels();
+    GC::Ptr<DOM::NodeList> labels();
 
     virtual Optional<ARIA::Role> default_role() const override;
 
     String get_an_elements_target() const;
     TokenizedFeature::NoOpener get_an_elements_noopener(StringView target) const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<ElementInternals>> attach_internals();
+    WebIDL::ExceptionOr<GC::Ref<ElementInternals>> attach_internals();
 
     WebIDL::ExceptionOr<void> set_popover(Optional<String> value);
     Optional<String> popover() const;
@@ -93,17 +93,17 @@ private:
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
     virtual void did_receive_focus() override;
     virtual void did_lose_focus() override;
 
     [[nodiscard]] String get_the_text_steps();
-    JS::NonnullGCPtr<DOM::DocumentFragment> rendered_text_fragment(StringView input);
+    GC::Ref<DOM::DocumentFragment> rendered_text_fragment(StringView input);
 
-    JS::GCPtr<DOM::NodeList> m_labels;
+    GC::Ptr<DOM::NodeList> m_labels;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#attached-internals
-    JS::GCPtr<ElementInternals> m_attached_internals;
+    GC::Ptr<ElementInternals> m_attached_internals;
 
     enum class ContentEditableState {
         True,
diff --git a/Libraries/LibWeb/HTML/HTMLEmbedElement.cpp b/Libraries/LibWeb/HTML/HTMLEmbedElement.cpp
index ca549898e39..2436548e392 100644
--- a/Libraries/LibWeb/HTML/HTMLEmbedElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLEmbedElement.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLEmbedElement);
+GC_DEFINE_ALLOCATOR(HTMLEmbedElement);
 
 HTMLEmbedElement::HTMLEmbedElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLEmbedElement.h b/Libraries/LibWeb/HTML/HTMLEmbedElement.h
index a48621bd2c2..d3cea6ca73a 100644
--- a/Libraries/LibWeb/HTML/HTMLEmbedElement.h
+++ b/Libraries/LibWeb/HTML/HTMLEmbedElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLEmbedElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLEmbedElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLEmbedElement);
+    GC_DECLARE_ALLOCATOR(HTMLEmbedElement);
 
 public:
     virtual ~HTMLEmbedElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLFieldSetElement.cpp b/Libraries/LibWeb/HTML/HTMLFieldSetElement.cpp
index 94321e7fd96..a5fb9019d0f 100644
--- a/Libraries/LibWeb/HTML/HTMLFieldSetElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFieldSetElement.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFieldSetElement);
+GC_DEFINE_ALLOCATOR(HTMLFieldSetElement);
 
 HTMLFieldSetElement::HTMLFieldSetElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -59,7 +59,7 @@ bool HTMLFieldSetElement::is_disabled() const
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-fieldset-elements
-JS::GCPtr<DOM::HTMLCollection> const& HTMLFieldSetElement::elements()
+GC::Ptr<DOM::HTMLCollection> const& HTMLFieldSetElement::elements()
 {
     // The elements IDL attribute must return an HTMLCollection rooted at the fieldset element, whose filter matches listed elements.
     if (!m_elements) {
diff --git a/Libraries/LibWeb/HTML/HTMLFieldSetElement.h b/Libraries/LibWeb/HTML/HTMLFieldSetElement.h
index 52bc7db8000..683918a60ec 100644
--- a/Libraries/LibWeb/HTML/HTMLFieldSetElement.h
+++ b/Libraries/LibWeb/HTML/HTMLFieldSetElement.h
@@ -17,7 +17,7 @@ class HTMLFieldSetElement final
     : public HTMLElement
     , public FormAssociatedElement {
     WEB_PLATFORM_OBJECT(HTMLFieldSetElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLFieldSetElement);
+    GC_DECLARE_ALLOCATOR(HTMLFieldSetElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLFieldSetElement)
 
 public:
@@ -31,7 +31,7 @@ public:
 
     bool is_disabled() const;
 
-    JS::GCPtr<DOM::HTMLCollection> const& elements();
+    GC::Ptr<DOM::HTMLCollection> const& elements();
 
     // ^FormAssociatedElement
     // https://html.spec.whatwg.org/multipage/forms.html#category-listed
@@ -48,7 +48,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::HTMLCollection> m_elements;
+    GC::Ptr<DOM::HTMLCollection> m_elements;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLFontElement.cpp b/Libraries/LibWeb/HTML/HTMLFontElement.cpp
index 31f892cf227..a8493dc8994 100644
--- a/Libraries/LibWeb/HTML/HTMLFontElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFontElement.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFontElement);
+GC_DEFINE_ALLOCATOR(HTMLFontElement);
 
 enum class Mode {
     RelativePlus,
diff --git a/Libraries/LibWeb/HTML/HTMLFontElement.h b/Libraries/LibWeb/HTML/HTMLFontElement.h
index e59fce7125b..28d948a0720 100644
--- a/Libraries/LibWeb/HTML/HTMLFontElement.h
+++ b/Libraries/LibWeb/HTML/HTMLFontElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLFontElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLFontElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLFontElement);
+    GC_DECLARE_ALLOCATOR(HTMLFontElement);
 
 public:
     virtual ~HTMLFontElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLFormControlsCollection.cpp b/Libraries/LibWeb/HTML/HTMLFormControlsCollection.cpp
index c2612778efd..6f87d3ed4db 100644
--- a/Libraries/LibWeb/HTML/HTMLFormControlsCollection.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFormControlsCollection.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFormControlsCollection);
+GC_DEFINE_ALLOCATOR(HTMLFormControlsCollection);
 
-JS::NonnullGCPtr<HTMLFormControlsCollection> HTMLFormControlsCollection::create(DOM::ParentNode& root, Scope scope, Function<bool(DOM::Element const&)> filter)
+GC::Ref<HTMLFormControlsCollection> HTMLFormControlsCollection::create(DOM::ParentNode& root, Scope scope, Function<bool(DOM::Element const&)> filter)
 {
     return root.realm().create<HTMLFormControlsCollection>(root, scope, move(filter));
 }
@@ -35,7 +35,7 @@ void HTMLFormControlsCollection::initialize(JS::Realm& realm)
 }
 
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#dom-htmlformcontrolscollection-nameditem
-Variant<Empty, DOM::Element*, JS::Handle<RadioNodeList>> HTMLFormControlsCollection::named_item_or_radio_node_list(FlyString const& name) const
+Variant<Empty, DOM::Element*, GC::Root<RadioNodeList>> HTMLFormControlsCollection::named_item_or_radio_node_list(FlyString const& name) const
 {
     // 1. If name is the empty string, return null and stop the algorithm.
     if (name.is_empty())
@@ -68,7 +68,7 @@ Variant<Empty, DOM::Element*, JS::Handle<RadioNodeList>> HTMLFormControlsCollect
     // 4. Otherwise, create a new RadioNodeList object representing a live view of the HTMLFormControlsCollection object, further filtered so that the only nodes in the
     //    RadioNodeList object are those that have either an id attribute or a name attribute equal to name. The nodes in the RadioNodeList object must be sorted in tree
     //    order. Return that RadioNodeList object.
-    return JS::make_handle(RadioNodeList::create(realm(), root(), DOM::LiveNodeList::Scope::Descendants, [name](auto const& node) {
+    return GC::make_root(RadioNodeList::create(realm(), root(), DOM::LiveNodeList::Scope::Descendants, [name](auto const& node) {
         if (!is<DOM::Element>(node))
             return false;
 
diff --git a/Libraries/LibWeb/HTML/HTMLFormControlsCollection.h b/Libraries/LibWeb/HTML/HTMLFormControlsCollection.h
index 32fdb536815..a2cf756e3c5 100644
--- a/Libraries/LibWeb/HTML/HTMLFormControlsCollection.h
+++ b/Libraries/LibWeb/HTML/HTMLFormControlsCollection.h
@@ -12,14 +12,14 @@ namespace Web::HTML {
 
 class HTMLFormControlsCollection : public DOM::HTMLCollection {
     WEB_PLATFORM_OBJECT(HTMLFormControlsCollection, DOM::HTMLCollection);
-    JS_DECLARE_ALLOCATOR(HTMLFormControlsCollection);
+    GC_DECLARE_ALLOCATOR(HTMLFormControlsCollection);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<HTMLFormControlsCollection> create(DOM::ParentNode& root, Scope, ESCAPING Function<bool(DOM::Element const&)> filter);
+    [[nodiscard]] static GC::Ref<HTMLFormControlsCollection> create(DOM::ParentNode& root, Scope, ESCAPING Function<bool(DOM::Element const&)> filter);
 
     virtual ~HTMLFormControlsCollection() override;
 
-    Variant<Empty, DOM::Element*, JS::Handle<RadioNodeList>> named_item_or_radio_node_list(FlyString const& name) const;
+    Variant<Empty, DOM::Element*, GC::Root<RadioNodeList>> named_item_or_radio_node_list(FlyString const& name) const;
 
 protected:
     virtual void initialize(JS::Realm&) override;
diff --git a/Libraries/LibWeb/HTML/HTMLFormElement.cpp b/Libraries/LibWeb/HTML/HTMLFormElement.cpp
index cea33b2d894..e578fae9c12 100644
--- a/Libraries/LibWeb/HTML/HTMLFormElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFormElement.cpp
@@ -37,7 +37,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFormElement);
+GC_DEFINE_ALLOCATOR(HTMLFormElement);
 
 HTMLFormElement::HTMLFormElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -96,7 +96,7 @@ WebIDL::ExceptionOr<void> HTMLFormElement::implicitly_submit_form()
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-form-submit
-WebIDL::ExceptionOr<void> HTMLFormElement::submit_form(JS::NonnullGCPtr<HTMLElement> submitter, SubmitFormOptions options)
+WebIDL::ExceptionOr<void> HTMLFormElement::submit_form(GC::Ref<HTMLElement> submitter, SubmitFormOptions options)
 {
     auto& vm = this->vm();
     auto& realm = this->realm();
@@ -110,7 +110,7 @@ WebIDL::ExceptionOr<void> HTMLFormElement::submit_form(JS::NonnullGCPtr<HTMLElem
         return {};
 
     // 3. Let form document be form's node document.
-    JS::NonnullGCPtr<DOM::Document> form_document = this->document();
+    GC::Ref<DOM::Document> form_document = this->document();
 
     // 4. If form document's active sandboxing flag set has its sandboxed forms browsing context flag set, then return.
     if (has_flag(form_document->active_sandboxing_flag_set(), HTML::SandboxingFlagSet::SandboxedForms))
@@ -132,7 +132,7 @@ WebIDL::ExceptionOr<void> HTMLFormElement::submit_form(JS::NonnullGCPtr<HTMLElem
         //           2. Return.
 
         // 4. Let submitterButton be null if submitter is form. Otherwise, let submitterButton be submitter.
-        JS::GCPtr<HTMLElement> submitter_button;
+        GC::Ptr<HTMLElement> submitter_button;
         if (submitter != this)
             submitter_button = submitter;
 
@@ -332,7 +332,7 @@ WebIDL::ExceptionOr<void> HTMLFormElement::submit()
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#dom-form-requestsubmit
-WebIDL::ExceptionOr<void> HTMLFormElement::request_submit(JS::GCPtr<Element> submitter)
+WebIDL::ExceptionOr<void> HTMLFormElement::request_submit(GC::Ptr<Element> submitter)
 {
     // 1. If submitter is not null, then:
     if (submitter) {
@@ -385,7 +385,7 @@ void HTMLFormElement::remove_associated_element(Badge<FormAssociatedElement>, HT
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fs-action
-String HTMLFormElement::action_from_form_element(JS::NonnullGCPtr<HTMLElement> element) const
+String HTMLFormElement::action_from_form_element(GC::Ref<HTMLElement> element) const
 {
     // The action of an element is the value of the element's formaction attribute, if the element is a submit button
     // and has such an attribute, or the value of its form owner's action attribute, if it has one, or else the empty
@@ -416,7 +416,7 @@ static HTMLFormElement::MethodAttributeState method_attribute_to_method_state(St
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fs-method
-HTMLFormElement::MethodAttributeState HTMLFormElement::method_state_from_form_element(JS::NonnullGCPtr<HTMLElement const> element) const
+HTMLFormElement::MethodAttributeState HTMLFormElement::method_state_from_form_element(GC::Ref<HTMLElement const> element) const
 {
     // If the element is a submit button and has a formmethod attribute, then the element's method is that attribute's state;
     // otherwise, it is the form owner's method attribute's state.
@@ -451,7 +451,7 @@ static HTMLFormElement::EncodingTypeAttributeState encoding_type_attribute_to_en
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#concept-fs-enctype
-HTMLFormElement::EncodingTypeAttributeState HTMLFormElement::encoding_type_state_from_form_element(JS::NonnullGCPtr<HTMLElement> element) const
+HTMLFormElement::EncodingTypeAttributeState HTMLFormElement::encoding_type_state_from_form_element(GC::Ref<HTMLElement> element) const
 {
     // If the element is a submit button and has a formenctype attribute, then the element's enctype is that attribute's state;
     // otherwise, it is the form owner's enctype attribute's state.
@@ -517,7 +517,7 @@ static bool is_form_control(DOM::Element const& element, HTMLFormElement const&
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#dom-form-elements
-JS::NonnullGCPtr<HTMLFormControlsCollection> HTMLFormElement::elements() const
+GC::Ref<HTMLFormControlsCollection> HTMLFormElement::elements() const
 {
     if (!m_elements) {
         auto& root = verify_cast<ParentNode>(const_cast<HTMLFormElement*>(this)->root());
@@ -550,9 +550,9 @@ WebIDL::ExceptionOr<bool> HTMLFormElement::report_validity()
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#category-submit
-Vector<JS::NonnullGCPtr<DOM::Element>> HTMLFormElement::get_submittable_elements()
+Vector<GC::Ref<DOM::Element>> HTMLFormElement::get_submittable_elements()
 {
-    Vector<JS::NonnullGCPtr<DOM::Element>> submittable_elements;
+    Vector<GC::Ref<DOM::Element>> submittable_elements;
 
     root().for_each_in_subtree([&](auto& node) {
         if (auto* form_associated_element = dynamic_cast<FormAssociatedElement*>(&node)) {
@@ -567,7 +567,7 @@ Vector<JS::NonnullGCPtr<DOM::Element>> HTMLFormElement::get_submittable_elements
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#dom-form-rellist
-JS::NonnullGCPtr<DOM::DOMTokenList> HTMLFormElement::rel_list()
+GC::Ref<DOM::DOMTokenList> HTMLFormElement::rel_list()
 {
     // The relList IDL attribute must reflect the rel content attribute.
     if (!m_rel_list)
@@ -665,7 +665,7 @@ static ErrorOr<Vector<DOMURL::QueryParam>> convert_to_list_of_name_value_pairs(V
         // 2. If entry's value is a File object, then let value be entry's value's name. Otherwise, let value be entry's value.
         String value;
         entry.value.visit(
-            [&value](JS::Handle<FileAPI::File> const& file) {
+            [&value](GC::Root<FileAPI::File> const& file) {
                 value = file->name();
             },
             [&value](String const& string) {
@@ -710,7 +710,7 @@ static ErrorOr<String> plain_text_encode(Vector<DOMURL::QueryParam> const& pairs
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#submit-mutate-action
-ErrorOr<void> HTMLFormElement::mutate_action_url(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+ErrorOr<void> HTMLFormElement::mutate_action_url(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Let pairs be the result of converting to a list of name-value pairs with entry list.
     auto pairs = TRY(convert_to_list_of_name_value_pairs(entry_list));
@@ -727,7 +727,7 @@ ErrorOr<void> HTMLFormElement::mutate_action_url(URL::URL parsed_action, Vector<
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#submit-body
-ErrorOr<void> HTMLFormElement::submit_as_entity_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, [[maybe_unused]] String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+ErrorOr<void> HTMLFormElement::submit_as_entity_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, [[maybe_unused]] String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Assert: method is POST.
 
@@ -788,7 +788,7 @@ ErrorOr<void> HTMLFormElement::submit_as_entity_body(URL::URL parsed_action, Vec
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#submit-get-action
-void HTMLFormElement::get_action_url(URL::URL parsed_action, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+void HTMLFormElement::get_action_url(URL::URL parsed_action, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Plan to navigate to parsed action.
     // Spec Note: entry list is discarded.
@@ -796,7 +796,7 @@ void HTMLFormElement::get_action_url(URL::URL parsed_action, JS::NonnullGCPtr<Na
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#submit-mailto-headers
-ErrorOr<void> HTMLFormElement::mail_with_headers(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, [[maybe_unused]] String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+ErrorOr<void> HTMLFormElement::mail_with_headers(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, [[maybe_unused]] String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Let pairs be the result of converting to a list of name-value pairs with entry list.
     auto pairs = TRY(convert_to_list_of_name_value_pairs(entry_list));
@@ -815,7 +815,7 @@ ErrorOr<void> HTMLFormElement::mail_with_headers(URL::URL parsed_action, Vector<
     return {};
 }
 
-ErrorOr<void> HTMLFormElement::mail_as_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, [[maybe_unused]] String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+ErrorOr<void> HTMLFormElement::mail_as_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, [[maybe_unused]] String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Let pairs be the result of converting to a list of name-value pairs with entry list.
     auto pairs = TRY(convert_to_list_of_name_value_pairs(entry_list));
@@ -868,7 +868,7 @@ ErrorOr<void> HTMLFormElement::mail_as_body(URL::URL parsed_action, Vector<XHR::
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plan-to-navigate
-void HTMLFormElement::plan_to_navigate_to(URL::URL url, Variant<Empty, String, POSTResource> post_resource, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
+void HTMLFormElement::plan_to_navigate_to(URL::URL url, Variant<Empty, String, POSTResource> post_resource, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement)
 {
     // 1. Let referrerPolicy be the empty string.
     ReferrerPolicy::ReferrerPolicy referrer_policy = ReferrerPolicy::ReferrerPolicy::EmptyString;
@@ -887,7 +887,7 @@ void HTMLFormElement::plan_to_navigate_to(URL::URL url, Variant<Empty, String, P
     }
 
     // 4. Queue an element task on the DOM manipulation task source given the form element and the following steps:
-    // NOTE: `this`, `actual_resource` and `target_navigable` are protected by JS::HeapFunction.
+    // NOTE: `this`, `actual_resource` and `target_navigable` are protected by GC::HeapFunction.
     queue_an_element_task(Task::Source::DOMManipulation, [this, url, post_resource, target_navigable, history_handling, referrer_policy, user_involvement]() {
         // 1. Set the form's planned navigation to null.
         m_planned_navigation = {};
@@ -928,7 +928,7 @@ Vector<FlyString> HTMLFormElement::supported_property_names() const
     //    where the source is either id, name, or past, and, if the source is past, an age.
     struct SourcedName {
         FlyString name;
-        JS::GCPtr<DOM::Element const> element;
+        GC::Ptr<DOM::Element const> element;
         enum class Source {
             Id,
             Name,
diff --git a/Libraries/LibWeb/HTML/HTMLFormElement.h b/Libraries/LibWeb/HTML/HTMLFormElement.h
index 554ca5f179b..7795142167e 100644
--- a/Libraries/LibWeb/HTML/HTMLFormElement.h
+++ b/Libraries/LibWeb/HTML/HTMLFormElement.h
@@ -29,12 +29,12 @@ namespace Web::HTML {
 
 class HTMLFormElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLFormElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLFormElement);
+    GC_DECLARE_ALLOCATOR(HTMLFormElement);
 
 public:
     virtual ~HTMLFormElement() override;
 
-    String action_from_form_element(JS::NonnullGCPtr<HTMLElement> element) const;
+    String action_from_form_element(GC::Ref<HTMLElement> element) const;
 
     enum class MethodAttributeState {
 #define __ENUMERATE_FORM_METHOD_ATTRIBUTE(_, state) state,
@@ -42,7 +42,7 @@ public:
 #undef __ENUMERATE_FORM_METHOD_ATTRIBUTE
     };
 
-    MethodAttributeState method_state_from_form_element(JS::NonnullGCPtr<HTMLElement const> element) const;
+    MethodAttributeState method_state_from_form_element(GC::Ref<HTMLElement const> element) const;
 
     enum class EncodingTypeAttributeState {
 #define __ENUMERATE_FORM_METHOD_ENCODING_TYPE(_, state) state,
@@ -50,13 +50,13 @@ public:
 #undef __ENUMERATE_FORM_METHOD_ENCODING_TYPE
     };
 
-    EncodingTypeAttributeState encoding_type_state_from_form_element(JS::NonnullGCPtr<HTMLElement> element) const;
+    EncodingTypeAttributeState encoding_type_state_from_form_element(GC::Ref<HTMLElement> element) const;
 
     struct SubmitFormOptions {
         bool from_submit_binding = { false };
         UserNavigationInvolvement user_involvement = { UserNavigationInvolvement::None };
     };
-    WebIDL::ExceptionOr<void> submit_form(JS::NonnullGCPtr<HTMLElement> submitter, SubmitFormOptions);
+    WebIDL::ExceptionOr<void> submit_form(GC::Ref<HTMLElement> submitter, SubmitFormOptions);
     WebIDL::ExceptionOr<void> implicitly_submit_form();
 
     void reset_form();
@@ -65,7 +65,7 @@ public:
     WebIDL::ExceptionOr<void> submit();
 
     // NOTE: This is for the JS bindings. Use submit_form instead.
-    WebIDL::ExceptionOr<void> request_submit(JS::GCPtr<Element> submitter);
+    WebIDL::ExceptionOr<void> request_submit(GC::Ptr<Element> submitter);
 
     // NOTE: This is for the JS bindings. Use submit_form instead.
     void reset();
@@ -73,9 +73,9 @@ public:
     void add_associated_element(Badge<FormAssociatedElement>, HTMLElement&);
     void remove_associated_element(Badge<FormAssociatedElement>, HTMLElement&);
 
-    Vector<JS::NonnullGCPtr<DOM::Element>> get_submittable_elements();
+    Vector<GC::Ref<DOM::Element>> get_submittable_elements();
 
-    JS::NonnullGCPtr<HTMLFormControlsCollection> elements() const;
+    GC::Ref<HTMLFormControlsCollection> elements() const;
     unsigned length() const;
 
     WebIDL::ExceptionOr<bool> check_validity();
@@ -90,7 +90,7 @@ public:
 
     WebIDL::ExceptionOr<void> set_method(String const&);
 
-    JS::NonnullGCPtr<DOM::DOMTokenList> rel_list();
+    GC::Ref<DOM::DOMTokenList> rel_list();
 
     String action() const;
     WebIDL::ExceptionOr<void> set_action(String const&);
@@ -112,12 +112,12 @@ private:
 
     ErrorOr<String> pick_an_encoding() const;
 
-    ErrorOr<void> mutate_action_url(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
-    ErrorOr<void> submit_as_entity_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
-    void get_action_url(URL::URL parsed_action, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
-    ErrorOr<void> mail_with_headers(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
-    ErrorOr<void> mail_as_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, String encoding, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
-    void plan_to_navigate_to(URL::URL url, Variant<Empty, String, POSTResource> post_resource, JS::NonnullGCPtr<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    ErrorOr<void> mutate_action_url(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    ErrorOr<void> submit_as_entity_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    void get_action_url(URL::URL parsed_action, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    ErrorOr<void> mail_with_headers(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    ErrorOr<void> mail_as_body(URL::URL parsed_action, Vector<XHR::FormDataEntry> entry_list, EncodingTypeAttributeState encoding_type, String encoding, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
+    void plan_to_navigate_to(URL::URL url, Variant<Empty, String, POSTResource> post_resource, GC::Ref<Navigable> target_navigable, Bindings::NavigationHistoryBehavior history_handling, UserNavigationInvolvement user_involvement);
 
     FormAssociatedElement* default_button();
     size_t number_of_fields_blocking_implicit_submission() const;
@@ -127,25 +127,25 @@ private:
     // https://html.spec.whatwg.org/multipage/forms.html#locked-for-reset
     bool m_locked_for_reset { false };
 
-    Vector<JS::NonnullGCPtr<HTMLElement>> m_associated_elements;
+    Vector<GC::Ref<HTMLElement>> m_associated_elements;
 
     // https://html.spec.whatwg.org/multipage/forms.html#past-names-map
     struct PastNameEntry {
-        JS::GCPtr<DOM::Node const> node;
+        GC::Ptr<DOM::Node const> node;
         MonotonicTime insertion_time;
     };
     HashMap<FlyString, PastNameEntry> mutable m_past_names_map;
 
-    JS::GCPtr<HTMLFormControlsCollection> mutable m_elements;
+    GC::Ptr<HTMLFormControlsCollection> mutable m_elements;
 
     bool m_constructing_entry_list { false };
 
     // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#planned-navigation
     // Each form element has a planned navigation, which is either null or a task; when the form is first created,
     // its planned navigation must be set to null.
-    JS::GCPtr<Task const> m_planned_navigation;
+    GC::Ptr<Task const> m_planned_navigation;
 
-    JS::GCPtr<DOM::DOMTokenList> m_rel_list;
+    GC::Ptr<DOM::DOMTokenList> m_rel_list;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLFrameElement.cpp b/Libraries/LibWeb/HTML/HTMLFrameElement.cpp
index 0b76e1ea43a..b3fd4b0bbaf 100644
--- a/Libraries/LibWeb/HTML/HTMLFrameElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFrameElement.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFrameElement);
+GC_DEFINE_ALLOCATOR(HTMLFrameElement);
 
 HTMLFrameElement::HTMLFrameElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : NavigableContainer(document, move(qualified_name))
@@ -48,7 +48,7 @@ void HTMLFrameElement::inserted()
         return;
 
     // 3. Create a new child navigable for insertedNode.
-    MUST(create_new_child_navigable(JS::create_heap_function(realm().heap(), [this] {
+    MUST(create_new_child_navigable(GC::create_function(realm().heap(), [this] {
         // 4. Process the frame attributes for insertedNode, with initialInsertion set to true.
         process_the_frame_attributes(true);
         set_content_navigable_initialized();
diff --git a/Libraries/LibWeb/HTML/HTMLFrameElement.h b/Libraries/LibWeb/HTML/HTMLFrameElement.h
index 42be1fd2289..ba301aca0b2 100644
--- a/Libraries/LibWeb/HTML/HTMLFrameElement.h
+++ b/Libraries/LibWeb/HTML/HTMLFrameElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // NOTE: This element is marked as obsolete, but is still listed as required by the specification.
 class HTMLFrameElement final : public NavigableContainer {
     WEB_PLATFORM_OBJECT(HTMLFrameElement, NavigableContainer);
-    JS_DECLARE_ALLOCATOR(HTMLFrameElement);
+    GC_DECLARE_ALLOCATOR(HTMLFrameElement);
 
 public:
     virtual ~HTMLFrameElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLFrameSetElement.cpp b/Libraries/LibWeb/HTML/HTMLFrameSetElement.cpp
index 1d4b0c7591f..d23b182e4f0 100644
--- a/Libraries/LibWeb/HTML/HTMLFrameSetElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLFrameSetElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLFrameSetElement);
+GC_DEFINE_ALLOCATOR(HTMLFrameSetElement);
 
 HTMLFrameSetElement::HTMLFrameSetElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -47,7 +47,7 @@ void HTMLFrameSetElement::attribute_changed(FlyString const& name, Optional<Stri
 #undef __ENUMERATE
 }
 
-JS::GCPtr<DOM::EventTarget> HTMLFrameSetElement::global_event_handlers_to_event_target(FlyString const& event_name)
+GC::Ptr<DOM::EventTarget> HTMLFrameSetElement::global_event_handlers_to_event_target(FlyString const& event_name)
 {
     // NOTE: This is a little weird, but IIUC document.body.onload actually refers to window.onload
     // NOTE: document.body can return either a HTMLBodyElement or HTMLFrameSetElement, so both these elements must support this mapping.
@@ -57,7 +57,7 @@ JS::GCPtr<DOM::EventTarget> HTMLFrameSetElement::global_event_handlers_to_event_
     return *this;
 }
 
-JS::GCPtr<DOM::EventTarget> HTMLFrameSetElement::window_event_handlers_to_event_target()
+GC::Ptr<DOM::EventTarget> HTMLFrameSetElement::window_event_handlers_to_event_target()
 {
     // All WindowEventHandlers on HTMLFrameSetElement (e.g. document.body.onrejectionhandled) are mapped to window.on{event}.
     // NOTE: document.body can return either a HTMLBodyElement or HTMLFrameSetElement, so both these elements must support this mapping.
diff --git a/Libraries/LibWeb/HTML/HTMLFrameSetElement.h b/Libraries/LibWeb/HTML/HTMLFrameSetElement.h
index da2f4cfdefa..c1f2d90f76b 100644
--- a/Libraries/LibWeb/HTML/HTMLFrameSetElement.h
+++ b/Libraries/LibWeb/HTML/HTMLFrameSetElement.h
@@ -16,7 +16,7 @@ class HTMLFrameSetElement final
     : public HTMLElement
     , public WindowEventHandlers {
     WEB_PLATFORM_OBJECT(HTMLFrameSetElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLFrameSetElement);
+    GC_DECLARE_ALLOCATOR(HTMLFrameSetElement);
 
 public:
     virtual ~HTMLFrameSetElement() override;
@@ -30,10 +30,10 @@ private:
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) override;
+    virtual GC::Ptr<EventTarget> global_event_handlers_to_event_target(FlyString const& event_name) override;
 
     // ^HTML::WindowEventHandlers
-    virtual JS::GCPtr<EventTarget> window_event_handlers_to_event_target() override;
+    virtual GC::Ptr<EventTarget> window_event_handlers_to_event_target() override;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLHRElement.cpp b/Libraries/LibWeb/HTML/HTMLHRElement.cpp
index 4506a82c16a..403a01d3b27 100644
--- a/Libraries/LibWeb/HTML/HTMLHRElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLHRElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLHRElement);
+GC_DEFINE_ALLOCATOR(HTMLHRElement);
 
 HTMLHRElement::HTMLHRElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLHRElement.h b/Libraries/LibWeb/HTML/HTMLHRElement.h
index 728ca47f792..8ed8fafbb67 100644
--- a/Libraries/LibWeb/HTML/HTMLHRElement.h
+++ b/Libraries/LibWeb/HTML/HTMLHRElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLHRElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLHRElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLHRElement);
+    GC_DECLARE_ALLOCATOR(HTMLHRElement);
 
 public:
     virtual ~HTMLHRElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLHeadElement.cpp b/Libraries/LibWeb/HTML/HTMLHeadElement.cpp
index d4b5d095e93..bc0ba06760a 100644
--- a/Libraries/LibWeb/HTML/HTMLHeadElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLHeadElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLHeadElement);
+GC_DEFINE_ALLOCATOR(HTMLHeadElement);
 
 HTMLHeadElement::HTMLHeadElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLHeadElement.h b/Libraries/LibWeb/HTML/HTMLHeadElement.h
index 1c55f26f265..9105033394b 100644
--- a/Libraries/LibWeb/HTML/HTMLHeadElement.h
+++ b/Libraries/LibWeb/HTML/HTMLHeadElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLHeadElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLHeadElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLHeadElement);
+    GC_DECLARE_ALLOCATOR(HTMLHeadElement);
 
 public:
     virtual ~HTMLHeadElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLHeadingElement.cpp b/Libraries/LibWeb/HTML/HTMLHeadingElement.cpp
index 828531da424..5c254546ee2 100644
--- a/Libraries/LibWeb/HTML/HTMLHeadingElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLHeadingElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLHeadingElement);
+GC_DEFINE_ALLOCATOR(HTMLHeadingElement);
 
 HTMLHeadingElement::HTMLHeadingElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLHeadingElement.h b/Libraries/LibWeb/HTML/HTMLHeadingElement.h
index 603fdaa103b..81e81e45ad5 100644
--- a/Libraries/LibWeb/HTML/HTMLHeadingElement.h
+++ b/Libraries/LibWeb/HTML/HTMLHeadingElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLHeadingElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLHeadingElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLHeadingElement);
+    GC_DECLARE_ALLOCATOR(HTMLHeadingElement);
 
 public:
     virtual ~HTMLHeadingElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLHtmlElement.cpp b/Libraries/LibWeb/HTML/HTMLHtmlElement.cpp
index 69482cd4e51..7c300a352d2 100644
--- a/Libraries/LibWeb/HTML/HTMLHtmlElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLHtmlElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLHtmlElement);
+GC_DEFINE_ALLOCATOR(HTMLHtmlElement);
 
 HTMLHtmlElement::HTMLHtmlElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLHtmlElement.h b/Libraries/LibWeb/HTML/HTMLHtmlElement.h
index bbe23579489..ebf5bfd9948 100644
--- a/Libraries/LibWeb/HTML/HTMLHtmlElement.h
+++ b/Libraries/LibWeb/HTML/HTMLHtmlElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLHtmlElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLHtmlElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLHtmlElement);
+    GC_DECLARE_ALLOCATOR(HTMLHtmlElement);
 
 public:
     virtual ~HTMLHtmlElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLIFrameElement.cpp b/Libraries/LibWeb/HTML/HTMLIFrameElement.cpp
index 6a700ed4255..8249a8576c8 100644
--- a/Libraries/LibWeb/HTML/HTMLIFrameElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLIFrameElement.cpp
@@ -18,7 +18,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLIFrameElement);
+GC_DEFINE_ALLOCATOR(HTMLIFrameElement);
 
 HTMLIFrameElement::HTMLIFrameElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : NavigableContainer(document, move(qualified_name))
@@ -33,7 +33,7 @@ void HTMLIFrameElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLIFrameElement);
 }
 
-JS::GCPtr<Layout::Node> HTMLIFrameElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLIFrameElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::FrameBox>(document(), *this, move(style));
 }
@@ -78,7 +78,7 @@ void HTMLIFrameElement::inserted()
         return;
 
     // 2. Create a new child navigable for insertedNode.
-    MUST(create_new_child_navigable(JS::create_heap_function(realm().heap(), [this] {
+    MUST(create_new_child_navigable(GC::create_function(realm().heap(), [this] {
         // FIXME: 3. If insertedNode has a sandbox attribute, then parse the sandboxing directive given the attribute's
         //           value and insertedNode's iframe sandboxing flag set.
 
diff --git a/Libraries/LibWeb/HTML/HTMLIFrameElement.h b/Libraries/LibWeb/HTML/HTMLIFrameElement.h
index caceb6c9724..2fd2c8158e4 100644
--- a/Libraries/LibWeb/HTML/HTMLIFrameElement.h
+++ b/Libraries/LibWeb/HTML/HTMLIFrameElement.h
@@ -18,12 +18,12 @@ class HTMLIFrameElement final
 
     WEB_PLATFORM_OBJECT(HTMLIFrameElement, NavigableContainer);
     LAZY_LOADING_ELEMENT(HTMLIFrameElement);
-    JS_DECLARE_ALLOCATOR(HTMLIFrameElement);
+    GC_DECLARE_ALLOCATOR(HTMLIFrameElement);
 
 public:
     virtual ~HTMLIFrameElement() override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     void set_current_navigation_was_lazy_loaded(bool value);
diff --git a/Libraries/LibWeb/HTML/HTMLImageElement.cpp b/Libraries/LibWeb/HTML/HTMLImageElement.cpp
index cb5e9fbd83d..01ba2c5d944 100644
--- a/Libraries/LibWeb/HTML/HTMLImageElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLImageElement.cpp
@@ -38,7 +38,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLImageElement);
+GC_DEFINE_ALLOCATOR(HTMLImageElement);
 
 HTMLImageElement::HTMLImageElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -112,7 +112,7 @@ void HTMLImageElement::form_associated_element_attribute_changed(FlyString const
     }
 }
 
-JS::GCPtr<Layout::Node> HTMLImageElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLImageElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::ImageBox>(document(), *this, move(style), *this);
 }
@@ -284,7 +284,7 @@ String HTMLImageElement::current_src() const
 }
 
 // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> HTMLImageElement::decode() const
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> HTMLImageElement::decode() const
 {
     auto& realm = this->realm();
 
@@ -292,7 +292,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> HTMLImageElement::decode(
     auto promise = WebIDL::create_promise(realm);
 
     // 2. Queue a microtask to perform the following steps:
-    queue_a_microtask(&document(), JS::create_heap_function(realm.heap(), [this, promise, &realm]() mutable {
+    queue_a_microtask(&document(), GC::create_function(realm.heap(), [this, promise, &realm]() mutable {
         auto reject_if_document_not_fully_active = [this, promise, &realm]() -> bool {
             if (this->document().is_fully_active())
                 return false;
@@ -325,8 +325,8 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> HTMLImageElement::decode(
             return;
 
         // 2.2 Otherwise, in parallel wait for one of the following cases to occur, and perform the corresponding actions:
-        Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [this, promise, &realm, reject_if_document_not_fully_active, reject_if_current_request_state_broken] {
-            Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(heap(), [&] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this, promise, &realm, reject_if_document_not_fully_active, reject_if_current_request_state_broken] {
+            Platform::EventLoopPlugin::the().spin_until(GC::create_function(heap(), [&] {
                 auto state = this->current_request().state();
 
                 return !this->document().is_fully_active() || state == ImageRequest::State::Broken || state == ImageRequest::State::CompletelyAvailable;
@@ -393,7 +393,7 @@ public:
     {
     }
 
-    void enqueue(JS::Handle<JS::HeapFunction<void()>> callback)
+    void enqueue(GC::Root<GC::Function<void()>> callback)
     {
         // NOTE: We don't want to flush the queue on every image load, since that would be slow.
         //       However, we don't want to keep growing the batch forever either.
@@ -413,7 +413,7 @@ private:
     }
 
     NonnullRefPtr<Core::Timer> m_timer;
-    Vector<JS::Handle<JS::HeapFunction<void()>>> m_queue;
+    Vector<GC::Root<GC::Function<void()>>> m_queue;
 };
 
 static BatchingDispatcher& batching_dispatcher()
@@ -519,7 +519,7 @@ ErrorOr<void> HTMLImageElement::update_the_image_data(bool restart_animations, b
     }
 after_step_7:
     // 8. Queue a microtask to perform the rest of this algorithm, allowing the task that invoked this algorithm to continue.
-    queue_a_microtask(&document(), JS::create_heap_function(this->heap(), [this, restart_animations, maybe_omit_events, previous_url]() mutable {
+    queue_a_microtask(&document(), GC::create_function(this->heap(), [this, restart_animations, maybe_omit_events, previous_url]() mutable {
         // FIXME: 9. If another instance of this algorithm for this img element was started after this instance
         //           (even if it aborted and is no longer running), then return.
 
@@ -674,11 +674,11 @@ after_step_7:
     return {};
 }
 
-void HTMLImageElement::add_callbacks_to_image_request(JS::NonnullGCPtr<ImageRequest> image_request, bool maybe_omit_events, URL::URL const& url_string, URL::URL const& previous_url)
+void HTMLImageElement::add_callbacks_to_image_request(GC::Ref<ImageRequest> image_request, bool maybe_omit_events, URL::URL const& url_string, URL::URL const& previous_url)
 {
     image_request->add_callbacks(
         [this, image_request, maybe_omit_events, url_string, previous_url]() {
-            batching_dispatcher().enqueue(JS::create_heap_function(realm().heap(), [this, image_request, maybe_omit_events, url_string, previous_url] {
+            batching_dispatcher().enqueue(GC::create_function(realm().heap(), [this, image_request, maybe_omit_events, url_string, previous_url] {
                 VERIFY(image_request->shared_resource_request());
                 auto image_data = image_request->shared_resource_request()->image_data();
                 image_request->set_image_data(image_data);
@@ -748,7 +748,7 @@ void HTMLImageElement::did_set_viewport_rect(CSSPixelRect const& viewport_rect)
     if (viewport_rect.size() == m_last_seen_viewport_size)
         return;
     m_last_seen_viewport_size = viewport_rect.size();
-    batching_dispatcher().enqueue(JS::create_heap_function(realm().heap(), [this] {
+    batching_dispatcher().enqueue(GC::create_function(realm().heap(), [this] {
         react_to_changes_in_the_environment();
     }));
 }
@@ -818,7 +818,7 @@ void HTMLImageElement::react_to_changes_in_the_environment()
 
     // FIXME: 13. End the synchronous section, continuing the remaining steps in parallel.
 
-    auto step_15 = [this](String const& selected_source, JS::NonnullGCPtr<ImageRequest> image_request, ListOfAvailableImages::Key const& key, JS::NonnullGCPtr<DecodedImageData> image_data) {
+    auto step_15 = [this](String const& selected_source, GC::Ref<ImageRequest> image_request, ListOfAvailableImages::Key const& key, GC::Ref<DecodedImageData> image_data) {
         // 15. Queue an element task on the DOM manipulation task source given the img element and the following steps:
         queue_an_element_task(HTML::Task::Source::DOMManipulation, [this, selected_source, image_request, key, image_data] {
             // 1. FIXME: If the img element has experienced relevant mutations since this algorithm started, then let pending request be null and abort these steps.
@@ -886,7 +886,7 @@ void HTMLImageElement::react_to_changes_in_the_environment()
 
                 // then let pending request be null and abort these steps.
 
-                batching_dispatcher().enqueue(JS::create_heap_function(realm().heap(), [step_15, selected_source = move(selected_source), image_request, key] {
+                batching_dispatcher().enqueue(GC::create_function(realm().heap(), [step_15, selected_source = move(selected_source), image_request, key] {
                     // 7. Otherwise, response's unsafe response is image request's image data. It can be either CORS-same-origin
                     //    or CORS-cross-origin; this affects the image's interaction with other APIs (e.g., when used on a canvas).
                     VERIFY(image_request->shared_resource_request());
@@ -979,7 +979,7 @@ static void update_the_source_set(DOM::Element& element)
         TODO();
 
     // 2. Let elements be « el ».
-    JS::MarkedVector<DOM::Element*> elements(element.heap());
+    GC::MarkedVector<DOM::Element*> elements(element.heap());
     elements.append(&element);
 
     // 3. If el is an img element whose parent node is a picture element,
diff --git a/Libraries/LibWeb/HTML/HTMLImageElement.h b/Libraries/LibWeb/HTML/HTMLImageElement.h
index d0f6bf3b071..d6bc229c9ae 100644
--- a/Libraries/LibWeb/HTML/HTMLImageElement.h
+++ b/Libraries/LibWeb/HTML/HTMLImageElement.h
@@ -9,9 +9,9 @@
 
 #include <AK/ByteBuffer.h>
 #include <AK/OwnPtr.h>
+#include <LibGC/Function.h>
 #include <LibGfx/Forward.h>
 #include <LibGfx/ImmutableBitmap.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/DOM/Document.h>
 #include <LibWeb/DOM/DocumentLoadEventDelayer.h>
 #include <LibWeb/HTML/BrowsingContext.h>
@@ -31,7 +31,7 @@ class HTMLImageElement final
     , public Layout::ImageProvider
     , public DOM::Document::ViewportClient {
     WEB_PLATFORM_OBJECT(HTMLImageElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLImageElement);
+    GC_DECLARE_ALLOCATOR(HTMLImageElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLImageElement);
     LAZY_LOADING_ELEMENT(HTMLImageElement);
 
@@ -68,7 +68,7 @@ public:
     String current_src() const;
 
     // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decode
-    [[nodiscard]] WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> decode() const;
+    [[nodiscard]] WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> decode() const;
 
     virtual Optional<ARIA::Role> default_role() const override;
 
@@ -111,7 +111,7 @@ public:
     virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
     virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
     virtual void set_visible_in_viewport(bool) override;
-    virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const override { return *this; }
+    virtual GC::Ref<DOM::Element const> to_html_element() const override { return *this; }
 
     virtual void visit_edges(Cell::Visitor&) override;
 
@@ -130,14 +130,14 @@ private:
     // https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element:dimension-attributes
     virtual bool supports_dimension_attributes() const override { return true; }
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     virtual void did_set_viewport_rect(CSSPixelRect const&) override;
 
     void handle_successful_fetch(URL::URL const&, StringView mime_type, ImageRequest&, ByteBuffer, bool maybe_omit_events, URL::URL const& previous_url);
     void handle_failed_fetch();
-    void add_callbacks_to_image_request(JS::NonnullGCPtr<ImageRequest>, bool maybe_omit_events, URL::URL const& url_string, URL::URL const& previous_url);
+    void add_callbacks_to_image_request(GC::Ref<ImageRequest>, bool maybe_omit_events, URL::URL const& url_string, URL::URL const& previous_url);
 
     void animate();
 
@@ -154,10 +154,10 @@ private:
     Optional<String> m_last_selected_source;
 
     // https://html.spec.whatwg.org/multipage/images.html#current-request
-    JS::GCPtr<ImageRequest> m_current_request;
+    GC::Ptr<ImageRequest> m_current_request;
 
     // https://html.spec.whatwg.org/multipage/images.html#pending-request
-    JS::GCPtr<ImageRequest> m_pending_request;
+    GC::Ptr<ImageRequest> m_pending_request;
 
     SourceSet m_source_set;
 
diff --git a/Libraries/LibWeb/HTML/HTMLInputElement.cpp b/Libraries/LibWeb/HTML/HTMLInputElement.cpp
index fffa5f151f0..df197314de7 100644
--- a/Libraries/LibWeb/HTML/HTMLInputElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLInputElement.cpp
@@ -55,7 +55,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLInputElement);
+GC_DEFINE_ALLOCATOR(HTMLInputElement);
 
 HTMLInputElement::HTMLInputElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -89,7 +89,7 @@ void HTMLInputElement::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#dom-cva-validity
-JS::NonnullGCPtr<ValidityState const> HTMLInputElement::validity() const
+GC::Ref<ValidityState const> HTMLInputElement::validity() const
 {
     auto& realm = this->realm();
 
@@ -98,7 +98,7 @@ JS::NonnullGCPtr<ValidityState const> HTMLInputElement::validity() const
     return realm.create<ValidityState>(realm);
 }
 
-JS::GCPtr<Layout::Node> HTMLInputElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLInputElement::create_layout_node(CSS::StyleProperties style)
 {
     if (type_state() == TypeAttributeState::Hidden)
         return nullptr;
@@ -194,7 +194,7 @@ void HTMLInputElement::set_indeterminate(bool value)
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#dom-input-files
-JS::GCPtr<FileAPI::FileList> HTMLInputElement::files()
+GC::Ptr<FileAPI::FileList> HTMLInputElement::files()
 {
     // On getting, if the IDL attribute applies, it must return a FileList object that represents the current selected files.
     //  The same object must be returned until the list of selected files changes.
@@ -208,7 +208,7 @@ JS::GCPtr<FileAPI::FileList> HTMLInputElement::files()
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#dom-input-files
-void HTMLInputElement::set_files(JS::GCPtr<FileAPI::FileList> files)
+void HTMLInputElement::set_files(GC::Ptr<FileAPI::FileList> files)
 {
     // 1. If the IDL attribute does not apply or the given value is null, then return.
     if (m_type != TypeAttributeState::FileUpload || files == nullptr)
@@ -258,7 +258,7 @@ FileFilter HTMLInputElement::parse_accept_attribute() const
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#update-the-file-selection
-void HTMLInputElement::update_the_file_selection(JS::NonnullGCPtr<FileAPI::FileList> files)
+void HTMLInputElement::update_the_file_selection(GC::Ref<FileAPI::FileList> files)
 {
     // 1. Queue an element task on the user interaction task source given element and the following steps:
     queue_an_element_task(Task::Source::UserInteraction, [this, files] {
@@ -378,7 +378,7 @@ WebIDL::ExceptionOr<void> HTMLInputElement::run_input_activation_behavior(DOM::E
         change_event->set_bubbles(true);
         dispatch_event(*change_event);
     } else if (type_state() == TypeAttributeState::SubmitButton) {
-        JS::GCPtr<HTMLFormElement> form;
+        GC::Ptr<HTMLFormElement> form;
         // 1. If the element does not have a form owner, then return.
         if (!(form = this->form()))
             return {};
@@ -508,7 +508,7 @@ void HTMLInputElement::did_select_files(Span<SelectedFile> selected_files, Multi
         FileAPI::FilePropertyBag options {};
         options.type = mime_type.essence();
 
-        auto file = MUST(FileAPI::File::create(realm(), { JS::make_handle(blob) }, file_name, move(options)));
+        auto file = MUST(FileAPI::File::create(realm(), { GC::make_root(blob) }, file_name, move(options)));
         files->add_file(file);
     }
 
@@ -1772,7 +1772,7 @@ void HTMLInputElement::legacy_cancelled_activation_behavior_was_not_called()
     m_legacy_pre_activation_behavior_checked_element_in_group = nullptr;
 }
 
-JS::GCPtr<DecodedImageData> HTMLInputElement::image_data() const
+GC::Ptr<DecodedImageData> HTMLInputElement::image_data() const
 {
     if (m_resource_request)
         return m_resource_request->image_data();
@@ -1905,7 +1905,7 @@ String HTMLInputElement::convert_number_to_string(double input) const
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#concept-input-value-string-date
-WebIDL::ExceptionOr<JS::GCPtr<JS::Date>> HTMLInputElement::convert_string_to_date(StringView input) const
+WebIDL::ExceptionOr<GC::Ptr<JS::Date>> HTMLInputElement::convert_string_to_date(StringView input) const
 {
     // https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):concept-input-value-string-date
     if (type_state() == TypeAttributeState::Date) {
@@ -1934,7 +1934,7 @@ WebIDL::ExceptionOr<JS::GCPtr<JS::Date>> HTMLInputElement::convert_string_to_dat
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#concept-input-value-date-string
-String HTMLInputElement::covert_date_to_string(JS::NonnullGCPtr<JS::Date> input) const
+String HTMLInputElement::covert_date_to_string(GC::Ref<JS::Date> input) const
 {
     // https://html.spec.whatwg.org/multipage/input.html#date-state-(type=date):concept-input-value-date-string
     if (type_state() == TypeAttributeState::Date) {
@@ -2094,7 +2094,7 @@ JS::Object* HTMLInputElement::value_as_date() const
 }
 
 // https://html.spec.whatwg.org/multipage/input.html#dom-input-valueasdate
-WebIDL::ExceptionOr<void> HTMLInputElement::set_value_as_date(Optional<JS::Handle<JS::Object>> const& value)
+WebIDL::ExceptionOr<void> HTMLInputElement::set_value_as_date(Optional<GC::Root<JS::Object>> const& value)
 {
     // On setting, if the valueAsDate attribute does not apply, as defined for the input element's type attribute's current state, then throw an "InvalidStateError" DOMException;
     if (!value_as_date_applies())
diff --git a/Libraries/LibWeb/HTML/HTMLInputElement.h b/Libraries/LibWeb/HTML/HTMLInputElement.h
index 0ada814c15a..599e046cce4 100644
--- a/Libraries/LibWeb/HTML/HTMLInputElement.h
+++ b/Libraries/LibWeb/HTML/HTMLInputElement.h
@@ -52,13 +52,13 @@ class HTMLInputElement final
     , public FormAssociatedTextControlElement
     , public Layout::ImageProvider {
     WEB_PLATFORM_OBJECT(HTMLInputElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLInputElement);
+    GC_DECLARE_ALLOCATOR(HTMLInputElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLInputElement)
 
 public:
     virtual ~HTMLInputElement() override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     enum class TypeAttributeState {
@@ -110,14 +110,14 @@ public:
     };
     void did_select_files(Span<SelectedFile> selected_files, MultipleHandling = MultipleHandling::Replace);
 
-    JS::GCPtr<FileAPI::FileList> files();
-    void set_files(JS::GCPtr<FileAPI::FileList>);
+    GC::Ptr<FileAPI::FileList> files();
+    void set_files(GC::Ptr<FileAPI::FileList>);
 
     FileFilter parse_accept_attribute() const;
 
     // NOTE: User interaction
     // https://html.spec.whatwg.org/multipage/input.html#update-the-file-selection
-    void update_the_file_selection(JS::NonnullGCPtr<FileAPI::FileList>);
+    void update_the_file_selection(GC::Ref<FileAPI::FileList>);
 
     WebIDL::Long max_length() const;
     WebIDL::ExceptionOr<void> set_max_length(WebIDL::Long);
@@ -135,7 +135,7 @@ public:
     SelectedCoordinate selected_coordinate() const { return m_selected_coordinate; }
 
     JS::Object* value_as_date() const;
-    WebIDL::ExceptionOr<void> set_value_as_date(Optional<JS::Handle<JS::Object>> const&);
+    WebIDL::ExceptionOr<void> set_value_as_date(Optional<GC::Root<JS::Object>> const&);
 
     double value_as_number() const;
     WebIDL::ExceptionOr<void> set_value_as_number(double value);
@@ -185,7 +185,7 @@ public:
 
     virtual WebIDL::ExceptionOr<void> cloned(Node&, bool) override;
 
-    JS::NonnullGCPtr<ValidityState const> validity() const;
+    GC::Ref<ValidityState const> validity() const;
 
     // ^HTMLElement
     // https://html.spec.whatwg.org/multipage/forms.html#category-label
@@ -193,8 +193,8 @@ public:
 
     virtual Optional<ARIA::Role> default_role() const override;
 
-    JS::GCPtr<Element> placeholder_element() { return m_placeholder_element; }
-    JS::GCPtr<Element const> placeholder_element() const { return m_placeholder_element; }
+    GC::Ptr<Element> placeholder_element() { return m_placeholder_element; }
+    GC::Ptr<Element const> placeholder_element() const { return m_placeholder_element; }
 
     virtual bool has_activation_behavior() const override;
     virtual void activation_behavior(DOM::Event const&) override;
@@ -216,7 +216,7 @@ public:
 
     // ^FormAssociatedTextControlElement
     virtual void did_edit_text_node() override;
-    virtual JS::GCPtr<DOM::Text> form_associated_element_to_text_node() override { return m_text_node; }
+    virtual GC::Ptr<DOM::Text> form_associated_element_to_text_node() override { return m_text_node; }
 
 private:
     HTMLInputElement(DOM::Document&, DOM::QualifiedName);
@@ -249,7 +249,7 @@ private:
     virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
     virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
     virtual void set_visible_in_viewport(bool) override;
-    virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const override { return *this; }
+    virtual GC::Ref<DOM::Element const> to_html_element() const override { return *this; }
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -257,8 +257,8 @@ private:
     Optional<double> convert_string_to_number(StringView input) const;
     String convert_number_to_string(double input) const;
 
-    WebIDL::ExceptionOr<JS::GCPtr<JS::Date>> convert_string_to_date(StringView input) const;
-    String covert_date_to_string(JS::NonnullGCPtr<JS::Date> input) const;
+    WebIDL::ExceptionOr<GC::Ptr<JS::Date>> convert_string_to_date(StringView input) const;
+    String covert_date_to_string(GC::Ref<JS::Date> input) const;
 
     Optional<double> min() const;
     Optional<double> max() const;
@@ -298,28 +298,28 @@ private:
     ValueAttributeMode value_attribute_mode() const;
 
     void update_placeholder_visibility();
-    JS::GCPtr<DOM::Element> m_placeholder_element;
-    JS::GCPtr<DOM::Text> m_placeholder_text_node;
+    GC::Ptr<DOM::Element> m_placeholder_element;
+    GC::Ptr<DOM::Text> m_placeholder_text_node;
 
     void update_text_input_shadow_tree();
-    JS::GCPtr<DOM::Element> m_inner_text_element;
-    JS::GCPtr<DOM::Text> m_text_node;
+    GC::Ptr<DOM::Element> m_inner_text_element;
+    GC::Ptr<DOM::Text> m_text_node;
     bool m_checked { false };
 
     void update_color_well_element();
-    JS::GCPtr<DOM::Element> m_color_well_element;
+    GC::Ptr<DOM::Element> m_color_well_element;
 
     void update_file_input_shadow_tree();
-    JS::GCPtr<DOM::Element> m_file_button;
-    JS::GCPtr<DOM::Element> m_file_label;
+    GC::Ptr<DOM::Element> m_file_button;
+    GC::Ptr<DOM::Element> m_file_label;
 
     void update_slider_shadow_tree_elements();
-    JS::GCPtr<DOM::Element> m_slider_runnable_track;
-    JS::GCPtr<DOM::Element> m_slider_progress_element;
-    JS::GCPtr<DOM::Element> m_slider_thumb;
+    GC::Ptr<DOM::Element> m_slider_runnable_track;
+    GC::Ptr<DOM::Element> m_slider_progress_element;
+    GC::Ptr<DOM::Element> m_slider_thumb;
 
-    JS::GCPtr<DecodedImageData> image_data() const;
-    JS::GCPtr<SharedResourceRequest> m_resource_request;
+    GC::Ptr<DecodedImageData> image_data() const;
+    GC::Ptr<SharedResourceRequest> m_resource_request;
     SelectedCoordinate m_selected_coordinate;
 
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
@@ -339,10 +339,10 @@ private:
     // https://html.spec.whatwg.org/multipage/input.html#the-input-element:legacy-pre-activation-behavior
     bool m_before_legacy_pre_activation_behavior_checked { false };
     bool m_before_legacy_pre_activation_behavior_indeterminate { false };
-    JS::GCPtr<HTMLInputElement> m_legacy_pre_activation_behavior_checked_element_in_group;
+    GC::Ptr<HTMLInputElement> m_legacy_pre_activation_behavior_checked_element_in_group;
 
     // https://html.spec.whatwg.org/multipage/input.html#concept-input-type-file-selected
-    JS::GCPtr<FileAPI::FileList> m_selected_files;
+    GC::Ptr<FileAPI::FileList> m_selected_files;
 
     TypeAttributeState m_type { TypeAttributeState::Text };
     String m_value;
diff --git a/Libraries/LibWeb/HTML/HTMLLIElement.cpp b/Libraries/LibWeb/HTML/HTMLLIElement.cpp
index 6d385359fd3..d06806fca36 100644
--- a/Libraries/LibWeb/HTML/HTMLLIElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLLIElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLLIElement);
+GC_DEFINE_ALLOCATOR(HTMLLIElement);
 
 HTMLLIElement::HTMLLIElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLLIElement.h b/Libraries/LibWeb/HTML/HTMLLIElement.h
index e12879c39e8..8c85e5d0110 100644
--- a/Libraries/LibWeb/HTML/HTMLLIElement.h
+++ b/Libraries/LibWeb/HTML/HTMLLIElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLLIElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLLIElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLLIElement);
+    GC_DECLARE_ALLOCATOR(HTMLLIElement);
 
 public:
     virtual ~HTMLLIElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLLabelElement.cpp b/Libraries/LibWeb/HTML/HTMLLabelElement.cpp
index c497a942506..6045d5e57cb 100644
--- a/Libraries/LibWeb/HTML/HTMLLabelElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLLabelElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLLabelElement);
+GC_DEFINE_ALLOCATOR(HTMLLabelElement);
 
 HTMLLabelElement::HTMLLabelElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -27,15 +27,15 @@ void HTMLLabelElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(HTMLLabelElement);
 }
 
-JS::GCPtr<Layout::Node> HTMLLabelElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLLabelElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::Label>(document(), this, move(style));
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#labeled-control
-JS::GCPtr<HTMLElement> HTMLLabelElement::control() const
+GC::Ptr<HTMLElement> HTMLLabelElement::control() const
 {
-    JS::GCPtr<HTMLElement> control;
+    GC::Ptr<HTMLElement> control;
 
     // The for attribute may be specified to indicate a form control with which the caption is
     // to be associated. If the attribute is specified, the attribute's value must be the ID of
@@ -68,7 +68,7 @@ JS::GCPtr<HTMLElement> HTMLLabelElement::control() const
 }
 
 // https://html.spec.whatwg.org/multipage/forms.html#dom-label-form
-JS::GCPtr<HTMLFormElement> HTMLLabelElement::form() const
+GC::Ptr<HTMLFormElement> HTMLLabelElement::form() const
 {
     auto labeled_control = control();
 
diff --git a/Libraries/LibWeb/HTML/HTMLLabelElement.h b/Libraries/LibWeb/HTML/HTMLLabelElement.h
index ee02b60f52e..76fcc3fc1c9 100644
--- a/Libraries/LibWeb/HTML/HTMLLabelElement.h
+++ b/Libraries/LibWeb/HTML/HTMLLabelElement.h
@@ -12,17 +12,17 @@ namespace Web::HTML {
 
 class HTMLLabelElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLLabelElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLLabelElement);
+    GC_DECLARE_ALLOCATOR(HTMLLabelElement);
 
 public:
     virtual ~HTMLLabelElement() override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     Optional<String> for_() const { return attribute(HTML::AttributeNames::for_); }
 
-    JS::GCPtr<HTMLElement> control() const;
-    JS::GCPtr<HTMLFormElement> form() const;
+    GC::Ptr<HTMLElement> control() const;
+    GC::Ptr<HTMLFormElement> form() const;
 
 private:
     HTMLLabelElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/HTML/HTMLLegendElement.cpp b/Libraries/LibWeb/HTML/HTMLLegendElement.cpp
index 468ba3d8e45..6f691d15089 100644
--- a/Libraries/LibWeb/HTML/HTMLLegendElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLLegendElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLLegendElement);
+GC_DEFINE_ALLOCATOR(HTMLLegendElement);
 
 HTMLLegendElement::HTMLLegendElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLLegendElement.h b/Libraries/LibWeb/HTML/HTMLLegendElement.h
index 4bf0350e507..0623061fec7 100644
--- a/Libraries/LibWeb/HTML/HTMLLegendElement.h
+++ b/Libraries/LibWeb/HTML/HTMLLegendElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLLegendElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLLegendElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLLegendElement);
+    GC_DECLARE_ALLOCATOR(HTMLLegendElement);
 
 public:
     virtual ~HTMLLegendElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLLinkElement.cpp b/Libraries/LibWeb/HTML/HTMLLinkElement.cpp
index cc94852eb85..79906b42cbf 100644
--- a/Libraries/LibWeb/HTML/HTMLLinkElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLLinkElement.cpp
@@ -34,7 +34,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLLinkElement);
+GC_DEFINE_ALLOCATOR(HTMLLinkElement);
 
 HTMLLinkElement::HTMLLinkElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -116,7 +116,7 @@ WebIDL::ExceptionOr<void> HTMLLinkElement::set_as(String const& value)
 }
 
 // https://html.spec.whatwg.org/multipage/semantics.html#dom-link-rellist
-JS::NonnullGCPtr<DOM::DOMTokenList> HTMLLinkElement::rel_list()
+GC::Ref<DOM::DOMTokenList> HTMLLinkElement::rel_list()
 {
     // The relList IDL attribute must reflect the rel content attribute.
     if (!m_rel_list)
@@ -263,7 +263,7 @@ HTMLLinkElement::LinkProcessingOptions HTMLLinkElement::create_link_options()
 }
 
 // https://html.spec.whatwg.org/multipage/semantics.html#create-a-link-request
-JS::GCPtr<Fetch::Infrastructure::Request> HTMLLinkElement::create_link_request(HTMLLinkElement::LinkProcessingOptions const& options)
+GC::Ptr<Fetch::Infrastructure::Request> HTMLLinkElement::create_link_request(HTMLLinkElement::LinkProcessingOptions const& options)
 {
     // 1. Assert: options's href is not the empty string.
     VERIFY(!options.href.is_empty());
@@ -527,13 +527,13 @@ void HTMLLinkElement::resource_did_load_favicon()
     document().check_favicon_after_loading_link_resource();
 }
 
-static NonnullRefPtr<Core::Promise<Web::Platform::DecodedImage>> decode_favicon(ReadonlyBytes favicon_data, URL::URL const& favicon_url, JS::NonnullGCPtr<DOM::Document> document)
+static NonnullRefPtr<Core::Promise<Web::Platform::DecodedImage>> decode_favicon(ReadonlyBytes favicon_data, URL::URL const& favicon_url, GC::Ref<DOM::Document> document)
 {
     auto on_failed_decode = [favicon_url]([[maybe_unused]] Error& error) {
         dbgln_if(IMAGE_DECODER_DEBUG, "Failed to decode favicon {}: {}", favicon_url, error);
     };
 
-    auto on_successful_decode = [document = JS::Handle(document)](Web::Platform::DecodedImage& decoded_image) -> ErrorOr<void> {
+    auto on_successful_decode = [document = GC::Root(document)](Web::Platform::DecodedImage& decoded_image) -> ErrorOr<void> {
         auto favicon_bitmap = decoded_image.frames[0].bitmap;
         dbgln_if(IMAGE_DECODER_DEBUG, "Decoded favicon, {}", favicon_bitmap->size());
 
@@ -561,7 +561,7 @@ bool HTMLLinkElement::load_favicon_and_use_if_window_is_active()
 }
 
 // https://html.spec.whatwg.org/multipage/links.html#rel-icon:the-link-element-3
-WebIDL::ExceptionOr<void> HTMLLinkElement::load_fallback_favicon_if_needed(JS::NonnullGCPtr<DOM::Document> document)
+WebIDL::ExceptionOr<void> HTMLLinkElement::load_fallback_favicon_if_needed(GC::Ref<DOM::Document> document)
 {
     auto& realm = document->realm();
     auto& vm = realm.vm();
@@ -586,14 +586,14 @@ WebIDL::ExceptionOr<void> HTMLLinkElement::load_fallback_favicon_if_needed(JS::N
 
     // 2. Let response be the result of fetching request.
     Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
-    fetch_algorithms_input.process_response = [document, request](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+    fetch_algorithms_input.process_response = [document, request](GC::Ref<Fetch::Infrastructure::Response> response) {
         auto& realm = document->realm();
-        auto global = JS::NonnullGCPtr { realm.global_object() };
+        auto global = GC::Ref { realm.global_object() };
 
-        auto process_body = JS::create_heap_function(realm.heap(), [document, request](ByteBuffer body) {
+        auto process_body = GC::create_function(realm.heap(), [document, request](ByteBuffer body) {
             (void)decode_favicon(body, request->url(), document);
         });
-        auto process_body_error = JS::create_heap_function(realm.heap(), [](JS::Value) {
+        auto process_body_error = GC::create_function(realm.heap(), [](JS::Value) {
         });
 
         // Check for failed favicon response
diff --git a/Libraries/LibWeb/HTML/HTMLLinkElement.h b/Libraries/LibWeb/HTML/HTMLLinkElement.h
index c25e63b2843..11defb3d60e 100644
--- a/Libraries/LibWeb/HTML/HTMLLinkElement.h
+++ b/Libraries/LibWeb/HTML/HTMLLinkElement.h
@@ -22,7 +22,7 @@ class HTMLLinkElement final
     : public HTMLElement
     , public ResourceClient {
     WEB_PLATFORM_OBJECT(HTMLLinkElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLLinkElement);
+    GC_DECLARE_ALLOCATOR(HTMLLinkElement);
 
 public:
     virtual ~HTMLLinkElement() override;
@@ -36,12 +36,12 @@ public:
     String as() const;
     WebIDL::ExceptionOr<void> set_as(String const&);
 
-    JS::NonnullGCPtr<DOM::DOMTokenList> rel_list();
+    GC::Ref<DOM::DOMTokenList> rel_list();
 
     bool has_loaded_icon() const;
     bool load_favicon_and_use_if_window_is_active();
 
-    static WebIDL::ExceptionOr<void> load_fallback_favicon_if_needed(JS::NonnullGCPtr<DOM::Document>);
+    static WebIDL::ExceptionOr<void> load_fallback_favicon_if_needed(GC::Ref<DOM::Document>);
 
 private:
     HTMLLinkElement(DOM::Document&, DOM::QualifiedName);
@@ -89,13 +89,13 @@ private:
         URL::Origin origin;
         // environment
         //      An environment
-        JS::GCPtr<HTML::EnvironmentSettingsObject> environment;
+        GC::Ptr<HTML::EnvironmentSettingsObject> environment;
         // policy container
         //      A policy container
         HTML::PolicyContainer policy_container;
         // document (default null)
         //      Null or a Document
-        JS::GCPtr<Web::DOM::Document> document;
+        GC::Ptr<Web::DOM::Document> document;
         // FIXME: on document ready (default null)
         //          Null or an algorithm accepting a Document
         // fetch priority (default auto)
@@ -107,7 +107,7 @@ private:
     LinkProcessingOptions create_link_options();
 
     // https://html.spec.whatwg.org/multipage/semantics.html#create-a-link-request
-    JS::GCPtr<Fetch::Infrastructure::Request> create_link_request(LinkProcessingOptions const&);
+    GC::Ptr<Fetch::Infrastructure::Request> create_link_request(LinkProcessingOptions const&);
 
     // https://html.spec.whatwg.org/multipage/semantics.html#linked-resource-fetch-setup-steps
     bool linked_resource_fetch_setup_steps(Fetch::Infrastructure::Request&);
@@ -140,12 +140,12 @@ private:
         };
     };
 
-    JS::GCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
 
-    JS::GCPtr<CSS::CSSStyleSheet> m_loaded_style_sheet;
+    GC::Ptr<CSS::CSSStyleSheet> m_loaded_style_sheet;
 
     Optional<DOM::DocumentLoadEventDelayer> m_document_load_event_delayer;
-    JS::GCPtr<DOM::DOMTokenList> m_rel_list;
+    GC::Ptr<DOM::DOMTokenList> m_rel_list;
     unsigned m_relationship { 0 };
     // https://html.spec.whatwg.org/multipage/semantics.html#explicitly-enabled
     bool m_explicitly_enabled { false };
diff --git a/Libraries/LibWeb/HTML/HTMLMapElement.cpp b/Libraries/LibWeb/HTML/HTMLMapElement.cpp
index 2cbcdc9b265..4c7b02c755d 100644
--- a/Libraries/LibWeb/HTML/HTMLMapElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMapElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLMapElement);
+GC_DEFINE_ALLOCATOR(HTMLMapElement);
 
 HTMLMapElement::HTMLMapElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -33,7 +33,7 @@ void HTMLMapElement::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/image-maps.html#dom-map-areas
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLMapElement::areas()
+GC::Ref<DOM::HTMLCollection> HTMLMapElement::areas()
 {
     // The areas attribute must return an HTMLCollection rooted at the map element, whose filter matches only area elements.
     if (!m_areas) {
diff --git a/Libraries/LibWeb/HTML/HTMLMapElement.h b/Libraries/LibWeb/HTML/HTMLMapElement.h
index d6986176ff6..0345c08525e 100644
--- a/Libraries/LibWeb/HTML/HTMLMapElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMapElement.h
@@ -13,12 +13,12 @@ namespace Web::HTML {
 
 class HTMLMapElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLMapElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLMapElement);
+    GC_DECLARE_ALLOCATOR(HTMLMapElement);
 
 public:
     virtual ~HTMLMapElement() override;
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> areas();
+    GC::Ref<DOM::HTMLCollection> areas();
 
 private:
     HTMLMapElement(DOM::Document&, DOM::QualifiedName);
@@ -26,7 +26,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::HTMLCollection> m_areas;
+    GC::Ptr<DOM::HTMLCollection> m_areas;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLMarqueeElement.cpp b/Libraries/LibWeb/HTML/HTMLMarqueeElement.cpp
index 9aaab2bda73..435da552192 100644
--- a/Libraries/LibWeb/HTML/HTMLMarqueeElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMarqueeElement.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLMarqueeElement);
+GC_DEFINE_ALLOCATOR(HTMLMarqueeElement);
 
 HTMLMarqueeElement::HTMLMarqueeElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLMarqueeElement.h b/Libraries/LibWeb/HTML/HTMLMarqueeElement.h
index 63e3352ee01..dd9c9399b64 100644
--- a/Libraries/LibWeb/HTML/HTMLMarqueeElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMarqueeElement.h
@@ -15,7 +15,7 @@ namespace Web::HTML {
 // NOTE: This element is marked as obsolete, but is still listed as required by the specification.
 class HTMLMarqueeElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLMarqueeElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLMarqueeElement);
+    GC_DECLARE_ALLOCATOR(HTMLMarqueeElement);
 
 public:
     virtual ~HTMLMarqueeElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLMediaElement.cpp b/Libraries/LibWeb/HTML/HTMLMediaElement.cpp
index 3aa8f162925..e59fec5dd2f 100644
--- a/Libraries/LibWeb/HTML/HTMLMediaElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMediaElement.cpp
@@ -162,7 +162,7 @@ void HTMLMediaElement::set_decoder_error(String error_message)
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-media-buffered
-JS::NonnullGCPtr<TimeRanges> HTMLMediaElement::buffered() const
+GC::Ref<TimeRanges> HTMLMediaElement::buffered() const
 {
     auto& realm = this->realm();
 
@@ -332,7 +332,7 @@ void HTMLMediaElement::set_duration(double duration)
         paintable->set_needs_display();
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> HTMLMediaElement::play()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> HTMLMediaElement::play()
 {
     auto& realm = this->realm();
 
@@ -458,7 +458,7 @@ double HTMLMediaElement::effective_media_volume() const
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-media-addtexttrack
-JS::NonnullGCPtr<TextTrack> HTMLMediaElement::add_text_track(Bindings::TextTrackKind kind, String const& label, String const& language)
+GC::Ref<TextTrack> HTMLMediaElement::add_text_track(Bindings::TextTrackKind kind, String const& label, String const& language)
 {
     // 1. Create a new TextTrack object.
     auto text_track = TextTrack::create(this->realm());
@@ -483,7 +483,7 @@ JS::NonnullGCPtr<TextTrack> HTMLMediaElement::add_text_track(Bindings::TextTrack
     //    text track's TextTrack object.
     queue_a_media_element_task([this, text_track] {
         TrackEventInit event_init {};
-        event_init.track = JS::make_handle(text_track);
+        event_init.track = GC::make_root(text_track);
 
         auto event = TrackEvent::create(this->realm(), HTML::EventNames::addtrack, move(event_init));
         m_text_tracks->dispatch_event(event);
@@ -593,11 +593,11 @@ enum class SelectMode {
 };
 
 class SourceElementSelector final : public JS::Cell {
-    JS_CELL(SourceElementSelector, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SourceElementSelector);
+    GC_CELL(SourceElementSelector, JS::Cell);
+    GC_DECLARE_ALLOCATOR(SourceElementSelector);
 
 public:
-    SourceElementSelector(JS::NonnullGCPtr<HTMLMediaElement> media_element, JS::NonnullGCPtr<HTMLSourceElement> candidate)
+    SourceElementSelector(GC::Ref<HTMLMediaElement> media_element, GC::Ref<HTMLSourceElement> candidate)
         : m_media_element(media_element)
         , m_candidate(candidate)
     {
@@ -682,10 +682,10 @@ private:
         return {};
     }
 
-    WebIDL::ExceptionOr<void> find_next_candidate(JS::NonnullGCPtr<DOM::Node> previous_candidate)
+    WebIDL::ExceptionOr<void> find_next_candidate(GC::Ref<DOM::Node> previous_candidate)
     {
         // 12. ⌛ Find next candidate: Let candidate be null.
-        JS::GCPtr<HTMLSourceElement> candidate;
+        GC::Ptr<HTMLSourceElement> candidate;
 
         // 13. ⌛ Search loop: If the node after pointer is the end of the list, then jump to the waiting step below.
         auto* next_sibling = previous_candidate->next_sibling();
@@ -713,7 +713,7 @@ private:
         return {};
     }
 
-    WebIDL::ExceptionOr<void> waiting(JS::NonnullGCPtr<DOM::Node> previous_candidate)
+    WebIDL::ExceptionOr<void> waiting(GC::Ref<DOM::Node> previous_candidate)
     {
         // 17. ⌛ Waiting: Set the element's networkState attribute to the NETWORK_NO_SOURCE value.
         m_media_element->m_network_state = HTMLMediaElement::NetworkState::NoSource;
@@ -735,7 +735,7 @@ private:
         return {};
     }
 
-    WebIDL::ExceptionOr<void> wait_for_next_candidate(JS::NonnullGCPtr<DOM::Node> previous_candidate)
+    WebIDL::ExceptionOr<void> wait_for_next_candidate(GC::Ref<DOM::Node> previous_candidate)
     {
         // NOTE: If there isn't another candidate to check, we implement the "waiting" step by returning until the media
         //       element's children have changed.
@@ -762,12 +762,12 @@ private:
         return {};
     }
 
-    JS::NonnullGCPtr<HTMLMediaElement> m_media_element;
-    JS::NonnullGCPtr<HTMLSourceElement> m_candidate;
-    JS::GCPtr<DOM::Node> m_previously_failed_candidate;
+    GC::Ref<HTMLMediaElement> m_media_element;
+    GC::Ref<HTMLSourceElement> m_candidate;
+    GC::Ptr<DOM::Node> m_previously_failed_candidate;
 };
 
-JS_DEFINE_ALLOCATOR(SourceElementSelector);
+GC_DEFINE_ALLOCATOR(SourceElementSelector);
 
 void HTMLMediaElement::children_changed()
 {
@@ -795,7 +795,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::select_resource()
     // FIXME: 5. ⌛ If the media element's blocked-on-parser flag is false, then populate the list of pending text tracks.
 
     Optional<SelectMode> mode;
-    JS::GCPtr<HTMLSourceElement> candidate;
+    GC::Ptr<HTMLSourceElement> candidate;
 
     // 6. FIXME: ⌛ If the media element has an assigned media provider object, then let mode be object.
 
@@ -859,7 +859,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::select_resource()
             });
 
             // 7. Wait for the task queued by the previous step to have executed.
-            HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&]() { return ran_media_element_task; }));
+            HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&]() { return ran_media_element_task; }));
         };
 
         // 1. ⌛ If the src attribute's value is the empty string, then end the synchronous section, and jump down to the failed with attribute step below.
@@ -1013,7 +1013,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::fetch_resource(URL::URL const& url_r
             // 2. Let updateMedia be to queue a media element task given the media element to run the first appropriate steps from the media data processing
             //    steps list below. (A new task is used for this so that the work described below occurs relative to the appropriate media element event task
             //    source rather than using the networking task source.)
-            auto update_media = JS::create_heap_function(heap(), [this, failure_callback = move(failure_callback)](ByteBuffer media_data) mutable {
+            auto update_media = GC::create_function(heap(), [this, failure_callback = move(failure_callback)](ByteBuffer media_data) mutable {
                 // 6. Update the media data with the contents of response's unsafe response obtained in this fashion. response can be CORS-same-origin or
                 //    CORS-cross-origin; this affects whether subtitles referenced in the media data are exposed in the API and, for video elements, whether
                 //    a canvas gets tainted when the video is drawn on it.
@@ -1042,12 +1042,12 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::fetch_resource(URL::URL const& url_r
             // 5. Otherwise, incrementally read response's body given updateMedia, processEndOfMedia, an empty algorithm, and global.
 
             VERIFY(response->body());
-            auto empty_algorithm = JS::create_heap_function(heap(), [](JS::Value) {});
+            auto empty_algorithm = GC::create_function(heap(), [](JS::Value) {});
 
             // FIXME: We are "fully" reading the response here, rather than "incrementally". Memory concerns aside, this should be okay for now as we are
             //        always setting byteRange to "entire resource". However, we should switch to incremental reads when that is implemented, and then
             //        implement the processEndOfMedia step.
-            response->body()->fully_read(realm, update_media, empty_algorithm, JS::NonnullGCPtr { global });
+            response->body()->fully_read(realm, update_media, empty_algorithm, GC::Ref { global });
         };
 
         m_fetch_controller = TRY(Fetch::Fetching::fetch(realm, request, Fetch::Infrastructure::FetchAlgorithms::create(vm, move(fetch_algorithms_input))));
@@ -1075,7 +1075,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::fetch_resource(URL::URL const& url_r
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#verify-a-media-response
-bool HTMLMediaElement::verify_response(JS::NonnullGCPtr<Fetch::Infrastructure::Response> response, ByteRange const& byte_range)
+bool HTMLMediaElement::verify_response(GC::Ref<Fetch::Infrastructure::Response> response, ByteRange const& byte_range)
 {
     // 1. If response is a network error, then return false.
     if (response->is_network_error())
@@ -1112,8 +1112,8 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::process_media_data(Function<void(Str
         return {};
     }
 
-    JS::GCPtr<AudioTrack> audio_track;
-    JS::GCPtr<VideoTrack> video_track;
+    GC::Ptr<AudioTrack> audio_track;
+    GC::Ptr<VideoTrack> video_track;
 
     // -> If the media resource is found to have an audio track
     if (!audio_loader.is_error()) {
@@ -1141,7 +1141,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::process_media_data(Function<void(Str
 
         // 7. Fire an event named addtrack at this AudioTrackList object, using TrackEvent, with the track attribute initialized to the new AudioTrack object.
         TrackEventInit event_init {};
-        event_init.track = JS::make_handle(audio_track);
+        event_init.track = GC::make_root(audio_track);
 
         auto event = TrackEvent::create(realm, HTML::EventNames::addtrack, move(event_init));
         m_audio_tracks->dispatch_event(event);
@@ -1174,7 +1174,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::process_media_data(Function<void(Str
 
         // 7. Fire an event named addtrack at this VideoTrackList object, using TrackEvent, with the track attribute initialized to the new VideoTrack object.
         TrackEventInit event_init {};
-        event_init.track = JS::make_handle(video_track);
+        event_init.track = GC::make_root(video_track);
 
         auto event = TrackEvent::create(realm, HTML::EventNames::addtrack, move(event_init));
         m_video_tracks->dispatch_event(event);
@@ -1265,7 +1265,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::process_media_data(Function<void(Str
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dedicated-media-source-failure-steps
-WebIDL::ExceptionOr<void> HTMLMediaElement::handle_media_source_failure(Span<JS::NonnullGCPtr<WebIDL::Promise>> promises, String error_message)
+WebIDL::ExceptionOr<void> HTMLMediaElement::handle_media_source_failure(Span<GC::Ref<WebIDL::Promise>> promises, String error_message)
 {
     auto& realm = this->realm();
 
@@ -1575,7 +1575,7 @@ void HTMLMediaElement::seek_element(double playback_position, MediaSeekMode seek
     //     available, and, if it is, until it has decoded enough data to play back that position.
     m_seek_in_progress = true;
     on_seek(playback_position, seek_mode);
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&]() { return !m_seek_in_progress; }));
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&]() { return !m_seek_in_progress; }));
 
     // FIXME: 13. Await a stable state. The synchronous section consists of all the remaining steps of this algorithm. (Steps in the
     //            synchronous section are marked with ⌛.)
@@ -1863,12 +1863,12 @@ void HTMLMediaElement::time_marches_on(TimeMarchesOnReason reason)
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#take-pending-play-promises
-JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> HTMLMediaElement::take_pending_play_promises()
+GC::MarkedVector<GC::Ref<WebIDL::Promise>> HTMLMediaElement::take_pending_play_promises()
 {
     // 1. Let promises be an empty list of promises.
     // 2. Copy the media element's list of pending play promises to promises.
     // 3. Clear the media element's list of pending play promises.
-    JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> promises(heap());
+    GC::MarkedVector<GC::Ref<WebIDL::Promise>> promises(heap());
     promises.extend(move(m_pending_play_promises));
 
     // 4. Return promises.
@@ -1876,7 +1876,7 @@ JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> HTMLMediaElement::take_pendi
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#resolve-pending-play-promises
-void HTMLMediaElement::resolve_pending_play_promises(ReadonlySpan<JS::NonnullGCPtr<WebIDL::Promise>> promises)
+void HTMLMediaElement::resolve_pending_play_promises(ReadonlySpan<GC::Ref<WebIDL::Promise>> promises)
 {
     auto& realm = this->realm();
 
@@ -1890,7 +1890,7 @@ void HTMLMediaElement::resolve_pending_play_promises(ReadonlySpan<JS::NonnullGCP
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#reject-pending-play-promises
-void HTMLMediaElement::reject_pending_play_promises(ReadonlySpan<JS::NonnullGCPtr<WebIDL::Promise>> promises, JS::NonnullGCPtr<WebIDL::DOMException> error)
+void HTMLMediaElement::reject_pending_play_promises(ReadonlySpan<GC::Ref<WebIDL::Promise>> promises, GC::Ref<WebIDL::DOMException> error)
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/HTML/HTMLMediaElement.h b/Libraries/LibWeb/HTML/HTMLMediaElement.h
index 2e4719e1723..5aee59725b2 100644
--- a/Libraries/LibWeb/HTML/HTMLMediaElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMediaElement.h
@@ -11,8 +11,8 @@
 #include <AK/Optional.h>
 #include <AK/Time.h>
 #include <AK/Variant.h>
+#include <LibGC/MarkedVector.h>
 #include <LibGfx/Rect.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibWeb/DOM/DocumentLoadEventDelayer.h>
 #include <LibWeb/HTML/CORSSettingAttribute.h>
 #include <LibWeb/HTML/EventLoop/Task.h>
@@ -39,10 +39,10 @@ public:
 
     virtual bool is_focusable() const override { return true; }
 
-    // NOTE: The function is wrapped in a JS::HeapFunction immediately.
+    // NOTE: The function is wrapped in a GC::HeapFunction immediately.
     void queue_a_media_element_task(Function<void()>);
 
-    JS::GCPtr<MediaError> error() const { return m_error; }
+    GC::Ptr<MediaError> error() const { return m_error; }
     void set_decoder_error(String error_message);
 
     String const& current_src() const { return m_current_src; }
@@ -56,7 +56,7 @@ public:
     };
     NetworkState network_state() const { return m_network_state; }
 
-    [[nodiscard]] JS::NonnullGCPtr<TimeRanges> buffered() const;
+    [[nodiscard]] GC::Ref<TimeRanges> buffered() const;
 
     Bindings::CanPlayTypeResult can_play_type(StringView type) const;
 
@@ -88,7 +88,7 @@ public:
     bool paused() const { return m_paused; }
     bool ended() const;
     bool potentially_playing() const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> play();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> play();
     WebIDL::ExceptionOr<void> pause();
     WebIDL::ExceptionOr<void> toggle_playback();
 
@@ -102,11 +102,11 @@ public:
 
     double effective_media_volume() const;
 
-    JS::NonnullGCPtr<AudioTrackList> audio_tracks() const { return *m_audio_tracks; }
-    JS::NonnullGCPtr<VideoTrackList> video_tracks() const { return *m_video_tracks; }
-    JS::NonnullGCPtr<TextTrackList> text_tracks() const { return *m_text_tracks; }
+    GC::Ref<AudioTrackList> audio_tracks() const { return *m_audio_tracks; }
+    GC::Ref<VideoTrackList> video_tracks() const { return *m_video_tracks; }
+    GC::Ref<TextTrackList> text_tracks() const { return *m_text_tracks; }
 
-    JS::NonnullGCPtr<TextTrack> add_text_track(Bindings::TextTrackKind kind, String const& label, String const& language);
+    GC::Ref<TextTrack> add_text_track(Bindings::TextTrackKind kind, String const& label, String const& language);
 
     WebIDL::ExceptionOr<bool> handle_keydown(Badge<Web::EventHandler>, UIEvents::KeyCode, u32 modifiers);
 
@@ -165,9 +165,9 @@ private:
 
     WebIDL::ExceptionOr<void> load_element();
     WebIDL::ExceptionOr<void> fetch_resource(URL::URL const&, ESCAPING Function<void(String)> failure_callback);
-    static bool verify_response(JS::NonnullGCPtr<Fetch::Infrastructure::Response>, ByteRange const&);
+    static bool verify_response(GC::Ref<Fetch::Infrastructure::Response>, ByteRange const&);
     WebIDL::ExceptionOr<void> process_media_data(Function<void(String)> failure_callback);
-    WebIDL::ExceptionOr<void> handle_media_source_failure(Span<JS::NonnullGCPtr<WebIDL::Promise>> promises, String error_message);
+    WebIDL::ExceptionOr<void> handle_media_source_failure(Span<GC::Ref<WebIDL::Promise>> promises, String error_message);
     void forget_media_resource_specific_tracks();
     void set_ready_state(ReadyState);
 
@@ -193,13 +193,13 @@ private:
     };
     void time_marches_on(TimeMarchesOnReason = TimeMarchesOnReason::NormalPlayback);
 
-    JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> take_pending_play_promises();
-    void resolve_pending_play_promises(ReadonlySpan<JS::NonnullGCPtr<WebIDL::Promise>> promises);
-    void reject_pending_play_promises(ReadonlySpan<JS::NonnullGCPtr<WebIDL::Promise>> promises, JS::NonnullGCPtr<WebIDL::DOMException> error);
+    GC::MarkedVector<GC::Ref<WebIDL::Promise>> take_pending_play_promises();
+    void resolve_pending_play_promises(ReadonlySpan<GC::Ref<WebIDL::Promise>> promises);
+    void reject_pending_play_promises(ReadonlySpan<GC::Ref<WebIDL::Promise>> promises, GC::Ref<WebIDL::DOMException> error);
 
     // https://html.spec.whatwg.org/multipage/media.html#reject-pending-play-promises
     template<typename ErrorType>
-    void reject_pending_play_promises(ReadonlySpan<JS::NonnullGCPtr<WebIDL::Promise>> promises, String message)
+    void reject_pending_play_promises(ReadonlySpan<GC::Ref<WebIDL::Promise>> promises, String message)
     {
         auto& realm = this->realm();
 
@@ -211,7 +211,7 @@ private:
     UniqueTaskSource m_media_element_event_task_source {};
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-error
-    JS::GCPtr<MediaError> m_error;
+    GC::Ptr<MediaError> m_error;
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-crossorigin
     CORSSettingAttribute m_crossorigin { CORSSettingAttribute::NoCORS };
@@ -245,7 +245,7 @@ private:
     double m_duration { NAN };
 
     // https://html.spec.whatwg.org/multipage/media.html#list-of-pending-play-promises
-    Vector<JS::NonnullGCPtr<WebIDL::Promise>> m_pending_play_promises;
+    Vector<GC::Ref<WebIDL::Promise>> m_pending_play_promises;
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-paused
     bool m_paused { true };
@@ -257,13 +257,13 @@ private:
     bool m_muted { false };
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-audiotracks
-    JS::GCPtr<AudioTrackList> m_audio_tracks;
+    GC::Ptr<AudioTrackList> m_audio_tracks;
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-videotracks
-    JS::GCPtr<VideoTrackList> m_video_tracks;
+    GC::Ptr<VideoTrackList> m_video_tracks;
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-media-texttracks
-    JS::GCPtr<TextTrackList> m_text_tracks;
+    GC::Ptr<TextTrackList> m_text_tracks;
 
     // https://html.spec.whatwg.org/multipage/media.html#media-data
     ByteBuffer m_media_data;
@@ -277,11 +277,11 @@ private:
     bool m_running_time_update_event_handler { false };
     Optional<MonotonicTime> m_last_time_update_event_time;
 
-    JS::GCPtr<DOM::DocumentObserver> m_document_observer;
+    GC::Ptr<DOM::DocumentObserver> m_document_observer;
 
-    JS::GCPtr<SourceElementSelector> m_source_element_selector;
+    GC::Ptr<SourceElementSelector> m_source_element_selector;
 
-    JS::GCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
 
     bool m_seek_in_progress = false;
 
diff --git a/Libraries/LibWeb/HTML/HTMLMenuElement.cpp b/Libraries/LibWeb/HTML/HTMLMenuElement.cpp
index 3345c54b224..d54d095b6a9 100644
--- a/Libraries/LibWeb/HTML/HTMLMenuElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMenuElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLMenuElement);
+GC_DEFINE_ALLOCATOR(HTMLMenuElement);
 
 HTMLMenuElement::HTMLMenuElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLMenuElement.h b/Libraries/LibWeb/HTML/HTMLMenuElement.h
index 0d10ab3b170..e9c21ab25f9 100644
--- a/Libraries/LibWeb/HTML/HTMLMenuElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMenuElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLMenuElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLMenuElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLMenuElement);
+    GC_DECLARE_ALLOCATOR(HTMLMenuElement);
 
 public:
     virtual ~HTMLMenuElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLMetaElement.cpp b/Libraries/LibWeb/HTML/HTMLMetaElement.cpp
index d9255a513d0..8f86575208d 100644
--- a/Libraries/LibWeb/HTML/HTMLMetaElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMetaElement.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLMetaElement);
+GC_DEFINE_ALLOCATOR(HTMLMetaElement);
 
 HTMLMetaElement::HTMLMetaElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLMetaElement.h b/Libraries/LibWeb/HTML/HTMLMetaElement.h
index 5d3bf0554f2..ba2a41a0a98 100644
--- a/Libraries/LibWeb/HTML/HTMLMetaElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMetaElement.h
@@ -23,7 +23,7 @@ namespace Web::HTML {
 
 class HTMLMetaElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLMetaElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLMetaElement);
+    GC_DECLARE_ALLOCATOR(HTMLMetaElement);
 
 public:
     virtual ~HTMLMetaElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLMeterElement.cpp b/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
index 501b3c1b24f..39b8648a9a2 100644
--- a/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLMeterElement);
+GC_DEFINE_ALLOCATOR(HTMLMeterElement);
 
 HTMLMeterElement::HTMLMeterElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLMeterElement.h b/Libraries/LibWeb/HTML/HTMLMeterElement.h
index 2c7016487e0..b2539d822af 100644
--- a/Libraries/LibWeb/HTML/HTMLMeterElement.h
+++ b/Libraries/LibWeb/HTML/HTMLMeterElement.h
@@ -15,7 +15,7 @@ namespace Web::HTML {
 
 class HTMLMeterElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLMeterElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLMeterElement);
+    GC_DECLARE_ALLOCATOR(HTMLMeterElement);
 
 public:
     virtual ~HTMLMeterElement() override;
@@ -55,7 +55,7 @@ private:
 
     void update_meter_value_element();
 
-    JS::GCPtr<DOM::Element> m_meter_value_element;
+    GC::Ptr<DOM::Element> m_meter_value_element;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLModElement.cpp b/Libraries/LibWeb/HTML/HTMLModElement.cpp
index f8127e0e56a..d4b044f16f5 100644
--- a/Libraries/LibWeb/HTML/HTMLModElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLModElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLModElement);
+GC_DEFINE_ALLOCATOR(HTMLModElement);
 
 HTMLModElement::HTMLModElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLModElement.h b/Libraries/LibWeb/HTML/HTMLModElement.h
index fbc513013eb..a29e415eaee 100644
--- a/Libraries/LibWeb/HTML/HTMLModElement.h
+++ b/Libraries/LibWeb/HTML/HTMLModElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLModElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLModElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLModElement);
+    GC_DECLARE_ALLOCATOR(HTMLModElement);
 
 public:
     virtual ~HTMLModElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLOListElement.cpp b/Libraries/LibWeb/HTML/HTMLOListElement.cpp
index c44c5a4383d..c8b730051ff 100644
--- a/Libraries/LibWeb/HTML/HTMLOListElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOListElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLOListElement);
+GC_DEFINE_ALLOCATOR(HTMLOListElement);
 
 HTMLOListElement::HTMLOListElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLOListElement.h b/Libraries/LibWeb/HTML/HTMLOListElement.h
index 051ae0638be..f128f86343b 100644
--- a/Libraries/LibWeb/HTML/HTMLOListElement.h
+++ b/Libraries/LibWeb/HTML/HTMLOListElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLOListElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLOListElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLOListElement);
+    GC_DECLARE_ALLOCATOR(HTMLOListElement);
 
 public:
     virtual ~HTMLOListElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLObjectElement.cpp b/Libraries/LibWeb/HTML/HTMLObjectElement.cpp
index d8edc7edf70..9e8c58e714d 100644
--- a/Libraries/LibWeb/HTML/HTMLObjectElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLObjectElement.cpp
@@ -27,7 +27,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLObjectElement);
+GC_DEFINE_ALLOCATOR(HTMLObjectElement);
 
 HTMLObjectElement::HTMLObjectElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : NavigableContainer(document, move(qualified_name))
@@ -137,7 +137,7 @@ String HTMLObjectElement::data() const
     return MUST(document().parse_url(*data).to_string());
 }
 
-JS::GCPtr<Layout::Node> HTMLObjectElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLObjectElement::create_layout_node(CSS::StyleProperties style)
 {
     switch (m_representation) {
     case Representation::Children:
@@ -432,7 +432,7 @@ i32 HTMLObjectElement::default_tab_index_value() const
     return 0;
 }
 
-JS::GCPtr<DecodedImageData> HTMLObjectElement::image_data() const
+GC::Ptr<DecodedImageData> HTMLObjectElement::image_data() const
 {
     if (!m_resource_request)
         return nullptr;
diff --git a/Libraries/LibWeb/HTML/HTMLObjectElement.h b/Libraries/LibWeb/HTML/HTMLObjectElement.h
index 87495db13ab..29d70204bfe 100644
--- a/Libraries/LibWeb/HTML/HTMLObjectElement.h
+++ b/Libraries/LibWeb/HTML/HTMLObjectElement.h
@@ -22,7 +22,7 @@ class HTMLObjectElement final
     , public ResourceClient
     , public Layout::ImageProvider {
     WEB_PLATFORM_OBJECT(HTMLObjectElement, NavigableContainer)
-    JS_DECLARE_ALLOCATOR(HTMLObjectElement);
+    GC_DECLARE_ALLOCATOR(HTMLObjectElement);
     FORM_ASSOCIATED_ELEMENT(NavigableContainer, HTMLObjectElement)
 
     enum class Representation {
@@ -58,7 +58,7 @@ private:
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     bool has_ancestor_media_element_or_object_element_not_showing_fallback_content() const;
@@ -85,13 +85,13 @@ private:
     virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
     virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
     virtual void set_visible_in_viewport(bool) override;
-    virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const override { return *this; }
+    virtual GC::Ref<DOM::Element const> to_html_element() const override { return *this; }
 
     Representation m_representation { Representation::Unknown };
 
-    JS::GCPtr<DecodedImageData> image_data() const;
+    GC::Ptr<DecodedImageData> image_data() const;
 
-    JS::GCPtr<SharedResourceRequest> m_resource_request;
+    GC::Ptr<SharedResourceRequest> m_resource_request;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLOptGroupElement.cpp b/Libraries/LibWeb/HTML/HTMLOptGroupElement.cpp
index 18677ba557b..fd45a79dc3f 100644
--- a/Libraries/LibWeb/HTML/HTMLOptGroupElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOptGroupElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLOptGroupElement);
+GC_DEFINE_ALLOCATOR(HTMLOptGroupElement);
 
 HTMLOptGroupElement::HTMLOptGroupElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLOptGroupElement.h b/Libraries/LibWeb/HTML/HTMLOptGroupElement.h
index 50522986f62..a13f207cac3 100644
--- a/Libraries/LibWeb/HTML/HTMLOptGroupElement.h
+++ b/Libraries/LibWeb/HTML/HTMLOptGroupElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLOptGroupElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLOptGroupElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLOptGroupElement);
+    GC_DECLARE_ALLOCATOR(HTMLOptGroupElement);
 
 public:
     virtual ~HTMLOptGroupElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLOptionElement.cpp b/Libraries/LibWeb/HTML/HTMLOptionElement.cpp
index 0deb6522c19..87995bb31df 100644
--- a/Libraries/LibWeb/HTML/HTMLOptionElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOptionElement.cpp
@@ -21,7 +21,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLOptionElement);
+GC_DEFINE_ALLOCATOR(HTMLOptionElement);
 
 static u64 m_next_selectedness_update_index = 1;
 
@@ -174,7 +174,7 @@ bool HTMLOptionElement::disabled() const
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-option-form
-JS::GCPtr<HTMLFormElement> HTMLOptionElement::form() const
+GC::Ptr<HTMLFormElement> HTMLOptionElement::form() const
 {
     // The form IDL attribute's behavior depends on whether the option element is in a select element or not.
     // If the option has a select element as its parent, or has an optgroup element as its parent and that optgroup element has a select element as its parent,
diff --git a/Libraries/LibWeb/HTML/HTMLOptionElement.h b/Libraries/LibWeb/HTML/HTMLOptionElement.h
index d87a1c0684e..b6575f31c64 100644
--- a/Libraries/LibWeb/HTML/HTMLOptionElement.h
+++ b/Libraries/LibWeb/HTML/HTMLOptionElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLOptionElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLOptionElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLOptionElement);
+    GC_DECLARE_ALLOCATOR(HTMLOptionElement);
 
 public:
     virtual ~HTMLOptionElement() override;
@@ -36,7 +36,7 @@ public:
 
     bool disabled() const;
 
-    JS::GCPtr<HTML::HTMLFormElement> form() const;
+    GC::Ptr<HTML::HTMLFormElement> form() const;
 
     virtual Optional<ARIA::Role> default_role() const override;
 
diff --git a/Libraries/LibWeb/HTML/HTMLOptionsCollection.cpp b/Libraries/LibWeb/HTML/HTMLOptionsCollection.cpp
index e7a8ea6cf2a..111a424b6d4 100644
--- a/Libraries/LibWeb/HTML/HTMLOptionsCollection.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOptionsCollection.cpp
@@ -16,9 +16,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLOptionsCollection);
+GC_DEFINE_ALLOCATOR(HTMLOptionsCollection);
 
-JS::NonnullGCPtr<HTMLOptionsCollection> HTMLOptionsCollection::create(DOM::ParentNode& root, Function<bool(DOM::Element const&)> filter)
+GC::Ref<HTMLOptionsCollection> HTMLOptionsCollection::create(DOM::ParentNode& root, Function<bool(DOM::Element const&)> filter)
 {
     return root.realm().create<HTMLOptionsCollection>(root, move(filter));
 }
@@ -123,13 +123,13 @@ WebIDL::ExceptionOr<void> HTMLOptionsCollection::set_value_of_indexed_property(u
 WebIDL::ExceptionOr<void> HTMLOptionsCollection::add(HTMLOptionOrOptGroupElement element, Optional<HTMLElementOrElementIndex> before)
 {
     auto resolved_element = element.visit(
-        [](auto& e) -> JS::Handle<HTMLElement> {
-            return JS::make_handle(static_cast<HTML::HTMLElement&>(*e));
+        [](auto& e) -> GC::Root<HTMLElement> {
+            return GC::make_root(static_cast<HTML::HTMLElement&>(*e));
         });
 
-    JS::GCPtr<DOM::Node> before_element;
-    if (before.has_value() && before->has<JS::Handle<HTMLElement>>())
-        before_element = before->get<JS::Handle<HTMLElement>>().ptr();
+    GC::Ptr<DOM::Node> before_element;
+    if (before.has_value() && before->has<GC::Root<HTMLElement>>())
+        before_element = before->get<GC::Root<HTMLElement>>().ptr();
 
     // 1. If element is an ancestor of the select element on which the HTMLOptionsCollection is rooted, then throw a "HierarchyRequestError" DOMException.
     if (resolved_element->is_ancestor_of(root()))
@@ -144,7 +144,7 @@ WebIDL::ExceptionOr<void> HTMLOptionsCollection::add(HTMLOptionOrOptGroupElement
         return {};
 
     // 4. If before is a node, then let reference be that node. Otherwise, if before is an integer, and there is a beforeth node in the collection, let reference be that node. Otherwise, let reference be null.
-    JS::GCPtr<DOM::Node> reference;
+    GC::Ptr<DOM::Node> reference;
 
     if (before_element)
         reference = move(before_element);
diff --git a/Libraries/LibWeb/HTML/HTMLOptionsCollection.h b/Libraries/LibWeb/HTML/HTMLOptionsCollection.h
index 6d95d5f744b..1497792e0b2 100644
--- a/Libraries/LibWeb/HTML/HTMLOptionsCollection.h
+++ b/Libraries/LibWeb/HTML/HTMLOptionsCollection.h
@@ -13,15 +13,15 @@
 
 namespace Web::HTML {
 
-using HTMLOptionOrOptGroupElement = Variant<JS::Handle<HTMLOptionElement>, JS::Handle<HTMLOptGroupElement>>;
-using HTMLElementOrElementIndex = Variant<JS::Handle<HTMLElement>, i32>;
+using HTMLOptionOrOptGroupElement = Variant<GC::Root<HTMLOptionElement>, GC::Root<HTMLOptGroupElement>>;
+using HTMLElementOrElementIndex = Variant<GC::Root<HTMLElement>, i32>;
 
 class HTMLOptionsCollection final : public DOM::HTMLCollection {
     WEB_PLATFORM_OBJECT(HTMLOptionsCollection, DOM::HTMLCollection);
-    JS_DECLARE_ALLOCATOR(HTMLOptionsCollection);
+    GC_DECLARE_ALLOCATOR(HTMLOptionsCollection);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<HTMLOptionsCollection> create(DOM::ParentNode& root, ESCAPING Function<bool(DOM::Element const&)> filter);
+    [[nodiscard]] static GC::Ref<HTMLOptionsCollection> create(DOM::ParentNode& root, ESCAPING Function<bool(DOM::Element const&)> filter);
     virtual ~HTMLOptionsCollection() override;
 
     WebIDL::ExceptionOr<void> set_value_of_indexed_property(u32, JS::Value) override;
diff --git a/Libraries/LibWeb/HTML/HTMLOrSVGElement.cpp b/Libraries/LibWeb/HTML/HTMLOrSVGElement.cpp
index 7122376953d..a8111b36cab 100644
--- a/Libraries/LibWeb/HTML/HTMLOrSVGElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOrSVGElement.cpp
@@ -14,7 +14,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/dom.html#dom-dataset-dev
 template<typename ElementBase>
-JS::NonnullGCPtr<DOMStringMap> HTMLOrSVGElement<ElementBase>::dataset()
+GC::Ref<DOMStringMap> HTMLOrSVGElement<ElementBase>::dataset()
 {
     if (!m_dataset)
         m_dataset = DOMStringMap::create(*static_cast<ElementBase*>(this));
diff --git a/Libraries/LibWeb/HTML/HTMLOrSVGElement.h b/Libraries/LibWeb/HTML/HTMLOrSVGElement.h
index fe6bd3288c9..a927c1d5276 100644
--- a/Libraries/LibWeb/HTML/HTMLOrSVGElement.h
+++ b/Libraries/LibWeb/HTML/HTMLOrSVGElement.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/HTML/DOMStringMap.h>
 
 namespace Web::HTML {
@@ -15,7 +15,7 @@ namespace Web::HTML {
 template<typename ElementBase>
 class HTMLOrSVGElement {
 public:
-    [[nodiscard]] JS::NonnullGCPtr<DOMStringMap> dataset();
+    [[nodiscard]] GC::Ref<DOMStringMap> dataset();
 
     // https://html.spec.whatwg.org/#dom-noncedelement-nonce
     String const& nonce() { return m_cryptographic_nonce; }
@@ -31,7 +31,7 @@ protected:
     void visit_edges(JS::Cell::Visitor&);
 
     // https://html.spec.whatwg.org/multipage/dom.html#dom-dataset-dev
-    JS::GCPtr<DOMStringMap> m_dataset;
+    GC::Ptr<DOMStringMap> m_dataset;
 
     // https://html.spec.whatwg.org/#cryptographicnonce
     String m_cryptographic_nonce;
diff --git a/Libraries/LibWeb/HTML/HTMLOutputElement.cpp b/Libraries/LibWeb/HTML/HTMLOutputElement.cpp
index f90b8cb4ae6..12fc2e06eeb 100644
--- a/Libraries/LibWeb/HTML/HTMLOutputElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLOutputElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLOutputElement);
+GC_DEFINE_ALLOCATOR(HTMLOutputElement);
 
 HTMLOutputElement::HTMLOutputElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -41,7 +41,7 @@ void HTMLOutputElement::form_associated_element_attribute_changed(FlyString cons
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-output-htmlfor
-JS::NonnullGCPtr<DOM::DOMTokenList> HTMLOutputElement::html_for()
+GC::Ref<DOM::DOMTokenList> HTMLOutputElement::html_for()
 {
     // The htmlFor IDL attribute must reflect the for content attribute.
     if (!m_html_for)
diff --git a/Libraries/LibWeb/HTML/HTMLOutputElement.h b/Libraries/LibWeb/HTML/HTMLOutputElement.h
index dad7a6ef6b8..849e3f985f0 100644
--- a/Libraries/LibWeb/HTML/HTMLOutputElement.h
+++ b/Libraries/LibWeb/HTML/HTMLOutputElement.h
@@ -17,13 +17,13 @@ class HTMLOutputElement final
     : public HTMLElement
     , public FormAssociatedElement {
     WEB_PLATFORM_OBJECT(HTMLOutputElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLOutputElement);
+    GC_DECLARE_ALLOCATOR(HTMLOutputElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLOutputElement)
 
 public:
     virtual ~HTMLOutputElement() override;
 
-    JS::NonnullGCPtr<DOM::DOMTokenList> html_for();
+    GC::Ref<DOM::DOMTokenList> html_for();
 
     String const& type() const
     {
@@ -65,7 +65,7 @@ private:
 
     virtual void form_associated_element_attribute_changed(FlyString const& name, Optional<String> const& value) override;
 
-    JS::GCPtr<DOM::DOMTokenList> m_html_for;
+    GC::Ptr<DOM::DOMTokenList> m_html_for;
 
     Optional<String> m_default_value_override {};
 };
diff --git a/Libraries/LibWeb/HTML/HTMLParagraphElement.cpp b/Libraries/LibWeb/HTML/HTMLParagraphElement.cpp
index 92610ac222e..13a77c34484 100644
--- a/Libraries/LibWeb/HTML/HTMLParagraphElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLParagraphElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLParagraphElement);
+GC_DEFINE_ALLOCATOR(HTMLParagraphElement);
 
 HTMLParagraphElement::HTMLParagraphElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLParagraphElement.h b/Libraries/LibWeb/HTML/HTMLParagraphElement.h
index 9dcc51a7aa4..d3b2d060c7b 100644
--- a/Libraries/LibWeb/HTML/HTMLParagraphElement.h
+++ b/Libraries/LibWeb/HTML/HTMLParagraphElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLParagraphElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLParagraphElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLParagraphElement);
+    GC_DECLARE_ALLOCATOR(HTMLParagraphElement);
 
 public:
     virtual ~HTMLParagraphElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLParamElement.cpp b/Libraries/LibWeb/HTML/HTMLParamElement.cpp
index a9fcd41afbc..0b6c07446c9 100644
--- a/Libraries/LibWeb/HTML/HTMLParamElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLParamElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLParamElement);
+GC_DEFINE_ALLOCATOR(HTMLParamElement);
 
 HTMLParamElement::HTMLParamElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLParamElement.h b/Libraries/LibWeb/HTML/HTMLParamElement.h
index 0cc46ad3883..96b20adf5ab 100644
--- a/Libraries/LibWeb/HTML/HTMLParamElement.h
+++ b/Libraries/LibWeb/HTML/HTMLParamElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLParamElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLParamElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLParamElement);
+    GC_DECLARE_ALLOCATOR(HTMLParamElement);
 
 public:
     virtual ~HTMLParamElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLPictureElement.cpp b/Libraries/LibWeb/HTML/HTMLPictureElement.cpp
index eb217efa222..9e1138e95d5 100644
--- a/Libraries/LibWeb/HTML/HTMLPictureElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLPictureElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLPictureElement);
+GC_DEFINE_ALLOCATOR(HTMLPictureElement);
 
 HTMLPictureElement::HTMLPictureElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLPictureElement.h b/Libraries/LibWeb/HTML/HTMLPictureElement.h
index 125d8c21cb6..1c7843df853 100644
--- a/Libraries/LibWeb/HTML/HTMLPictureElement.h
+++ b/Libraries/LibWeb/HTML/HTMLPictureElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLPictureElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLPictureElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLPictureElement);
+    GC_DECLARE_ALLOCATOR(HTMLPictureElement);
 
 public:
     virtual ~HTMLPictureElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLPreElement.cpp b/Libraries/LibWeb/HTML/HTMLPreElement.cpp
index f18ba604e2d..310dff90cf6 100644
--- a/Libraries/LibWeb/HTML/HTMLPreElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLPreElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLPreElement);
+GC_DEFINE_ALLOCATOR(HTMLPreElement);
 
 HTMLPreElement::HTMLPreElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLPreElement.h b/Libraries/LibWeb/HTML/HTMLPreElement.h
index 17b3162707c..7f17ca84809 100644
--- a/Libraries/LibWeb/HTML/HTMLPreElement.h
+++ b/Libraries/LibWeb/HTML/HTMLPreElement.h
@@ -14,7 +14,7 @@ namespace Web::HTML {
 
 class HTMLPreElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLPreElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLPreElement);
+    GC_DECLARE_ALLOCATOR(HTMLPreElement);
 
 public:
     virtual ~HTMLPreElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLProgressElement.cpp b/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
index 837a7272029..bb71d1e08d6 100644
--- a/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLProgressElement);
+GC_DEFINE_ALLOCATOR(HTMLProgressElement);
 
 HTMLProgressElement::HTMLProgressElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLProgressElement.h b/Libraries/LibWeb/HTML/HTMLProgressElement.h
index b66c048806e..7b143cfc532 100644
--- a/Libraries/LibWeb/HTML/HTMLProgressElement.h
+++ b/Libraries/LibWeb/HTML/HTMLProgressElement.h
@@ -14,7 +14,7 @@ namespace Web::HTML {
 
 class HTMLProgressElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLProgressElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLProgressElement);
+    GC_DECLARE_ALLOCATOR(HTMLProgressElement);
 
 public:
     virtual ~HTMLProgressElement() override;
@@ -55,7 +55,7 @@ private:
 
     bool is_determinate() const { return has_attribute(HTML::AttributeNames::value); }
 
-    JS::GCPtr<DOM::Element> m_progress_value_element;
+    GC::Ptr<DOM::Element> m_progress_value_element;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLQuoteElement.cpp b/Libraries/LibWeb/HTML/HTMLQuoteElement.cpp
index 1f339555371..587d13b81ac 100644
--- a/Libraries/LibWeb/HTML/HTMLQuoteElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLQuoteElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLQuoteElement);
+GC_DEFINE_ALLOCATOR(HTMLQuoteElement);
 
 HTMLQuoteElement::HTMLQuoteElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLQuoteElement.h b/Libraries/LibWeb/HTML/HTMLQuoteElement.h
index a7cd188eafa..d1f945e0fb6 100644
--- a/Libraries/LibWeb/HTML/HTMLQuoteElement.h
+++ b/Libraries/LibWeb/HTML/HTMLQuoteElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLQuoteElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLQuoteElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLQuoteElement);
+    GC_DECLARE_ALLOCATOR(HTMLQuoteElement);
 
 public:
     virtual ~HTMLQuoteElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLScriptElement.cpp b/Libraries/LibWeb/HTML/HTMLScriptElement.cpp
index 15b76022d92..9fe04a07657 100644
--- a/Libraries/LibWeb/HTML/HTMLScriptElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLScriptElement.cpp
@@ -26,7 +26,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLScriptElement);
+GC_DEFINE_ALLOCATOR(HTMLScriptElement);
 
 HTMLScriptElement::HTMLScriptElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -44,7 +44,7 @@ void HTMLScriptElement::initialize(JS::Realm& realm)
 void HTMLScriptElement::visit_edges(Cell::Visitor& visitor)
 {
     Base::visit_edges(visitor);
-    if (auto* script = m_result.get_pointer<JS::NonnullGCPtr<Script>>())
+    if (auto* script = m_result.get_pointer<GC::Ref<Script>>())
         visitor.visit(*script);
     visitor.visit(m_parser_document);
     visitor.visit(m_preparation_time_document);
@@ -86,10 +86,10 @@ void HTMLScriptElement::execute_script()
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#read-html
     // Before any script execution occurs, the user agent must wait for scripts may run for the newly-created document to be true for document.
     if (!m_document->ready_to_run_scripts())
-        main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] { return m_document->ready_to_run_scripts(); }));
+        main_thread_event_loop().spin_until(GC::create_function(heap(), [&] { return m_document->ready_to_run_scripts(); }));
 
     // 1. Let document be el's node document.
-    JS::NonnullGCPtr<DOM::Document> document = this->document();
+    GC::Ref<DOM::Document> document = this->document();
 
     // 2. If el's preparation-time document is not equal to document, then return.
     if (m_preparation_time_document.ptr() != document.ptr()) {
@@ -130,7 +130,7 @@ void HTMLScriptElement::execute_script()
             dbgln_if(HTML_SCRIPT_DEBUG, "HTMLScriptElement: Running inline script");
 
         // 3. Run the classic script given by el's result.
-        (void)verify_cast<ClassicScript>(*m_result.get<JS::NonnullGCPtr<Script>>()).run();
+        (void)verify_cast<ClassicScript>(*m_result.get<GC::Ref<Script>>()).run();
 
         // 4. Set document's currentScript attribute to oldCurrentScript.
         document->set_current_script({}, old_current_script);
@@ -141,12 +141,12 @@ void HTMLScriptElement::execute_script()
         VERIFY(document->current_script() == nullptr);
 
         // 2. Run the module script given by el's result.
-        (void)verify_cast<JavaScriptModuleScript>(*m_result.get<JS::NonnullGCPtr<Script>>()).run();
+        (void)verify_cast<JavaScriptModuleScript>(*m_result.get<GC::Ref<Script>>()).run();
     }
     // -> "importmap"
     else if (m_script_type == ScriptType::ImportMap) {
         // 1. Register an import map given el's relevant global object and el's result.
-        m_result.get<JS::NonnullGCPtr<ImportMapParseResult>>()->register_import_map(verify_cast<Window>(relevant_global_object(*this)));
+        m_result.get<GC::Ref<ImportMapParseResult>>()->register_import_map(verify_cast<Window>(relevant_global_object(*this)));
     }
 
     // 7. Decrement the ignore-destructive-writes counter of document, if it was incremented in the earlier step.
@@ -169,7 +169,7 @@ void HTMLScriptElement::prepare_script()
     }
 
     // 2. Let parser document be el's parser document.
-    JS::GCPtr<DOM::Document> parser_document = m_parser_document;
+    GC::Ptr<DOM::Document> parser_document = m_parser_document;
 
     // 3. Set el's parser document to null.
     m_parser_document = nullptr;
diff --git a/Libraries/LibWeb/HTML/HTMLScriptElement.h b/Libraries/LibWeb/HTML/HTMLScriptElement.h
index bdb419cc3ad..1d848c19569 100644
--- a/Libraries/LibWeb/HTML/HTMLScriptElement.h
+++ b/Libraries/LibWeb/HTML/HTMLScriptElement.h
@@ -18,7 +18,7 @@ namespace Web::HTML {
 
 class HTMLScriptElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLScriptElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLScriptElement);
+    GC_DECLARE_ALLOCATOR(HTMLScriptElement);
 
 public:
     virtual ~HTMLScriptElement() override;
@@ -82,16 +82,16 @@ private:
         struct Null { };
     };
 
-    using Result = Variant<ResultState::Uninitialized, ResultState::Null, JS::NonnullGCPtr<HTML::Script>, JS::NonnullGCPtr<HTML::ImportMapParseResult>>;
+    using Result = Variant<ResultState::Uninitialized, ResultState::Null, GC::Ref<HTML::Script>, GC::Ref<HTML::ImportMapParseResult>>;
 
     // https://html.spec.whatwg.org/multipage/scripting.html#mark-as-ready
     void mark_as_ready(Result);
 
     // https://html.spec.whatwg.org/multipage/scripting.html#parser-document
-    JS::GCPtr<DOM::Document> m_parser_document;
+    GC::Ptr<DOM::Document> m_parser_document;
 
     // https://html.spec.whatwg.org/multipage/scripting.html#preparation-time-document
-    JS::GCPtr<DOM::Document> m_preparation_time_document;
+    GC::Ptr<DOM::Document> m_preparation_time_document;
 
     // https://html.spec.whatwg.org/multipage/scripting.html#script-force-async
     bool m_force_async { true };
diff --git a/Libraries/LibWeb/HTML/HTMLSelectElement.cpp b/Libraries/LibWeb/HTML/HTMLSelectElement.cpp
index 7f88647069f..82e2490d2f2 100644
--- a/Libraries/LibWeb/HTML/HTMLSelectElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLSelectElement.cpp
@@ -29,7 +29,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLSelectElement);
+GC_DEFINE_ALLOCATOR(HTMLSelectElement);
 
 HTMLSelectElement::HTMLSelectElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -100,7 +100,7 @@ WebIDL::ExceptionOr<void> HTMLSelectElement::set_size(WebIDL::UnsignedLong size)
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-select-options
-JS::GCPtr<HTMLOptionsCollection> const& HTMLSelectElement::options()
+GC::Ptr<HTMLOptionsCollection> const& HTMLSelectElement::options()
 {
     if (!m_options) {
         m_options = HTMLOptionsCollection::create(*this, [](DOM::Element const& element) {
@@ -166,7 +166,7 @@ void HTMLSelectElement::remove(WebIDL::Long index)
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-select-selectedoptions
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLSelectElement::selected_options()
+GC::Ref<DOM::HTMLCollection> HTMLSelectElement::selected_options()
 {
     // The selectedOptions IDL attribute must return an HTMLCollection rooted at the select node,
     // whose filter matches the elements in the list of options that have their selectedness set to true.
@@ -183,20 +183,20 @@ JS::NonnullGCPtr<DOM::HTMLCollection> HTMLSelectElement::selected_options()
 }
 
 // https://html.spec.whatwg.org/multipage/form-elements.html#concept-select-option-list
-Vector<JS::Handle<HTMLOptionElement>> HTMLSelectElement::list_of_options() const
+Vector<GC::Root<HTMLOptionElement>> HTMLSelectElement::list_of_options() const
 {
     // The list of options for a select element consists of all the option element children of the select element,
     // and all the option element children of all the optgroup element children of the select element, in tree order.
-    Vector<JS::Handle<HTMLOptionElement>> list;
+    Vector<GC::Root<HTMLOptionElement>> list;
 
     for_each_child_of_type<HTMLOptionElement>([&](HTMLOptionElement& option_element) {
-        list.append(JS::make_handle(option_element));
+        list.append(GC::make_root(option_element));
         return IterationDecision::Continue;
     });
 
     for_each_child_of_type<HTMLOptGroupElement>([&](HTMLOptGroupElement const& optgroup_element) {
         optgroup_element.for_each_child_of_type<HTMLOptionElement>([&](HTMLOptionElement& option_element) {
-            list.append(JS::make_handle(option_element));
+            list.append(GC::make_root(option_element));
             return IterationDecision::Continue;
         });
         return IterationDecision::Continue;
@@ -611,7 +611,7 @@ void HTMLSelectElement::update_selectedness()
     if (number_of_selected >= 2) {
         // then set the selectedness of all but the last option element with its selectedness set to true
         // in the list of options in tree order to false.
-        JS::GCPtr<HTML::HTMLOptionElement> last_selected_option;
+        GC::Ptr<HTML::HTMLOptionElement> last_selected_option;
         u64 last_selected_option_update_index = 0;
 
         for (auto const& option_element : list_of_options()) {
diff --git a/Libraries/LibWeb/HTML/HTMLSelectElement.h b/Libraries/LibWeb/HTML/HTMLSelectElement.h
index 91ed23160a2..c9656fea7b7 100644
--- a/Libraries/LibWeb/HTML/HTMLSelectElement.h
+++ b/Libraries/LibWeb/HTML/HTMLSelectElement.h
@@ -21,7 +21,7 @@ class HTMLSelectElement final
     : public HTMLElement
     , public FormAssociatedElement {
     WEB_PLATFORM_OBJECT(HTMLSelectElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLSelectElement);
+    GC_DECLARE_ALLOCATOR(HTMLSelectElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLSelectElement)
 
 public:
@@ -32,7 +32,7 @@ public:
     WebIDL::UnsignedLong size() const;
     WebIDL::ExceptionOr<void> set_size(WebIDL::UnsignedLong);
 
-    JS::GCPtr<HTMLOptionsCollection> const& options();
+    GC::Ptr<HTMLOptionsCollection> const& options();
 
     WebIDL::UnsignedLong length();
     WebIDL::ExceptionOr<void> set_length(WebIDL::UnsignedLong);
@@ -42,7 +42,7 @@ public:
     void remove();
     void remove(WebIDL::Long);
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> selected_options();
+    GC::Ref<DOM::HTMLCollection> selected_options();
 
     WebIDL::Long selected_index() const;
     void set_selected_index(WebIDL::Long);
@@ -55,7 +55,7 @@ public:
 
     WebIDL::ExceptionOr<void> show_picker();
 
-    Vector<JS::Handle<HTMLOptionElement>> list_of_options() const;
+    Vector<GC::Root<HTMLOptionElement>> list_of_options() const;
 
     // ^EventTarget
     // https://html.spec.whatwg.org/multipage/interaction.html#the-tabindex-attribute:the-select-element
@@ -115,12 +115,12 @@ private:
     void update_inner_text_element();
     void queue_input_and_change_events();
 
-    JS::GCPtr<HTMLOptionsCollection> m_options;
-    JS::GCPtr<DOM::HTMLCollection> m_selected_options;
+    GC::Ptr<HTMLOptionsCollection> m_options;
+    GC::Ptr<DOM::HTMLCollection> m_selected_options;
     bool m_is_open { false };
     Vector<SelectItem> m_select_items;
-    JS::GCPtr<DOM::Element> m_inner_text_element;
-    JS::GCPtr<DOM::Element> m_chevron_icon_element;
+    GC::Ptr<DOM::Element> m_inner_text_element;
+    GC::Ptr<DOM::Element> m_chevron_icon_element;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLSlotElement.cpp b/Libraries/LibWeb/HTML/HTMLSlotElement.cpp
index 021b49524c3..16225903126 100644
--- a/Libraries/LibWeb/HTML/HTMLSlotElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLSlotElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLSlotElement);
+GC_DEFINE_ALLOCATOR(HTMLSlotElement);
 
 HTMLSlotElement::HTMLSlotElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -38,11 +38,11 @@ void HTMLSlotElement::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#dom-slot-assignednodes
-Vector<JS::Handle<DOM::Node>> HTMLSlotElement::assigned_nodes(AssignedNodesOptions options) const
+Vector<GC::Root<DOM::Node>> HTMLSlotElement::assigned_nodes(AssignedNodesOptions options) const
 {
     // 1. If options["flatten"] is false, then return this's assigned nodes.
     if (!options.flatten) {
-        Vector<JS::Handle<DOM::Node>> assigned_nodes;
+        Vector<GC::Root<DOM::Node>> assigned_nodes;
         assigned_nodes.ensure_capacity(assigned_nodes_internal().size());
 
         for (auto const& node : assigned_nodes_internal()) {
@@ -59,14 +59,14 @@ Vector<JS::Handle<DOM::Node>> HTMLSlotElement::assigned_nodes(AssignedNodesOptio
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#dom-slot-assignedelements
-Vector<JS::Handle<DOM::Element>> HTMLSlotElement::assigned_elements(AssignedNodesOptions options) const
+Vector<GC::Root<DOM::Element>> HTMLSlotElement::assigned_elements(AssignedNodesOptions options) const
 {
     // 1. If options["flatten"] is false, then return this's assigned nodes, filtered to contain only Element nodes.
     if (!options.flatten) {
-        Vector<JS::Handle<DOM::Element>> assigned_nodes;
+        Vector<GC::Root<DOM::Element>> assigned_nodes;
 
         for (auto const& node : assigned_nodes_internal()) {
-            if (auto const* element = node.get_pointer<JS::NonnullGCPtr<DOM::Element>>())
+            if (auto const* element = node.get_pointer<GC::Ref<DOM::Element>>())
                 assigned_nodes.append(*element);
         }
 
diff --git a/Libraries/LibWeb/HTML/HTMLSlotElement.h b/Libraries/LibWeb/HTML/HTMLSlotElement.h
index 01370a3eac4..a39d17ebc87 100644
--- a/Libraries/LibWeb/HTML/HTMLSlotElement.h
+++ b/Libraries/LibWeb/HTML/HTMLSlotElement.h
@@ -9,7 +9,7 @@
 
 #include <AK/Variant.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/Slot.h>
 #include <LibWeb/DOM/Slottable.h>
 #include <LibWeb/HTML/HTMLElement.h>
@@ -24,15 +24,15 @@ class HTMLSlotElement final
     : public HTMLElement
     , public DOM::Slot {
     WEB_PLATFORM_OBJECT(HTMLSlotElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLSlotElement);
+    GC_DECLARE_ALLOCATOR(HTMLSlotElement);
 
 public:
     virtual ~HTMLSlotElement() override;
 
-    Vector<JS::Handle<DOM::Node>> assigned_nodes(AssignedNodesOptions options = {}) const;
-    Vector<JS::Handle<DOM::Element>> assigned_elements(AssignedNodesOptions options = {}) const;
+    Vector<GC::Root<DOM::Node>> assigned_nodes(AssignedNodesOptions options = {}) const;
+    Vector<GC::Root<DOM::Element>> assigned_elements(AssignedNodesOptions options = {}) const;
 
-    using SlottableHandle = Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Text>>;
+    using SlottableHandle = Variant<GC::Root<DOM::Element>, GC::Root<DOM::Text>>;
     void assign(Vector<SlottableHandle> nodes);
 
     ReadonlySpan<DOM::Slottable> manually_assigned_nodes() const { return m_manually_assigned_nodes; }
diff --git a/Libraries/LibWeb/HTML/HTMLSourceElement.cpp b/Libraries/LibWeb/HTML/HTMLSourceElement.cpp
index bbbdda234ee..8d3d5f1712d 100644
--- a/Libraries/LibWeb/HTML/HTMLSourceElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLSourceElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLSourceElement);
+GC_DEFINE_ALLOCATOR(HTMLSourceElement);
 
 HTMLSourceElement::HTMLSourceElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLSourceElement.h b/Libraries/LibWeb/HTML/HTMLSourceElement.h
index a57d29cc6c7..5afd800bc1f 100644
--- a/Libraries/LibWeb/HTML/HTMLSourceElement.h
+++ b/Libraries/LibWeb/HTML/HTMLSourceElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLSourceElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLSourceElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLSourceElement);
+    GC_DECLARE_ALLOCATOR(HTMLSourceElement);
 
 public:
     virtual ~HTMLSourceElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLSpanElement.cpp b/Libraries/LibWeb/HTML/HTMLSpanElement.cpp
index a26d245f551..53fe9cff777 100644
--- a/Libraries/LibWeb/HTML/HTMLSpanElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLSpanElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLSpanElement);
+GC_DEFINE_ALLOCATOR(HTMLSpanElement);
 
 HTMLSpanElement::HTMLSpanElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLSpanElement.h b/Libraries/LibWeb/HTML/HTMLSpanElement.h
index 27f60d4d840..316e4254484 100644
--- a/Libraries/LibWeb/HTML/HTMLSpanElement.h
+++ b/Libraries/LibWeb/HTML/HTMLSpanElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLSpanElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLSpanElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLSpanElement);
+    GC_DECLARE_ALLOCATOR(HTMLSpanElement);
 
 public:
     virtual ~HTMLSpanElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLStyleElement.cpp b/Libraries/LibWeb/HTML/HTMLStyleElement.cpp
index bc31a6886da..2fcfd6a8f02 100644
--- a/Libraries/LibWeb/HTML/HTMLStyleElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLStyleElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLStyleElement);
+GC_DEFINE_ALLOCATOR(HTMLStyleElement);
 
 HTMLStyleElement::HTMLStyleElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLStyleElement.h b/Libraries/LibWeb/HTML/HTMLStyleElement.h
index a68abab5000..3946f9f4e53 100644
--- a/Libraries/LibWeb/HTML/HTMLStyleElement.h
+++ b/Libraries/LibWeb/HTML/HTMLStyleElement.h
@@ -14,7 +14,7 @@ namespace Web::HTML {
 
 class HTMLStyleElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLStyleElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLStyleElement);
+    GC_DECLARE_ALLOCATOR(HTMLStyleElement);
 
 public:
     virtual ~HTMLStyleElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLSummaryElement.cpp b/Libraries/LibWeb/HTML/HTMLSummaryElement.cpp
index 7dfc4a1e683..436e07abffc 100644
--- a/Libraries/LibWeb/HTML/HTMLSummaryElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLSummaryElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLSummaryElement);
+GC_DEFINE_ALLOCATOR(HTMLSummaryElement);
 
 HTMLSummaryElement::HTMLSummaryElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLSummaryElement.h b/Libraries/LibWeb/HTML/HTMLSummaryElement.h
index 36c2862e0c3..ad5767329af 100644
--- a/Libraries/LibWeb/HTML/HTMLSummaryElement.h
+++ b/Libraries/LibWeb/HTML/HTMLSummaryElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLSummaryElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLSummaryElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLSummaryElement);
+    GC_DECLARE_ALLOCATOR(HTMLSummaryElement);
 
 public:
     virtual ~HTMLSummaryElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTableCaptionElement.cpp b/Libraries/LibWeb/HTML/HTMLTableCaptionElement.cpp
index 20f5cf4a7da..b004f0774d6 100644
--- a/Libraries/LibWeb/HTML/HTMLTableCaptionElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableCaptionElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableCaptionElement);
+GC_DEFINE_ALLOCATOR(HTMLTableCaptionElement);
 
 HTMLTableCaptionElement::HTMLTableCaptionElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTableCaptionElement.h b/Libraries/LibWeb/HTML/HTMLTableCaptionElement.h
index aece874c298..8bc898a2af0 100644
--- a/Libraries/LibWeb/HTML/HTMLTableCaptionElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableCaptionElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLTableCaptionElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableCaptionElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableCaptionElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableCaptionElement);
 
 public:
     virtual ~HTMLTableCaptionElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTableCellElement.cpp b/Libraries/LibWeb/HTML/HTMLTableCellElement.cpp
index fbbe0e9a5fd..9138813c174 100644
--- a/Libraries/LibWeb/HTML/HTMLTableCellElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableCellElement.cpp
@@ -22,7 +22,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableCellElement);
+GC_DEFINE_ALLOCATOR(HTMLTableCellElement);
 
 HTMLTableCellElement::HTMLTableCellElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTableCellElement.h b/Libraries/LibWeb/HTML/HTMLTableCellElement.h
index 0f4829c20e1..af0081b5d2f 100644
--- a/Libraries/LibWeb/HTML/HTMLTableCellElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableCellElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLTableCellElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableCellElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableCellElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableCellElement);
 
 public:
     virtual ~HTMLTableCellElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTableColElement.cpp b/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
index fd0eafe79ff..753a76b5013 100644
--- a/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableColElement);
+GC_DEFINE_ALLOCATOR(HTMLTableColElement);
 
 HTMLTableColElement::HTMLTableColElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTableColElement.h b/Libraries/LibWeb/HTML/HTMLTableColElement.h
index 8638f8396f5..9da04faeb45 100644
--- a/Libraries/LibWeb/HTML/HTMLTableColElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableColElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLTableColElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableColElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableColElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableColElement);
 
 public:
     virtual ~HTMLTableColElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTableElement.cpp b/Libraries/LibWeb/HTML/HTMLTableElement.cpp
index 7edb3636e5c..0603164e42f 100644
--- a/Libraries/LibWeb/HTML/HTMLTableElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableElement.cpp
@@ -24,7 +24,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableElement);
+GC_DEFINE_ALLOCATOR(HTMLTableElement);
 
 HTMLTableElement::HTMLTableElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -123,7 +123,7 @@ void HTMLTableElement::attribute_changed(FlyString const& name, Optional<String>
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-caption
-JS::GCPtr<HTMLTableCaptionElement> HTMLTableElement::caption()
+GC::Ptr<HTMLTableCaptionElement> HTMLTableElement::caption()
 {
     // The caption IDL attribute must return, on getting, the first caption element child of the table element,
     // if any, or null otherwise.
@@ -144,7 +144,7 @@ WebIDL::ExceptionOr<void> HTMLTableElement::set_caption(HTMLTableCaptionElement*
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-createcaption
-JS::NonnullGCPtr<HTMLTableCaptionElement> HTMLTableElement::create_caption()
+GC::Ref<HTMLTableCaptionElement> HTMLTableElement::create_caption()
 {
     auto maybe_caption = caption();
     if (maybe_caption) {
@@ -166,7 +166,7 @@ void HTMLTableElement::delete_caption()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-thead
-JS::GCPtr<HTMLTableSectionElement> HTMLTableElement::t_head()
+GC::Ptr<HTMLTableSectionElement> HTMLTableElement::t_head()
 {
     // The tHead IDL attribute must return, on getting, the first thead element child of the table element,
     // if any, or null otherwise.
@@ -223,7 +223,7 @@ WebIDL::ExceptionOr<void> HTMLTableElement::set_t_head(HTMLTableSectionElement*
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-createthead
-JS::NonnullGCPtr<HTMLTableSectionElement> HTMLTableElement::create_t_head()
+GC::Ref<HTMLTableSectionElement> HTMLTableElement::create_t_head()
 {
     auto maybe_thead = t_head();
     if (maybe_thead)
@@ -264,7 +264,7 @@ void HTMLTableElement::delete_t_head()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-tfoot
-JS::GCPtr<HTMLTableSectionElement> HTMLTableElement::t_foot()
+GC::Ptr<HTMLTableSectionElement> HTMLTableElement::t_foot()
 {
     // The tFoot IDL attribute must return, on getting, the first tfoot element child of the table element,
     // if any, or null otherwise.
@@ -299,7 +299,7 @@ WebIDL::ExceptionOr<void> HTMLTableElement::set_t_foot(HTMLTableSectionElement*
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-createtfoot
-JS::NonnullGCPtr<HTMLTableSectionElement> HTMLTableElement::create_t_foot()
+GC::Ref<HTMLTableSectionElement> HTMLTableElement::create_t_foot()
 {
     auto maybe_tfoot = t_foot();
     if (maybe_tfoot)
@@ -320,7 +320,7 @@ void HTMLTableElement::delete_t_foot()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-tbodies
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableElement::t_bodies()
+GC::Ref<DOM::HTMLCollection> HTMLTableElement::t_bodies()
 {
     // The tBodies attribute must return an HTMLCollection rooted at the table node,
     // whose filter matches only tbody elements that are children of the table element.
@@ -333,7 +333,7 @@ JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableElement::t_bodies()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-createtbody
-JS::NonnullGCPtr<HTMLTableSectionElement> HTMLTableElement::create_t_body()
+GC::Ref<HTMLTableSectionElement> HTMLTableElement::create_t_body()
 {
     auto tbody = DOM::create_element(document(), TagNames::tbody, Namespace::HTML).release_value_but_fixme_should_propagate_errors();
 
@@ -358,7 +358,7 @@ JS::NonnullGCPtr<HTMLTableSectionElement> HTMLTableElement::create_t_body()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-rows
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableElement::rows()
+GC::Ref<DOM::HTMLCollection> HTMLTableElement::rows()
 {
     HTMLTableElement* table_node = this;
     // FIXME:  The elements in the collection must be ordered such that those elements whose parent is a thead are
@@ -390,7 +390,7 @@ JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableElement::rows()
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-insertrow
-WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> HTMLTableElement::insert_row(WebIDL::Long index)
+WebIDL::ExceptionOr<GC::Ref<HTMLTableRowElement>> HTMLTableElement::insert_row(WebIDL::Long index)
 {
     auto rows = this->rows();
     auto rows_length = rows->length();
@@ -412,7 +412,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> HTMLTableElement::ins
     } else {
         rows->item(index)->parent_element()->insert_before(tr, rows->item(index));
     }
-    return JS::NonnullGCPtr(tr);
+    return GC::Ref(tr);
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-table-deleterow
diff --git a/Libraries/LibWeb/HTML/HTMLTableElement.h b/Libraries/LibWeb/HTML/HTMLTableElement.h
index 3cf064375c4..eee1c0da7b1 100644
--- a/Libraries/LibWeb/HTML/HTMLTableElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableElement.h
@@ -17,31 +17,31 @@ namespace Web::HTML {
 
 class HTMLTableElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableElement);
 
 public:
     virtual ~HTMLTableElement() override;
 
-    JS::GCPtr<HTMLTableCaptionElement> caption();
+    GC::Ptr<HTMLTableCaptionElement> caption();
     WebIDL::ExceptionOr<void> set_caption(HTMLTableCaptionElement*);
-    JS::NonnullGCPtr<HTMLTableCaptionElement> create_caption();
+    GC::Ref<HTMLTableCaptionElement> create_caption();
     void delete_caption();
 
-    JS::GCPtr<HTMLTableSectionElement> t_head();
+    GC::Ptr<HTMLTableSectionElement> t_head();
     WebIDL::ExceptionOr<void> set_t_head(HTMLTableSectionElement* thead);
-    JS::NonnullGCPtr<HTMLTableSectionElement> create_t_head();
+    GC::Ref<HTMLTableSectionElement> create_t_head();
     void delete_t_head();
 
-    JS::GCPtr<HTMLTableSectionElement> t_foot();
+    GC::Ptr<HTMLTableSectionElement> t_foot();
     WebIDL::ExceptionOr<void> set_t_foot(HTMLTableSectionElement* tfoot);
-    JS::NonnullGCPtr<HTMLTableSectionElement> create_t_foot();
+    GC::Ref<HTMLTableSectionElement> create_t_foot();
     void delete_t_foot();
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> t_bodies();
-    JS::NonnullGCPtr<HTMLTableSectionElement> create_t_body();
+    GC::Ref<DOM::HTMLCollection> t_bodies();
+    GC::Ref<HTMLTableSectionElement> create_t_body();
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> rows();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> insert_row(WebIDL::Long index);
+    GC::Ref<DOM::HTMLCollection> rows();
+    WebIDL::ExceptionOr<GC::Ref<HTMLTableRowElement>> insert_row(WebIDL::Long index);
     WebIDL::ExceptionOr<void> delete_row(WebIDL::Long index);
 
     // https://www.w3.org/TR/html-aria/#el-table
@@ -61,8 +61,8 @@ private:
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
-    JS::GCPtr<DOM::HTMLCollection> mutable m_rows;
-    JS::GCPtr<DOM::HTMLCollection> mutable m_t_bodies;
+    GC::Ptr<DOM::HTMLCollection> mutable m_rows;
+    GC::Ptr<DOM::HTMLCollection> mutable m_t_bodies;
     unsigned m_padding { 1 };
 };
 
diff --git a/Libraries/LibWeb/HTML/HTMLTableRowElement.cpp b/Libraries/LibWeb/HTML/HTMLTableRowElement.cpp
index 54d66edcae6..6e71e30bc3d 100644
--- a/Libraries/LibWeb/HTML/HTMLTableRowElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableRowElement.cpp
@@ -24,7 +24,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableRowElement);
+GC_DEFINE_ALLOCATOR(HTMLTableRowElement);
 
 HTMLTableRowElement::HTMLTableRowElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -68,7 +68,7 @@ void HTMLTableRowElement::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tr-cells
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableRowElement::cells() const
+GC::Ref<DOM::HTMLCollection> HTMLTableRowElement::cells() const
 {
     // The cells attribute must return an HTMLCollection rooted at this tr element,
     // whose filter matches only td and th elements that are children of the tr element.
@@ -87,7 +87,7 @@ int HTMLTableRowElement::row_index() const
     // or a parent tbody, thead, or tfoot element and a grandparent table element,
     // return the index of this tr element in that table element's rows collection.
     // If there is no such table element, then the attribute must return −1.
-    auto rows_collection = [&]() -> JS::GCPtr<DOM::HTMLCollection> {
+    auto rows_collection = [&]() -> GC::Ptr<DOM::HTMLCollection> {
         if (!parent())
             return nullptr;
         if (is<HTMLTableElement>(*parent()))
@@ -112,7 +112,7 @@ int HTMLTableRowElement::section_row_index() const
     // return the index of the tr element in the parent element's rows collection
     // (for tables, that's HTMLTableElement's rows collection; for table sections, that's HTMLTableSectionElement's rows collection).
     // If there is no such parent element, then the attribute must return −1.
-    auto rows_collection = [&]() -> JS::GCPtr<DOM::HTMLCollection> {
+    auto rows_collection = [&]() -> GC::Ptr<DOM::HTMLCollection> {
         if (!parent())
             return nullptr;
         if (is<HTMLTableElement>(*parent()))
@@ -132,7 +132,7 @@ int HTMLTableRowElement::section_row_index() const
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tr-insertcell
-WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableCellElement>> HTMLTableRowElement::insert_cell(i32 index)
+WebIDL::ExceptionOr<GC::Ref<HTMLTableCellElement>> HTMLTableRowElement::insert_cell(i32 index)
 {
     auto cells_collection = cells();
     auto cells_collection_size = static_cast<i32>(cells_collection->length());
@@ -153,7 +153,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableCellElement>> HTMLTableRowElement:
         insert_before(table_cell, cells_collection->item(index));
 
     // 5. Return table cell.
-    return JS::NonnullGCPtr(table_cell);
+    return GC::Ref(table_cell);
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tr-deletecell
diff --git a/Libraries/LibWeb/HTML/HTMLTableRowElement.h b/Libraries/LibWeb/HTML/HTMLTableRowElement.h
index fba3aca3684..757e82f88a3 100644
--- a/Libraries/LibWeb/HTML/HTMLTableRowElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableRowElement.h
@@ -13,16 +13,16 @@ namespace Web::HTML {
 
 class HTMLTableRowElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableRowElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableRowElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableRowElement);
 
 public:
     virtual ~HTMLTableRowElement() override;
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> cells() const;
+    GC::Ref<DOM::HTMLCollection> cells() const;
 
     int row_index() const;
     int section_row_index() const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableCellElement>> insert_cell(i32 index);
+    WebIDL::ExceptionOr<GC::Ref<HTMLTableCellElement>> insert_cell(i32 index);
     WebIDL::ExceptionOr<void> delete_cell(i32 index);
 
     // https://www.w3.org/TR/html-aria/#el-tr
@@ -37,7 +37,7 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
-    JS::GCPtr<DOM::HTMLCollection> mutable m_cells;
+    GC::Ptr<DOM::HTMLCollection> mutable m_cells;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLTableSectionElement.cpp b/Libraries/LibWeb/HTML/HTMLTableSectionElement.cpp
index 7abd4d2d2a7..31e4fc91a8a 100644
--- a/Libraries/LibWeb/HTML/HTMLTableSectionElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTableSectionElement.cpp
@@ -20,7 +20,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTableSectionElement);
+GC_DEFINE_ALLOCATOR(HTMLTableSectionElement);
 
 HTMLTableSectionElement::HTMLTableSectionElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -42,7 +42,7 @@ void HTMLTableSectionElement::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tbody-rows
-JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableSectionElement::rows() const
+GC::Ref<DOM::HTMLCollection> HTMLTableSectionElement::rows() const
 {
     // The rows attribute must return an HTMLCollection rooted at this element,
     // whose filter matches only tr elements that are children of this element.
@@ -55,7 +55,7 @@ JS::NonnullGCPtr<DOM::HTMLCollection> HTMLTableSectionElement::rows() const
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tbody-insertrow
-WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> HTMLTableSectionElement::insert_row(WebIDL::Long index)
+WebIDL::ExceptionOr<GC::Ref<HTMLTableRowElement>> HTMLTableSectionElement::insert_row(WebIDL::Long index)
 {
     auto rows_collection = rows();
     auto rows_collection_size = static_cast<long>(rows_collection->length());
@@ -75,7 +75,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> HTMLTableSectionEleme
         insert_before(table_row, rows_collection->item(index));
 
     // 5. Return table row.
-    return JS::NonnullGCPtr(table_row);
+    return GC::Ref(table_row);
 }
 
 // https://html.spec.whatwg.org/multipage/tables.html#dom-tbody-deleterow
diff --git a/Libraries/LibWeb/HTML/HTMLTableSectionElement.h b/Libraries/LibWeb/HTML/HTMLTableSectionElement.h
index 99fad7b7150..f40780b4999 100644
--- a/Libraries/LibWeb/HTML/HTMLTableSectionElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTableSectionElement.h
@@ -15,13 +15,13 @@ namespace Web::HTML {
 
 class HTMLTableSectionElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTableSectionElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTableSectionElement);
+    GC_DECLARE_ALLOCATOR(HTMLTableSectionElement);
 
 public:
     virtual ~HTMLTableSectionElement() override;
 
-    JS::NonnullGCPtr<DOM::HTMLCollection> rows() const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<HTMLTableRowElement>> insert_row(WebIDL::Long index);
+    GC::Ref<DOM::HTMLCollection> rows() const;
+    WebIDL::ExceptionOr<GC::Ref<HTMLTableRowElement>> insert_row(WebIDL::Long index);
     WebIDL::ExceptionOr<void> delete_row(WebIDL::Long index);
 
     // https://www.w3.org/TR/html-aria/#el-tbody
@@ -39,7 +39,7 @@ private:
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
-    JS::GCPtr<DOM::HTMLCollection> mutable m_rows;
+    GC::Ptr<DOM::HTMLCollection> mutable m_rows;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLTemplateElement.cpp b/Libraries/LibWeb/HTML/HTMLTemplateElement.cpp
index f27948c6e98..fbf8572c485 100644
--- a/Libraries/LibWeb/HTML/HTMLTemplateElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTemplateElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTemplateElement);
+GC_DEFINE_ALLOCATOR(HTMLTemplateElement);
 
 HTMLTemplateElement::HTMLTemplateElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
@@ -63,7 +63,7 @@ WebIDL::ExceptionOr<void> HTMLTemplateElement::cloned(Node& copy, bool clone_chi
     return {};
 }
 
-void HTMLTemplateElement::set_template_contents(JS::NonnullGCPtr<DOM::DocumentFragment> contents)
+void HTMLTemplateElement::set_template_contents(GC::Ref<DOM::DocumentFragment> contents)
 {
     m_content = contents;
 }
diff --git a/Libraries/LibWeb/HTML/HTMLTemplateElement.h b/Libraries/LibWeb/HTML/HTMLTemplateElement.h
index 39947a2d9c7..488591d0ddf 100644
--- a/Libraries/LibWeb/HTML/HTMLTemplateElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTemplateElement.h
@@ -13,15 +13,15 @@ namespace Web::HTML {
 
 class HTMLTemplateElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTemplateElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTemplateElement);
+    GC_DECLARE_ALLOCATOR(HTMLTemplateElement);
 
 public:
     virtual ~HTMLTemplateElement() override;
 
-    JS::NonnullGCPtr<DOM::DocumentFragment> content() { return *m_content; }
-    JS::NonnullGCPtr<DOM::DocumentFragment> const content() const { return *m_content; }
+    GC::Ref<DOM::DocumentFragment> content() { return *m_content; }
+    GC::Ref<DOM::DocumentFragment> const content() const { return *m_content; }
 
-    void set_template_contents(JS::NonnullGCPtr<DOM::DocumentFragment>);
+    void set_template_contents(GC::Ref<DOM::DocumentFragment>);
 
     virtual void adopted_from(DOM::Document&) override;
     virtual WebIDL::ExceptionOr<void> cloned(Node& copy, bool clone_children) override;
@@ -34,7 +34,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::DocumentFragment> m_content;
+    GC::Ptr<DOM::DocumentFragment> m_content;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp b/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
index 7786093de72..17da0fab735 100644
--- a/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
@@ -27,7 +27,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTextAreaElement);
+GC_DEFINE_ALLOCATOR(HTMLTextAreaElement);
 
 HTMLTextAreaElement::HTMLTextAreaElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTextAreaElement.h b/Libraries/LibWeb/HTML/HTMLTextAreaElement.h
index 27f9b4b6851..00b55ddfecb 100644
--- a/Libraries/LibWeb/HTML/HTMLTextAreaElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTextAreaElement.h
@@ -22,7 +22,7 @@ class HTMLTextAreaElement final
     : public HTMLElement
     , public FormAssociatedTextControlElement {
     WEB_PLATFORM_OBJECT(HTMLTextAreaElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTextAreaElement);
+    GC_DECLARE_ALLOCATOR(HTMLTextAreaElement);
     FORM_ASSOCIATED_ELEMENT(HTMLElement, HTMLTextAreaElement)
 
 public:
@@ -124,7 +124,7 @@ public:
 
     // ^FormAssociatedTextControlElement
     virtual void did_edit_text_node() override;
-    virtual JS::GCPtr<DOM::Text> form_associated_element_to_text_node() override { return m_text_node; }
+    virtual GC::Ptr<DOM::Text> form_associated_element_to_text_node() override { return m_text_node; }
 
 private:
     HTMLTextAreaElement(DOM::Document&, DOM::QualifiedName);
@@ -146,11 +146,11 @@ private:
 
     void update_placeholder_visibility();
 
-    JS::GCPtr<DOM::Element> m_placeholder_element;
-    JS::GCPtr<DOM::Text> m_placeholder_text_node;
+    GC::Ptr<DOM::Element> m_placeholder_element;
+    GC::Ptr<DOM::Text> m_placeholder_text_node;
 
-    JS::GCPtr<DOM::Element> m_inner_text_element;
-    JS::GCPtr<DOM::Text> m_text_node;
+    GC::Ptr<DOM::Element> m_inner_text_element;
+    GC::Ptr<DOM::Text> m_text_node;
 
     RefPtr<Core::Timer> m_input_event_timer;
 
diff --git a/Libraries/LibWeb/HTML/HTMLTimeElement.cpp b/Libraries/LibWeb/HTML/HTMLTimeElement.cpp
index 7fea0def6c7..a845ac88273 100644
--- a/Libraries/LibWeb/HTML/HTMLTimeElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTimeElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTimeElement);
+GC_DEFINE_ALLOCATOR(HTMLTimeElement);
 
 HTMLTimeElement::HTMLTimeElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTimeElement.h b/Libraries/LibWeb/HTML/HTMLTimeElement.h
index d94199c2add..b3278ef1ced 100644
--- a/Libraries/LibWeb/HTML/HTMLTimeElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTimeElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLTimeElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTimeElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTimeElement);
+    GC_DECLARE_ALLOCATOR(HTMLTimeElement);
 
 public:
     virtual ~HTMLTimeElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTitleElement.cpp b/Libraries/LibWeb/HTML/HTMLTitleElement.cpp
index a9a6922194b..0a7bc75f7e6 100644
--- a/Libraries/LibWeb/HTML/HTMLTitleElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTitleElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTitleElement);
+GC_DEFINE_ALLOCATOR(HTMLTitleElement);
 
 HTMLTitleElement::HTMLTitleElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTitleElement.h b/Libraries/LibWeb/HTML/HTMLTitleElement.h
index 4e434df1ad0..25facd1cb62 100644
--- a/Libraries/LibWeb/HTML/HTMLTitleElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTitleElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLTitleElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTitleElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTitleElement);
+    GC_DECLARE_ALLOCATOR(HTMLTitleElement);
 
 public:
     virtual ~HTMLTitleElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLTrackElement.cpp b/Libraries/LibWeb/HTML/HTMLTrackElement.cpp
index 99682937212..09527fa239d 100644
--- a/Libraries/LibWeb/HTML/HTMLTrackElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLTrackElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLTrackElement);
+GC_DEFINE_ALLOCATOR(HTMLTrackElement);
 
 HTMLTrackElement::HTMLTrackElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLTrackElement.h b/Libraries/LibWeb/HTML/HTMLTrackElement.h
index 1710a472d67..630d1ab0f07 100644
--- a/Libraries/LibWeb/HTML/HTMLTrackElement.h
+++ b/Libraries/LibWeb/HTML/HTMLTrackElement.h
@@ -14,14 +14,14 @@ namespace Web::HTML {
 
 class HTMLTrackElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLTrackElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLTrackElement);
+    GC_DECLARE_ALLOCATOR(HTMLTrackElement);
 
 public:
     virtual ~HTMLTrackElement() override;
 
     WebIDL::UnsignedShort ready_state();
 
-    JS::Handle<TextTrack> track() { return m_track; }
+    GC::Root<TextTrack> track() { return m_track; }
 
 private:
     HTMLTrackElement(DOM::Document&, DOM::QualifiedName);
@@ -32,7 +32,7 @@ private:
     // ^DOM::Element
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
-    JS::GCPtr<TextTrack> m_track;
+    GC::Ptr<TextTrack> m_track;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/HTMLUListElement.cpp b/Libraries/LibWeb/HTML/HTMLUListElement.cpp
index 9560e37b22e..5c6e74ee628 100644
--- a/Libraries/LibWeb/HTML/HTMLUListElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLUListElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLUListElement);
+GC_DEFINE_ALLOCATOR(HTMLUListElement);
 
 HTMLUListElement::HTMLUListElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLUListElement.h b/Libraries/LibWeb/HTML/HTMLUListElement.h
index 7dd426212b2..50ab0f5e143 100644
--- a/Libraries/LibWeb/HTML/HTMLUListElement.h
+++ b/Libraries/LibWeb/HTML/HTMLUListElement.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class HTMLUListElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLUListElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLUListElement);
+    GC_DECLARE_ALLOCATOR(HTMLUListElement);
 
 public:
     virtual ~HTMLUListElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLUnknownElement.cpp b/Libraries/LibWeb/HTML/HTMLUnknownElement.cpp
index a8fff5a0c58..0243f45e4f6 100644
--- a/Libraries/LibWeb/HTML/HTMLUnknownElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLUnknownElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLUnknownElement);
+GC_DEFINE_ALLOCATOR(HTMLUnknownElement);
 
 HTMLUnknownElement::HTMLUnknownElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/HTML/HTMLUnknownElement.h b/Libraries/LibWeb/HTML/HTMLUnknownElement.h
index 6dd1e692a65..fce30a421d5 100644
--- a/Libraries/LibWeb/HTML/HTMLUnknownElement.h
+++ b/Libraries/LibWeb/HTML/HTMLUnknownElement.h
@@ -12,7 +12,7 @@ namespace Web::HTML {
 
 class HTMLUnknownElement final : public HTMLElement {
     WEB_PLATFORM_OBJECT(HTMLUnknownElement, HTMLElement);
-    JS_DECLARE_ALLOCATOR(HTMLUnknownElement);
+    GC_DECLARE_ALLOCATOR(HTMLUnknownElement);
 
 public:
     virtual ~HTMLUnknownElement() override;
diff --git a/Libraries/LibWeb/HTML/HTMLVideoElement.cpp b/Libraries/LibWeb/HTML/HTMLVideoElement.cpp
index de480344941..204497454f6 100644
--- a/Libraries/LibWeb/HTML/HTMLVideoElement.cpp
+++ b/Libraries/LibWeb/HTML/HTMLVideoElement.cpp
@@ -24,7 +24,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLVideoElement);
+GC_DEFINE_ALLOCATOR(HTMLVideoElement);
 
 HTMLVideoElement::HTMLVideoElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : HTMLMediaElement(document, move(qualified_name))
@@ -63,7 +63,7 @@ void HTMLVideoElement::attribute_changed(FlyString const& name, Optional<String>
     }
 }
 
-JS::GCPtr<Layout::Node> HTMLVideoElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> HTMLVideoElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::VideoBox>(document(), *this, move(style));
 }
@@ -107,7 +107,7 @@ u32 HTMLVideoElement::video_height() const
     return m_video_height;
 }
 
-void HTMLVideoElement::set_video_track(JS::GCPtr<HTML::VideoTrack> video_track)
+void HTMLVideoElement::set_video_track(GC::Ptr<HTML::VideoTrack> video_track)
 {
     set_needs_style_update(true);
     document().set_needs_layout();
@@ -196,13 +196,13 @@ WebIDL::ExceptionOr<void> HTMLVideoElement::determine_element_poster_frame(Optio
             response = filtered_response.internal_response();
         }
 
-        auto on_image_data_read = JS::create_heap_function(heap(), [this](ByteBuffer image_data) mutable {
+        auto on_image_data_read = GC::create_function(heap(), [this](ByteBuffer image_data) mutable {
             m_fetch_controller = nullptr;
 
             // 6. If an image is thus obtained, the poster frame is that image. Otherwise, there is no poster frame.
             (void)Platform::ImageCodecPlugin::the().decode_image(
                 image_data,
-                [strong_this = JS::Handle(*this)](Web::Platform::DecodedImage& image) -> ErrorOr<void> {
+                [strong_this = GC::Root(*this)](Web::Platform::DecodedImage& image) -> ErrorOr<void> {
                     if (!image.frames.is_empty())
                         strong_this->m_poster_frame = move(image.frames[0].bitmap);
                     return {};
@@ -211,9 +211,9 @@ WebIDL::ExceptionOr<void> HTMLVideoElement::determine_element_poster_frame(Optio
         });
 
         VERIFY(response->body());
-        auto empty_algorithm = JS::create_heap_function(heap(), [](JS::Value) {});
+        auto empty_algorithm = GC::create_function(heap(), [](JS::Value) {});
 
-        response->body()->fully_read(realm, on_image_data_read, empty_algorithm, JS::NonnullGCPtr { global });
+        response->body()->fully_read(realm, on_image_data_read, empty_algorithm, GC::Ref { global });
     };
 
     m_fetch_controller = TRY(Fetch::Fetching::fetch(realm, request, Fetch::Infrastructure::FetchAlgorithms::create(vm, move(fetch_algorithms_input))));
diff --git a/Libraries/LibWeb/HTML/HTMLVideoElement.h b/Libraries/LibWeb/HTML/HTMLVideoElement.h
index f0b67b658bc..4882ca30738 100644
--- a/Libraries/LibWeb/HTML/HTMLVideoElement.h
+++ b/Libraries/LibWeb/HTML/HTMLVideoElement.h
@@ -22,7 +22,7 @@ struct VideoFrame {
 
 class HTMLVideoElement final : public HTMLMediaElement {
     WEB_PLATFORM_OBJECT(HTMLVideoElement, HTMLMediaElement);
-    JS_DECLARE_ALLOCATOR(HTMLVideoElement);
+    GC_DECLARE_ALLOCATOR(HTMLVideoElement);
 
 public:
     virtual ~HTMLVideoElement() override;
@@ -36,7 +36,7 @@ public:
     void set_video_height(u32 video_height) { m_video_height = video_height; }
     u32 video_height() const;
 
-    void set_video_track(JS::GCPtr<VideoTrack>);
+    void set_video_track(GC::Ptr<VideoTrack>);
 
     void set_current_frame(Badge<VideoTrack>, RefPtr<Gfx::Bitmap> frame, double position);
     VideoFrame const& current_frame() const { return m_current_frame; }
@@ -60,7 +60,7 @@ private:
     // https://html.spec.whatwg.org/multipage/media.html#the-video-element:dimension-attributes
     virtual bool supports_dimension_attributes() const override { return true; }
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void adjust_computed_style(CSS::StyleProperties&) override;
 
     virtual void on_playing() override;
@@ -69,14 +69,14 @@ private:
 
     WebIDL::ExceptionOr<void> determine_element_poster_frame(Optional<String> const& poster);
 
-    JS::GCPtr<HTML::VideoTrack> m_video_track;
+    GC::Ptr<HTML::VideoTrack> m_video_track;
     VideoFrame m_current_frame;
     RefPtr<Gfx::Bitmap> m_poster_frame;
 
     u32 m_video_width { 0 };
     u32 m_video_height { 0 };
 
-    JS::GCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
 };
 
diff --git a/Libraries/LibWeb/HTML/HashChangeEvent.cpp b/Libraries/LibWeb/HTML/HashChangeEvent.cpp
index f660c69f2b0..bb9d3deb971 100644
--- a/Libraries/LibWeb/HTML/HashChangeEvent.cpp
+++ b/Libraries/LibWeb/HTML/HashChangeEvent.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/HashChangeEventPrototype.h>
 #include <LibWeb/Bindings/Intrinsics.h>
@@ -12,14 +12,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HashChangeEvent);
+GC_DEFINE_ALLOCATOR(HashChangeEvent);
 
-[[nodiscard]] JS::NonnullGCPtr<HashChangeEvent> HashChangeEvent::create(JS::Realm& realm, FlyString const& event_name, HashChangeEventInit const& event_init)
+[[nodiscard]] GC::Ref<HashChangeEvent> HashChangeEvent::create(JS::Realm& realm, FlyString const& event_name, HashChangeEventInit const& event_init)
 {
     return realm.create<HashChangeEvent>(realm, event_name, event_init);
 }
 
-JS::NonnullGCPtr<HashChangeEvent> HashChangeEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, HashChangeEventInit const& event_init)
+GC::Ref<HashChangeEvent> HashChangeEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, HashChangeEventInit const& event_init)
 {
     return realm.create<HashChangeEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/HashChangeEvent.h b/Libraries/LibWeb/HTML/HashChangeEvent.h
index 2b51cc9b4a1..055b31e9924 100644
--- a/Libraries/LibWeb/HTML/HashChangeEvent.h
+++ b/Libraries/LibWeb/HTML/HashChangeEvent.h
@@ -17,11 +17,11 @@ struct HashChangeEventInit : public DOM::EventInit {
 
 class HashChangeEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(HashChangeEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(HashChangeEvent);
+    GC_DECLARE_ALLOCATOR(HashChangeEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<HashChangeEvent> create(JS::Realm&, FlyString const& event_name, HashChangeEventInit const&);
-    [[nodiscard]] static JS::NonnullGCPtr<HashChangeEvent> construct_impl(JS::Realm&, FlyString const& event_name, HashChangeEventInit const&);
+    [[nodiscard]] static GC::Ref<HashChangeEvent> create(JS::Realm&, FlyString const& event_name, HashChangeEventInit const&);
+    [[nodiscard]] static GC::Ref<HashChangeEvent> construct_impl(JS::Realm&, FlyString const& event_name, HashChangeEventInit const&);
 
     String old_url() const { return m_old_url; }
     String new_url() const { return m_new_url; }
diff --git a/Libraries/LibWeb/HTML/History.cpp b/Libraries/LibWeb/HTML/History.cpp
index 654e416c8b5..e9b4e759db8 100644
--- a/Libraries/LibWeb/HTML/History.cpp
+++ b/Libraries/LibWeb/HTML/History.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(History);
+GC_DEFINE_ALLOCATOR(History);
 
-JS::NonnullGCPtr<History> History::create(JS::Realm& realm, DOM::Document& document)
+GC::Ref<History> History::create(JS::Realm& realm, DOM::Document& document)
 {
     return realm.create<History>(realm, document);
 }
diff --git a/Libraries/LibWeb/HTML/History.h b/Libraries/LibWeb/HTML/History.h
index 875e8b28581..a3b86e978ee 100644
--- a/Libraries/LibWeb/HTML/History.h
+++ b/Libraries/LibWeb/HTML/History.h
@@ -17,10 +17,10 @@ namespace Web::HTML {
 
 class History final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(History, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(History);
+    GC_DECLARE_ALLOCATOR(History);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<History> create(JS::Realm&, DOM::Document&);
+    [[nodiscard]] static GC::Ref<History> create(JS::Realm&, DOM::Document&);
 
     virtual ~History() override;
 
@@ -48,7 +48,7 @@ private:
 
     WebIDL::ExceptionOr<void> shared_history_push_replace_state(JS::Value data, Optional<String> const& url, HistoryHandlingBehavior);
 
-    JS::NonnullGCPtr<DOM::Document> m_associated_document;
+    GC::Ref<DOM::Document> m_associated_document;
     JS::Value m_state { JS::js_null() };
 };
 
diff --git a/Libraries/LibWeb/HTML/ImageBitmap.cpp b/Libraries/LibWeb/HTML/ImageBitmap.cpp
index 3edeeface5c..aedf8c2f6f2 100644
--- a/Libraries/LibWeb/HTML/ImageBitmap.cpp
+++ b/Libraries/LibWeb/HTML/ImageBitmap.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ImageBitmap);
+GC_DEFINE_ALLOCATOR(ImageBitmap);
 
-JS::NonnullGCPtr<ImageBitmap> ImageBitmap::create(JS::Realm& realm)
+GC::Ref<ImageBitmap> ImageBitmap::create(JS::Realm& realm)
 {
     return realm.create<ImageBitmap>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/ImageBitmap.h b/Libraries/LibWeb/HTML/ImageBitmap.h
index 294ccc7edcb..c1ede98b76e 100644
--- a/Libraries/LibWeb/HTML/ImageBitmap.h
+++ b/Libraries/LibWeb/HTML/ImageBitmap.h
@@ -16,7 +16,7 @@
 
 namespace Web::HTML {
 
-using ImageBitmapSource = Variant<CanvasImageSource, JS::Handle<FileAPI::Blob>, JS::Handle<ImageData>>;
+using ImageBitmapSource = Variant<CanvasImageSource, GC::Root<FileAPI::Blob>, GC::Root<ImageData>>;
 
 // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#imagebitmapoptions
 struct ImageBitmapOptions {
@@ -27,10 +27,10 @@ class ImageBitmap final : public Bindings::PlatformObject
     , public Web::Bindings::Serializable
     , public Web::Bindings::Transferable {
     WEB_PLATFORM_OBJECT(ImageBitmap, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ImageBitmap);
+    GC_DECLARE_ALLOCATOR(ImageBitmap);
 
 public:
-    static JS::NonnullGCPtr<ImageBitmap> create(JS::Realm&);
+    static GC::Ref<ImageBitmap> create(JS::Realm&);
     virtual ~ImageBitmap() override = default;
 
     // ^Web::Bindings::Serializable
diff --git a/Libraries/LibWeb/HTML/ImageData.cpp b/Libraries/LibWeb/HTML/ImageData.cpp
index b6914617669..346275b4259 100644
--- a/Libraries/LibWeb/HTML/ImageData.cpp
+++ b/Libraries/LibWeb/HTML/ImageData.cpp
@@ -16,10 +16,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ImageData);
+GC_DEFINE_ALLOCATOR(ImageData);
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-imagedata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::create(JS::Realm& realm, u32 sw, u32 sh, Optional<ImageDataSettings> const&)
+WebIDL::ExceptionOr<GC::Ref<ImageData>> ImageData::create(JS::Realm& realm, u32 sw, u32 sh, Optional<ImageDataSettings> const&)
 {
     auto& vm = realm.vm();
 
@@ -43,13 +43,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::create(JS::Realm& re
     return realm.create<ImageData>(realm, bitmap, data);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::construct_impl(JS::Realm& realm, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings)
+WebIDL::ExceptionOr<GC::Ref<ImageData>> ImageData::construct_impl(JS::Realm& realm, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings)
 {
     return ImageData::create(realm, sw, sh, settings);
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-imagedata-with-data
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::create(JS::Realm& realm, JS::Handle<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh, Optional<ImageDataSettings> const&)
+WebIDL::ExceptionOr<GC::Ref<ImageData>> ImageData::create(JS::Realm& realm, GC::Root<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh, Optional<ImageDataSettings> const&)
 {
     auto& vm = realm.vm();
 
@@ -87,12 +87,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::create(JS::Realm& re
     return realm.create<ImageData>(realm, bitmap, uint8_clamped_array_data);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> ImageData::construct_impl(JS::Realm& realm, JS::Handle<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh, Optional<ImageDataSettings> const& settings)
+WebIDL::ExceptionOr<GC::Ref<ImageData>> ImageData::construct_impl(JS::Realm& realm, GC::Root<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh, Optional<ImageDataSettings> const& settings)
 {
     return ImageData::create(realm, data, sw, move(sh), settings);
 }
 
-ImageData::ImageData(JS::Realm& realm, NonnullRefPtr<Gfx::Bitmap> bitmap, JS::NonnullGCPtr<JS::Uint8ClampedArray> data)
+ImageData::ImageData(JS::Realm& realm, NonnullRefPtr<Gfx::Bitmap> bitmap, GC::Ref<JS::Uint8ClampedArray> data)
     : PlatformObject(realm)
     , m_bitmap(move(bitmap))
     , m_data(move(data))
diff --git a/Libraries/LibWeb/HTML/ImageData.h b/Libraries/LibWeb/HTML/ImageData.h
index 797cf7a8cdd..652060f8939 100644
--- a/Libraries/LibWeb/HTML/ImageData.h
+++ b/Libraries/LibWeb/HTML/ImageData.h
@@ -19,14 +19,14 @@ struct ImageDataSettings {
 
 class ImageData final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ImageData, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ImageData);
+    GC_DECLARE_ALLOCATOR(ImageData);
 
 public:
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create(JS::Realm&, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings = {});
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> create(JS::Realm&, JS::Handle<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh = {}, Optional<ImageDataSettings> const& settings = {});
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<ImageData>> create(JS::Realm&, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings = {});
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<ImageData>> create(JS::Realm&, GC::Root<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh = {}, Optional<ImageDataSettings> const& settings = {});
 
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> construct_impl(JS::Realm&, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings = {});
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<ImageData>> construct_impl(JS::Realm&, JS::Handle<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh = {}, Optional<ImageDataSettings> const& settings = {});
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<ImageData>> construct_impl(JS::Realm&, u32 sw, u32 sh, Optional<ImageDataSettings> const& settings = {});
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<ImageData>> construct_impl(JS::Realm&, GC::Root<WebIDL::BufferSource> const& data, u32 sw, Optional<u32> sh = {}, Optional<ImageDataSettings> const& settings = {});
 
     virtual ~ImageData() override;
 
@@ -40,13 +40,13 @@ public:
     const JS::Uint8ClampedArray* data() const;
 
 private:
-    ImageData(JS::Realm&, NonnullRefPtr<Gfx::Bitmap>, JS::NonnullGCPtr<JS::Uint8ClampedArray>);
+    ImageData(JS::Realm&, NonnullRefPtr<Gfx::Bitmap>, GC::Ref<JS::Uint8ClampedArray>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     NonnullRefPtr<Gfx::Bitmap> m_bitmap;
-    JS::NonnullGCPtr<JS::Uint8ClampedArray> m_data;
+    GC::Ref<JS::Uint8ClampedArray> m_data;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/ImageRequest.cpp b/Libraries/LibWeb/HTML/ImageRequest.cpp
index d77290fdb93..69222078f0e 100644
--- a/Libraries/LibWeb/HTML/ImageRequest.cpp
+++ b/Libraries/LibWeb/HTML/ImageRequest.cpp
@@ -21,14 +21,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ImageRequest);
+GC_DEFINE_ALLOCATOR(ImageRequest);
 
-JS::NonnullGCPtr<ImageRequest> ImageRequest::create(JS::Realm& realm, JS::NonnullGCPtr<Page> page)
+GC::Ref<ImageRequest> ImageRequest::create(JS::Realm& realm, GC::Ref<Page> page)
 {
     return realm.create<ImageRequest>(page);
 }
 
-ImageRequest::ImageRequest(JS::NonnullGCPtr<Page> page)
+ImageRequest::ImageRequest(GC::Ref<Page> page)
     : m_page(page)
 {
 }
@@ -94,12 +94,12 @@ void abort_the_image_request(JS::Realm&, ImageRequest* image_request)
     // AD-HOC: We simply don't do this, since our SharedResourceRequest may be used by someone else.
 }
 
-JS::GCPtr<DecodedImageData> ImageRequest::image_data() const
+GC::Ptr<DecodedImageData> ImageRequest::image_data() const
 {
     return m_image_data;
 }
 
-void ImageRequest::set_image_data(JS::GCPtr<DecodedImageData> data)
+void ImageRequest::set_image_data(GC::Ptr<DecodedImageData> data)
 {
     m_image_data = data;
 }
@@ -125,7 +125,7 @@ void ImageRequest::prepare_for_presentation(HTMLImageElement&)
     // FIXME: 16. Update req's img element's presentation appropriately.
 }
 
-void ImageRequest::fetch_image(JS::Realm& realm, JS::NonnullGCPtr<Fetch::Infrastructure::Request> request)
+void ImageRequest::fetch_image(JS::Realm& realm, GC::Ref<Fetch::Infrastructure::Request> request)
 {
     VERIFY(m_shared_resource_request);
     m_shared_resource_request->fetch_resource(realm, request);
diff --git a/Libraries/LibWeb/HTML/ImageRequest.h b/Libraries/LibWeb/HTML/ImageRequest.h
index fa27aecafac..5566ce77c12 100644
--- a/Libraries/LibWeb/HTML/ImageRequest.h
+++ b/Libraries/LibWeb/HTML/ImageRequest.h
@@ -8,8 +8,8 @@
 
 #include <AK/Error.h>
 #include <AK/OwnPtr.h>
+#include <LibGC/Root.h>
 #include <LibGfx/Size.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Forward.h>
 
@@ -17,11 +17,11 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/images.html#image-request
 class ImageRequest final : public JS::Cell {
-    JS_CELL(ImageRequest, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ImageRequest);
+    GC_CELL(ImageRequest, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ImageRequest);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ImageRequest> create(JS::Realm&, JS::NonnullGCPtr<Page>);
+    [[nodiscard]] static GC::Ref<ImageRequest> create(JS::Realm&, GC::Ref<Page>);
 
     ~ImageRequest();
 
@@ -42,8 +42,8 @@ public:
     URL::URL const& current_url() const;
     void set_current_url(JS::Realm&, URL::URL);
 
-    [[nodiscard]] JS::GCPtr<DecodedImageData> image_data() const;
-    void set_image_data(JS::GCPtr<DecodedImageData>);
+    [[nodiscard]] GC::Ptr<DecodedImageData> image_data() const;
+    void set_image_data(GC::Ptr<DecodedImageData>);
 
     [[nodiscard]] float current_pixel_density() const { return m_current_pixel_density; }
     void set_current_pixel_density(float density) { m_current_pixel_density = density; }
@@ -54,17 +54,17 @@ public:
     // https://html.spec.whatwg.org/multipage/images.html#prepare-an-image-for-presentation
     void prepare_for_presentation(HTMLImageElement&);
 
-    void fetch_image(JS::Realm&, JS::NonnullGCPtr<Fetch::Infrastructure::Request>);
+    void fetch_image(JS::Realm&, GC::Ref<Fetch::Infrastructure::Request>);
     void add_callbacks(Function<void()> on_finish, Function<void()> on_fail);
 
-    JS::GCPtr<SharedResourceRequest const> shared_resource_request() const { return m_shared_resource_request; }
+    GC::Ptr<SharedResourceRequest const> shared_resource_request() const { return m_shared_resource_request; }
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
 private:
-    explicit ImageRequest(JS::NonnullGCPtr<Page>);
+    explicit ImageRequest(GC::Ref<Page>);
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
 
     // https://html.spec.whatwg.org/multipage/images.html#img-req-state
     // An image request's state is initially unavailable.
@@ -75,7 +75,7 @@ private:
     URL::URL m_current_url;
 
     // https://html.spec.whatwg.org/multipage/images.html#img-req-data
-    JS::GCPtr<DecodedImageData> m_image_data;
+    GC::Ptr<DecodedImageData> m_image_data;
 
     // https://html.spec.whatwg.org/multipage/images.html#current-pixel-density
     // Each image request has a current pixel density, which must initially be 1.
@@ -86,7 +86,7 @@ private:
     // which is either a struct consisting of a width and a height or is null. It must initially be null.
     Optional<Gfx::FloatSize> m_preferred_density_corrected_dimensions;
 
-    JS::GCPtr<SharedResourceRequest> m_shared_resource_request;
+    GC::Ptr<SharedResourceRequest> m_shared_resource_request;
 };
 
 // https://html.spec.whatwg.org/multipage/images.html#abort-the-image-request
diff --git a/Libraries/LibWeb/HTML/LazyLoadingElement.h b/Libraries/LibWeb/HTML/LazyLoadingElement.h
index 420c8b0a5fc..46f0f8b7e69 100644
--- a/Libraries/LibWeb/HTML/LazyLoadingElement.h
+++ b/Libraries/LibWeb/HTML/LazyLoadingElement.h
@@ -13,13 +13,13 @@
 namespace Web::HTML {
 
 // Lazy-loaded elements should invoke this macro to inject overridden LazyLoadingElement methods.
-#define LAZY_LOADING_ELEMENT(ElementClass)                                                                     \
-private:                                                                                                       \
-    virtual JS::GCPtr<JS::HeapFunction<void()>> take_lazy_load_resumption_steps(Badge<DOM::Document>) override \
-    {                                                                                                          \
-        return take_lazy_load_resumption_steps_internal();                                                     \
-    }                                                                                                          \
-                                                                                                               \
+#define LAZY_LOADING_ELEMENT(ElementClass)                                                               \
+private:                                                                                                 \
+    virtual GC::Ptr<GC::Function<void()>> take_lazy_load_resumption_steps(Badge<DOM::Document>) override \
+    {                                                                                                    \
+        return take_lazy_load_resumption_steps_internal();                                               \
+    }                                                                                                    \
+                                                                                                         \
     virtual bool is_lazy_loading() const override { return true; }
 
 enum class LazyLoading {
@@ -63,7 +63,7 @@ public:
     {
         auto& element = static_cast<T&>(*this);
 
-        m_lazy_load_resumption_steps = JS::create_heap_function(element.vm().heap(), move(steps));
+        m_lazy_load_resumption_steps = GC::create_function(element.vm().heap(), move(steps));
     }
 
     void visit_lazy_loading_element(JS::Cell::Visitor& visitor)
@@ -75,7 +75,7 @@ protected:
     LazyLoadingElement() = default;
     virtual ~LazyLoadingElement() = default;
 
-    JS::GCPtr<JS::HeapFunction<void()>> take_lazy_load_resumption_steps_internal()
+    GC::Ptr<GC::Function<void()>> take_lazy_load_resumption_steps_internal()
     {
         auto lazy_load_resumption_steps = m_lazy_load_resumption_steps;
         m_lazy_load_resumption_steps = nullptr;
@@ -85,7 +85,7 @@ protected:
 private:
     // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#lazy-load-resumption-steps
     // Each img and iframe element has associated lazy load resumption steps, initially null.
-    JS::GCPtr<JS::HeapFunction<void()>> m_lazy_load_resumption_steps;
+    GC::Ptr<GC::Function<void()>> m_lazy_load_resumption_steps;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/ListOfAvailableImages.cpp b/Libraries/LibWeb/HTML/ListOfAvailableImages.cpp
index a63ca26460c..a5fcbe92339 100644
--- a/Libraries/LibWeb/HTML/ListOfAvailableImages.cpp
+++ b/Libraries/LibWeb/HTML/ListOfAvailableImages.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ListOfAvailableImages);
+GC_DEFINE_ALLOCATOR(ListOfAvailableImages);
 
 ListOfAvailableImages::ListOfAvailableImages() = default;
 ListOfAvailableImages::~ListOfAvailableImages() = default;
@@ -39,7 +39,7 @@ void ListOfAvailableImages::visit_edges(JS::Cell::Visitor& visitor)
         visitor.visit(it.value->image_data);
 }
 
-void ListOfAvailableImages::add(Key const& key, JS::NonnullGCPtr<DecodedImageData> image_data, bool ignore_higher_layer_caching)
+void ListOfAvailableImages::add(Key const& key, GC::Ref<DecodedImageData> image_data, bool ignore_higher_layer_caching)
 {
     m_images.set(key, make<Entry>(image_data, ignore_higher_layer_caching));
 }
diff --git a/Libraries/LibWeb/HTML/ListOfAvailableImages.h b/Libraries/LibWeb/HTML/ListOfAvailableImages.h
index 5c718da32b7..775ba2d1928 100644
--- a/Libraries/LibWeb/HTML/ListOfAvailableImages.h
+++ b/Libraries/LibWeb/HTML/ListOfAvailableImages.h
@@ -17,8 +17,8 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/images.html#list-of-available-images
 class ListOfAvailableImages : public JS::Cell {
-    JS_CELL(ListOfAvailableImages, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ListOfAvailableImages);
+    GC_CELL(ListOfAvailableImages, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ListOfAvailableImages);
 
 public:
     struct Key {
@@ -34,20 +34,20 @@ public:
     };
 
     struct Entry {
-        Entry(JS::NonnullGCPtr<DecodedImageData> image_data, bool ignore_higher_layer_caching)
+        Entry(GC::Ref<DecodedImageData> image_data, bool ignore_higher_layer_caching)
             : image_data(move(image_data))
             , ignore_higher_layer_caching(ignore_higher_layer_caching)
         {
         }
 
-        JS::NonnullGCPtr<DecodedImageData> image_data;
+        GC::Ref<DecodedImageData> image_data;
         bool ignore_higher_layer_caching { false };
     };
 
     ListOfAvailableImages();
     ~ListOfAvailableImages();
 
-    void add(Key const&, JS::NonnullGCPtr<DecodedImageData>, bool ignore_higher_layer_caching);
+    void add(Key const&, GC::Ref<DecodedImageData>, bool ignore_higher_layer_caching);
     void remove(Key const&);
     [[nodiscard]] Entry* get(Key const&);
 
diff --git a/Libraries/LibWeb/HTML/Location.cpp b/Libraries/LibWeb/HTML/Location.cpp
index 52816e547c6..8b18be3be3e 100644
--- a/Libraries/LibWeb/HTML/Location.cpp
+++ b/Libraries/LibWeb/HTML/Location.cpp
@@ -7,7 +7,7 @@
 
 #include <AK/String.h>
 #include <AK/StringBuilder.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/PropertyDescriptor.h>
 #include <LibJS/Runtime/PropertyKey.h>
@@ -22,7 +22,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Location);
+GC_DEFINE_ALLOCATOR(Location);
 
 // https://html.spec.whatwg.org/multipage/history.html#the-location-interface
 Location::Location(JS::Realm& realm)
@@ -51,7 +51,7 @@ void Location::initialize(JS::Realm& realm)
 }
 
 // https://html.spec.whatwg.org/multipage/history.html#relevant-document
-JS::GCPtr<DOM::Document> Location::relevant_document() const
+GC::Ptr<DOM::Document> Location::relevant_document() const
 {
     // A Location object has an associated relevant Document, which is this Location object's
     // relevant global object's browsing context's active document, if this Location object's
@@ -579,7 +579,7 @@ JS::ThrowCompletionOr<bool> Location::internal_delete(JS::PropertyKey const& pro
 }
 
 // 7.10.5.10 [[OwnPropertyKeys]] ( ), https://html.spec.whatwg.org/multipage/history.html#location-ownpropertykeys
-JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> Location::internal_own_property_keys() const
+JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> Location::internal_own_property_keys() const
 {
     // 1. If IsPlatformObjectSameOrigin(this) is true, then return OrdinaryOwnPropertyKeys(this).
     if (HTML::is_platform_object_same_origin(*this))
diff --git a/Libraries/LibWeb/HTML/Location.h b/Libraries/LibWeb/HTML/Location.h
index 5c04da03071..6981745a8a4 100644
--- a/Libraries/LibWeb/HTML/Location.h
+++ b/Libraries/LibWeb/HTML/Location.h
@@ -19,7 +19,7 @@ namespace Web::HTML {
 
 class Location final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Location, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Location);
+    GC_DECLARE_ALLOCATOR(Location);
 
 public:
     virtual ~Location() override;
@@ -63,7 +63,7 @@ public:
     virtual JS::ThrowCompletionOr<JS::Value> internal_get(JS::PropertyKey const&, JS::Value receiver, JS::CacheablePropertyMetadata*, PropertyLookupPhase) const override;
     virtual JS::ThrowCompletionOr<bool> internal_set(JS::PropertyKey const&, JS::Value value, JS::Value receiver, JS::CacheablePropertyMetadata*) override;
     virtual JS::ThrowCompletionOr<bool> internal_delete(JS::PropertyKey const&) override;
-    virtual JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> internal_own_property_keys() const override;
+    virtual JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> internal_own_property_keys() const override;
 
     HTML::CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
     HTML::CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
@@ -74,7 +74,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::Document> relevant_document() const;
+    GC::Ptr<DOM::Document> relevant_document() const;
     URL::URL url() const;
     WebIDL::ExceptionOr<void> navigate(URL::URL, Bindings::NavigationHistoryBehavior = Bindings::NavigationHistoryBehavior::Auto);
 
diff --git a/Libraries/LibWeb/HTML/MediaError.cpp b/Libraries/LibWeb/HTML/MediaError.cpp
index 7f509048110..427b1312c8a 100644
--- a/Libraries/LibWeb/HTML/MediaError.cpp
+++ b/Libraries/LibWeb/HTML/MediaError.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(MediaError);
+GC_DEFINE_ALLOCATOR(MediaError);
 
 MediaError::MediaError(JS::Realm& realm, Code code, String message)
     : Base(realm)
diff --git a/Libraries/LibWeb/HTML/MediaError.h b/Libraries/LibWeb/HTML/MediaError.h
index c8f16f17d2c..8acc687b0f0 100644
--- a/Libraries/LibWeb/HTML/MediaError.h
+++ b/Libraries/LibWeb/HTML/MediaError.h
@@ -14,7 +14,7 @@ namespace Web::HTML {
 
 class MediaError final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MediaError, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MediaError);
+    GC_DECLARE_ALLOCATOR(MediaError);
 
 public:
     enum class Code : u16 {
diff --git a/Libraries/LibWeb/HTML/MessageChannel.cpp b/Libraries/LibWeb/HTML/MessageChannel.cpp
index 4697e889d5d..6dbeeae70e0 100644
--- a/Libraries/LibWeb/HTML/MessageChannel.cpp
+++ b/Libraries/LibWeb/HTML/MessageChannel.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(MessageChannel);
+GC_DEFINE_ALLOCATOR(MessageChannel);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MessageChannel>> MessageChannel::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<MessageChannel>> MessageChannel::construct_impl(JS::Realm& realm)
 {
     return realm.create<MessageChannel>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/MessageChannel.h b/Libraries/LibWeb/HTML/MessageChannel.h
index cee461b4492..8270c0f34b2 100644
--- a/Libraries/LibWeb/HTML/MessageChannel.h
+++ b/Libraries/LibWeb/HTML/MessageChannel.h
@@ -14,10 +14,10 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/web-messaging.html#message-channels
 class MessageChannel final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MessageChannel, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MessageChannel);
+    GC_DECLARE_ALLOCATOR(MessageChannel);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<MessageChannel>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<MessageChannel>> construct_impl(JS::Realm&);
     virtual ~MessageChannel() override;
 
     MessagePort* port1();
@@ -32,8 +32,8 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<MessagePort> m_port1;
-    JS::GCPtr<MessagePort> m_port2;
+    GC::Ptr<MessagePort> m_port1;
+    GC::Ptr<MessagePort> m_port2;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/MessageEvent.cpp b/Libraries/LibWeb/HTML/MessageEvent.cpp
index 75e9deaba08..8f9584c6179 100644
--- a/Libraries/LibWeb/HTML/MessageEvent.cpp
+++ b/Libraries/LibWeb/HTML/MessageEvent.cpp
@@ -13,14 +13,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(MessageEvent);
+GC_DEFINE_ALLOCATOR(MessageEvent);
 
-JS::NonnullGCPtr<MessageEvent> MessageEvent::create(JS::Realm& realm, FlyString const& event_name, MessageEventInit const& event_init)
+GC::Ref<MessageEvent> MessageEvent::create(JS::Realm& realm, FlyString const& event_name, MessageEventInit const& event_init)
 {
     return realm.create<MessageEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MessageEvent>> MessageEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MessageEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<MessageEvent>> MessageEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MessageEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
@@ -55,18 +55,18 @@ void MessageEvent::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_ports);
 }
 
-Variant<JS::Handle<WindowProxy>, JS::Handle<MessagePort>, Empty> MessageEvent::source() const
+Variant<GC::Root<WindowProxy>, GC::Root<MessagePort>, Empty> MessageEvent::source() const
 {
     if (!m_source.has_value())
         return Empty {};
 
-    return m_source.value().downcast<JS::Handle<WindowProxy>, JS::Handle<MessagePort>>();
+    return m_source.value().downcast<GC::Root<WindowProxy>, GC::Root<MessagePort>>();
 }
 
-JS::NonnullGCPtr<JS::Object> MessageEvent::ports() const
+GC::Ref<JS::Object> MessageEvent::ports() const
 {
     if (!m_ports_array) {
-        JS::MarkedVector<JS::Value> port_vector(heap());
+        GC::MarkedVector<JS::Value> port_vector(heap());
         for (auto const& port : m_ports)
             port_vector.append(port);
 
@@ -77,7 +77,7 @@ JS::NonnullGCPtr<JS::Object> MessageEvent::ports() const
 }
 
 // https://html.spec.whatwg.org/multipage/comms.html#dom-messageevent-initmessageevent
-void MessageEvent::init_message_event(String const& type, bool bubbles, bool cancelable, JS::Value data, String const& origin, String const& last_event_id, Optional<MessageEventSource> source, Vector<JS::Handle<MessagePort>> const& ports)
+void MessageEvent::init_message_event(String const& type, bool bubbles, bool cancelable, JS::Value data, String const& origin, String const& last_event_id, Optional<MessageEventSource> source, Vector<GC::Root<MessagePort>> const& ports)
 {
     // The initMessageEvent(type, bubbles, cancelable, data, origin, lastEventId, source, ports) method must initialize the event in a
     // manner analogous to the similarly-named initEvent() method.
diff --git a/Libraries/LibWeb/HTML/MessageEvent.h b/Libraries/LibWeb/HTML/MessageEvent.h
index 67e5ad2d5c3..29cf7eb6acc 100644
--- a/Libraries/LibWeb/HTML/MessageEvent.h
+++ b/Libraries/LibWeb/HTML/MessageEvent.h
@@ -13,23 +13,23 @@
 namespace Web::HTML {
 
 // FIXME: Include ServiceWorker
-using MessageEventSource = Variant<JS::Handle<WindowProxy>, JS::Handle<MessagePort>>;
+using MessageEventSource = Variant<GC::Root<WindowProxy>, GC::Root<MessagePort>>;
 
 struct MessageEventInit : public DOM::EventInit {
     JS::Value data { JS::js_null() };
     String origin {};
     String last_event_id {};
     Optional<MessageEventSource> source;
-    Vector<JS::Handle<MessagePort>> ports;
+    Vector<GC::Root<MessagePort>> ports;
 };
 
 class MessageEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(MessageEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(MessageEvent);
+    GC_DECLARE_ALLOCATOR(MessageEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MessageEvent> create(JS::Realm&, FlyString const& event_name, MessageEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<MessageEvent>> construct_impl(JS::Realm&, FlyString const& event_name, MessageEventInit const&);
+    [[nodiscard]] static GC::Ref<MessageEvent> create(JS::Realm&, FlyString const& event_name, MessageEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<MessageEvent>> construct_impl(JS::Realm&, FlyString const& event_name, MessageEventInit const&);
 
     MessageEvent(JS::Realm&, FlyString const& event_name, MessageEventInit const& event_init);
     virtual ~MessageEvent() override;
@@ -37,10 +37,10 @@ public:
     JS::Value data() const { return m_data; }
     String const& origin() const { return m_origin; }
     String const& last_event_id() const { return m_last_event_id; }
-    JS::NonnullGCPtr<JS::Object> ports() const;
-    Variant<JS::Handle<WindowProxy>, JS::Handle<MessagePort>, Empty> source() const;
+    GC::Ref<JS::Object> ports() const;
+    Variant<GC::Root<WindowProxy>, GC::Root<MessagePort>, Empty> source() const;
 
-    void init_message_event(String const& type, bool bubbles, bool cancelable, JS::Value data, String const& origin, String const& last_event_id, Optional<MessageEventSource> source, Vector<JS::Handle<MessagePort>> const& ports);
+    void init_message_event(String const& type, bool bubbles, bool cancelable, JS::Value data, String const& origin, String const& last_event_id, Optional<MessageEventSource> source, Vector<GC::Root<MessagePort>> const& ports);
 
 private:
     virtual void initialize(JS::Realm&) override;
@@ -50,8 +50,8 @@ private:
     String m_origin;
     String m_last_event_id;
     Optional<MessageEventSource> m_source;
-    Vector<JS::NonnullGCPtr<JS::Object>> m_ports;
-    mutable JS::GCPtr<JS::Array> m_ports_array;
+    Vector<GC::Ref<JS::Object>> m_ports;
+    mutable GC::Ptr<JS::Array> m_ports_array;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/MessagePort.cpp b/Libraries/LibWeb/HTML/MessagePort.cpp
index 7771e1d99f2..195627c2354 100644
--- a/Libraries/LibWeb/HTML/MessagePort.cpp
+++ b/Libraries/LibWeb/HTML/MessagePort.cpp
@@ -28,15 +28,15 @@ namespace Web::HTML {
 
 constexpr u8 IPC_FILE_TAG = 0xA5;
 
-JS_DEFINE_ALLOCATOR(MessagePort);
+GC_DEFINE_ALLOCATOR(MessagePort);
 
-static HashTable<JS::RawGCPtr<MessagePort>>& all_message_ports()
+static HashTable<GC::RawPtr<MessagePort>>& all_message_ports()
 {
-    static HashTable<JS::RawGCPtr<MessagePort>> ports;
+    static HashTable<GC::RawPtr<MessagePort>> ports;
     return ports;
 }
 
-JS::NonnullGCPtr<MessagePort> MessagePort::create(JS::Realm& realm)
+GC::Ref<MessagePort> MessagePort::create(JS::Realm& realm)
 {
     return realm.create<MessagePort>(realm);
 }
@@ -77,7 +77,7 @@ bool MessagePort::is_entangled() const
     return m_transport.has_value();
 }
 
-void MessagePort::set_worker_event_target(JS::NonnullGCPtr<DOM::EventTarget> target)
+void MessagePort::set_worker_event_target(GC::Ref<DOM::EventTarget> target)
 {
     m_worker_event_target = target;
 }
@@ -132,7 +132,7 @@ WebIDL::ExceptionOr<void> MessagePort::transfer_receiving_steps(HTML::TransferDa
             auto fd = data_holder.fds.take_first();
             m_transport = IPC::Transport(MUST(Core::LocalSocket::adopt_fd(fd.take_fd())));
 
-            m_transport->set_up_read_hook([strong_this = JS::make_handle(this)]() {
+            m_transport->set_up_read_hook([strong_this = GC::make_root(this)]() {
                 strong_this->read_from_transport();
             });
         } else {
@@ -192,20 +192,20 @@ void MessagePort::entangle_with(MessagePort& remote_port)
     m_transport = IPC::Transport(move(sockets[0]));
     m_remote_port->m_transport = IPC::Transport(move(sockets[1]));
 
-    m_transport->set_up_read_hook([strong_this = JS::make_handle(this)]() {
+    m_transport->set_up_read_hook([strong_this = GC::make_root(this)]() {
         strong_this->read_from_transport();
     });
 
-    m_remote_port->m_transport->set_up_read_hook([remote_port = JS::make_handle(m_remote_port)]() {
+    m_remote_port->m_transport->set_up_read_hook([remote_port = GC::make_root(m_remote_port)]() {
         remote_port->read_from_transport();
     });
 }
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#dom-messageport-postmessage-options
-WebIDL::ExceptionOr<void> MessagePort::post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer)
+WebIDL::ExceptionOr<void> MessagePort::post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer)
 {
     // 1. Let targetPort be the port with which this MessagePort is entangled, if any; otherwise let it be null.
-    JS::GCPtr<MessagePort> target_port = m_remote_port;
+    GC::Ptr<MessagePort> target_port = m_remote_port;
 
     // 2. Let options be «[ "transfer" → transfer ]».
     auto options = StructuredSerializeOptions { transfer };
@@ -218,14 +218,14 @@ WebIDL::ExceptionOr<void> MessagePort::post_message(JS::Value message, Vector<JS
 WebIDL::ExceptionOr<void> MessagePort::post_message(JS::Value message, StructuredSerializeOptions const& options)
 {
     // 1. Let targetPort be the port with which this MessagePort is entangled, if any; otherwise let it be null.
-    JS::GCPtr<MessagePort> target_port = m_remote_port;
+    GC::Ptr<MessagePort> target_port = m_remote_port;
 
     // 2. Run the message port post message steps providing targetPort, message and options.
     return message_port_post_message_steps(target_port, message, options);
 }
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#message-port-post-message-steps
-WebIDL::ExceptionOr<void> MessagePort::message_port_post_message_steps(JS::GCPtr<MessagePort> target_port, JS::Value message, StructuredSerializeOptions const& options)
+WebIDL::ExceptionOr<void> MessagePort::message_port_post_message_steps(GC::Ptr<MessagePort> target_port, JS::Value message, StructuredSerializeOptions const& options)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -323,7 +323,7 @@ ErrorOr<MessagePort::ParseDecision> MessagePort::parse_message()
 
         // Note: this is step 7 of message_port_post_message_steps:
         // 7. Add a task that runs the following steps to the port message queue of targetPort:
-        queue_global_task(Task::Source::PostedMessage, relevant_global_object(*this), JS::create_heap_function(heap(), [this, serialized_transfer_record = move(serialized_transfer_record)]() mutable {
+        queue_global_task(Task::Source::PostedMessage, relevant_global_object(*this), GC::create_function(heap(), [this, serialized_transfer_record = move(serialized_transfer_record)]() mutable {
             this->post_message_task_steps(serialized_transfer_record);
         }));
 
@@ -339,7 +339,7 @@ ErrorOr<MessagePort::ParseDecision> MessagePort::parse_message()
 void MessagePort::read_from_transport()
 {
     auto&& [bytes, fds] = m_transport->read_as_much_as_possible_without_blocking([this] {
-        queue_global_task(Task::Source::PostedMessage, relevant_global_object(*this), JS::create_heap_function(heap(), [this] {
+        queue_global_task(Task::Source::PostedMessage, relevant_global_object(*this), GC::create_function(heap(), [this] {
             this->close();
         }));
     });
@@ -397,7 +397,7 @@ void MessagePort::post_message_task_steps(SerializedTransferRecord& serialize_wi
 
     // 5. Let newPorts be a new frozen array consisting of all MessagePort objects in deserializeRecord.[[TransferredValues]], if any, maintaining their relative order.
     // FIXME: Use a FrozenArray
-    Vector<JS::Handle<MessagePort>> new_ports;
+    Vector<GC::Root<MessagePort>> new_ports;
     for (auto const& object : deserialize_record.transferred_values) {
         if (is<HTML::MessagePort>(*object)) {
             new_ports.append(verify_cast<MessagePort>(*object));
diff --git a/Libraries/LibWeb/HTML/MessagePort.h b/Libraries/LibWeb/HTML/MessagePort.h
index a170219e717..6a718468b6c 100644
--- a/Libraries/LibWeb/HTML/MessagePort.h
+++ b/Libraries/LibWeb/HTML/MessagePort.h
@@ -26,10 +26,10 @@ namespace Web::HTML {
 class MessagePort final : public DOM::EventTarget
     , public Bindings::Transferable {
     WEB_PLATFORM_OBJECT(MessagePort, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(MessagePort);
+    GC_DECLARE_ALLOCATOR(MessagePort);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MessagePort> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<MessagePort> create(JS::Realm&);
 
     static void for_each_message_port(Function<void(MessagePort&)>);
 
@@ -41,7 +41,7 @@ public:
     void disentangle();
 
     // https://html.spec.whatwg.org/multipage/web-messaging.html#dom-messageport-postmessage
-    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer);
+    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer);
 
     // https://html.spec.whatwg.org/multipage/web-messaging.html#dom-messageport-postmessage-options
     WebIDL::ExceptionOr<void> post_message(JS::Value message, StructuredSerializeOptions const& options);
@@ -62,7 +62,7 @@ public:
     virtual WebIDL::ExceptionOr<void> transfer_receiving_steps(HTML::TransferDataHolder&) override;
     virtual HTML::TransferType primary_interface() const override { return HTML::TransferType::MessagePort; }
 
-    void set_worker_event_target(JS::NonnullGCPtr<DOM::EventTarget>);
+    void set_worker_event_target(GC::Ref<DOM::EventTarget>);
 
 private:
     explicit MessagePort(JS::Realm&);
@@ -72,7 +72,7 @@ private:
 
     bool is_entangled() const;
 
-    WebIDL::ExceptionOr<void> message_port_post_message_steps(JS::GCPtr<MessagePort> target_port, JS::Value message, StructuredSerializeOptions const& options);
+    WebIDL::ExceptionOr<void> message_port_post_message_steps(GC::Ptr<MessagePort> target_port, JS::Value message, StructuredSerializeOptions const& options);
     void post_message_task_steps(SerializedTransferRecord&);
     void post_port_message(SerializedTransferRecord);
     ErrorOr<void> send_message_on_transport(SerializedTransferRecord const&);
@@ -85,7 +85,7 @@ private:
     ErrorOr<ParseDecision> parse_message();
 
     // The HTML spec implies(!) that this is MessagePort.[[RemotePort]]
-    JS::GCPtr<MessagePort> m_remote_port;
+    GC::Ptr<MessagePort> m_remote_port;
 
     // https://html.spec.whatwg.org/multipage/web-messaging.html#has-been-shipped
     bool m_has_been_shipped { false };
@@ -101,7 +101,7 @@ private:
     Queue<IPC::File> m_unprocessed_fds;
     Vector<u8> m_buffered_data;
 
-    JS::GCPtr<DOM::EventTarget> m_worker_event_target;
+    GC::Ptr<DOM::EventTarget> m_worker_event_target;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/MimeType.cpp b/Libraries/LibWeb/HTML/MimeType.cpp
index 38ce1666c82..3cb28e21134 100644
--- a/Libraries/LibWeb/HTML/MimeType.cpp
+++ b/Libraries/LibWeb/HTML/MimeType.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(MimeType);
+GC_DEFINE_ALLOCATOR(MimeType);
 
 MimeType::MimeType(JS::Realm& realm, String type)
     : Bindings::PlatformObject(realm)
@@ -52,7 +52,7 @@ String const& MimeType::suffixes() const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-mimetype-enabledplugin
-JS::NonnullGCPtr<Plugin> MimeType::enabled_plugin() const
+GC::Ref<Plugin> MimeType::enabled_plugin() const
 {
     // The MimeType interface's enabledPlugin getter steps are to return this's relevant global object's PDF viewer plugin objects[0] (i.e., the generic "PDF Viewer" one).
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
diff --git a/Libraries/LibWeb/HTML/MimeType.h b/Libraries/LibWeb/HTML/MimeType.h
index 090b9c3ba42..8dbac65ec4d 100644
--- a/Libraries/LibWeb/HTML/MimeType.h
+++ b/Libraries/LibWeb/HTML/MimeType.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/system-state.html#mimetype
 class MimeType : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MimeType, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MimeType);
+    GC_DECLARE_ALLOCATOR(MimeType);
 
 public:
     virtual ~MimeType() override;
@@ -21,7 +21,7 @@ public:
     String const& type() const;
     String description() const;
     String const& suffixes() const;
-    JS::NonnullGCPtr<Plugin> enabled_plugin() const;
+    GC::Ref<Plugin> enabled_plugin() const;
 
 private:
     MimeType(JS::Realm&, String type);
diff --git a/Libraries/LibWeb/HTML/MimeTypeArray.cpp b/Libraries/LibWeb/HTML/MimeTypeArray.cpp
index fc06bfee83b..961a16096b0 100644
--- a/Libraries/LibWeb/HTML/MimeTypeArray.cpp
+++ b/Libraries/LibWeb/HTML/MimeTypeArray.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(MimeTypeArray);
+GC_DEFINE_ALLOCATOR(MimeTypeArray);
 
 MimeTypeArray::MimeTypeArray(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -59,7 +59,7 @@ size_t MimeTypeArray::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-mimetypearray-item
-JS::GCPtr<MimeType> MimeTypeArray::item(u32 index) const
+GC::Ptr<MimeType> MimeTypeArray::item(u32 index) const
 {
     // 1. Let mimeTypes be this's relevant global object's PDF viewer mime type objects.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
@@ -74,7 +74,7 @@ JS::GCPtr<MimeType> MimeTypeArray::item(u32 index) const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-mimetypearray-nameditem
-JS::GCPtr<MimeType> MimeTypeArray::named_item(FlyString const& name) const
+GC::Ptr<MimeType> MimeTypeArray::named_item(FlyString const& name) const
 {
     // 1. For each MimeType mimeType of this's relevant global object's PDF viewer mime type objects: if mimeType's type is name, then return mimeType.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
diff --git a/Libraries/LibWeb/HTML/MimeTypeArray.h b/Libraries/LibWeb/HTML/MimeTypeArray.h
index 83213ca2bc4..3eeb30df34d 100644
--- a/Libraries/LibWeb/HTML/MimeTypeArray.h
+++ b/Libraries/LibWeb/HTML/MimeTypeArray.h
@@ -13,14 +13,14 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/system-state.html#mimetypearray
 class MimeTypeArray : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MimeTypeArray, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MimeTypeArray);
+    GC_DECLARE_ALLOCATOR(MimeTypeArray);
 
 public:
     virtual ~MimeTypeArray() override;
 
     size_t length() const;
-    JS::GCPtr<MimeType> item(u32 index) const;
-    JS::GCPtr<MimeType> named_item(FlyString const& name) const;
+    GC::Ptr<MimeType> item(u32 index) const;
+    GC::Ptr<MimeType> named_item(FlyString const& name) const;
 
 private:
     MimeTypeArray(JS::Realm&);
diff --git a/Libraries/LibWeb/HTML/Navigable.cpp b/Libraries/LibWeb/HTML/Navigable.cpp
index ea0afcb49b2..3a42cd7dda4 100644
--- a/Libraries/LibWeb/HTML/Navigable.cpp
+++ b/Libraries/LibWeb/HTML/Navigable.cpp
@@ -46,20 +46,20 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Navigable);
+GC_DEFINE_ALLOCATOR(Navigable);
 
 class ResponseHolder : public JS::Cell {
-    JS_CELL(ResponseHolder, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ResponseHolder);
+    GC_CELL(ResponseHolder, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ResponseHolder);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ResponseHolder> create(JS::VM& vm)
+    [[nodiscard]] static GC::Ref<ResponseHolder> create(JS::VM& vm)
     {
         return vm.heap().allocate<ResponseHolder>();
     }
 
-    [[nodiscard]] JS::GCPtr<Fetch::Infrastructure::Response> response() const { return m_response; }
-    void set_response(JS::GCPtr<Fetch::Infrastructure::Response> response) { m_response = response; }
+    [[nodiscard]] GC::Ptr<Fetch::Infrastructure::Response> response() const { return m_response; }
+    void set_response(GC::Ptr<Fetch::Infrastructure::Response> response) { m_response = response; }
 
     virtual void visit_edges(Cell::Visitor& visitor) override
     {
@@ -68,10 +68,10 @@ public:
     }
 
 private:
-    JS::GCPtr<Fetch::Infrastructure::Response> m_response;
+    GC::Ptr<Fetch::Infrastructure::Response> m_response;
 };
 
-JS_DEFINE_ALLOCATOR(ResponseHolder);
+GC_DEFINE_ALLOCATOR(ResponseHolder);
 
 HashTable<Navigable*>& all_navigables()
 {
@@ -80,9 +80,9 @@ HashTable<Navigable*>& all_navigables()
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#child-navigable
-Vector<JS::Handle<Navigable>> Navigable::child_navigables() const
+Vector<GC::Root<Navigable>> Navigable::child_navigables() const
 {
-    Vector<JS::Handle<Navigable>> results;
+    Vector<GC::Root<Navigable>> results;
     for (auto& entry : all_navigables()) {
         if (entry->current_session_history_entry()->step() == SessionHistoryEntry::Pending::Tag)
             continue;
@@ -98,7 +98,7 @@ bool Navigable::is_traversable() const
     return is<TraversableNavigable>(*this);
 }
 
-bool Navigable::is_ancestor_of(JS::NonnullGCPtr<Navigable> other) const
+bool Navigable::is_ancestor_of(GC::Ref<Navigable> other) const
 {
     for (auto ancestor = other->parent(); ancestor; ancestor = ancestor->parent()) {
         if (ancestor == this)
@@ -107,7 +107,7 @@ bool Navigable::is_ancestor_of(JS::NonnullGCPtr<Navigable> other) const
     return false;
 }
 
-Navigable::Navigable(JS::NonnullGCPtr<Page> page)
+Navigable::Navigable(GC::Ref<Page> page)
     : m_page(page)
     , m_event_handler({}, *this)
 {
@@ -157,7 +157,7 @@ void Navigable::set_delaying_load_events(bool value)
     }
 }
 
-JS::GCPtr<Navigable> Navigable::navigable_with_active_document(JS::NonnullGCPtr<DOM::Document> document)
+GC::Ptr<Navigable> Navigable::navigable_with_active_document(GC::Ref<DOM::Document> document)
 {
     for (auto* navigable : all_navigables()) {
         if (navigable->active_document() == document)
@@ -167,7 +167,7 @@ JS::GCPtr<Navigable> Navigable::navigable_with_active_document(JS::NonnullGCPtr<
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#initialize-the-navigable
-ErrorOr<void> Navigable::initialize_navigable(JS::NonnullGCPtr<DocumentState> document_state, JS::GCPtr<Navigable> parent)
+ErrorOr<void> Navigable::initialize_navigable(GC::Ref<DocumentState> document_state, GC::Ptr<Navigable> parent)
 {
     static int next_id = 0;
     m_id = String::number(next_id++);
@@ -176,7 +176,7 @@ ErrorOr<void> Navigable::initialize_navigable(JS::NonnullGCPtr<DocumentState> do
     VERIFY(document_state->document());
 
     // 2. Let entry be a new session history entry, with
-    JS::NonnullGCPtr<SessionHistoryEntry> entry = *heap().allocate<SessionHistoryEntry>();
+    GC::Ref<SessionHistoryEntry> entry = *heap().allocate<SessionHistoryEntry>();
     // URL: document's URL
     entry->set_url(document_state->document()->url());
     // document state: documentState
@@ -195,13 +195,13 @@ ErrorOr<void> Navigable::initialize_navigable(JS::NonnullGCPtr<DocumentState> do
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-the-target-history-entry
-JS::GCPtr<SessionHistoryEntry> Navigable::get_the_target_history_entry(int target_step) const
+GC::Ptr<SessionHistoryEntry> Navigable::get_the_target_history_entry(int target_step) const
 {
     // 1. Let entries be the result of getting session history entries for navigable.
     auto& entries = get_session_history_entries();
 
     // 2. Return the item in entries that has the greatest step less than or equal to step.
-    JS::GCPtr<SessionHistoryEntry> result = nullptr;
+    GC::Ptr<SessionHistoryEntry> result = nullptr;
     for (auto& entry : entries) {
         auto entry_step = entry->step().get<int>();
         if (entry_step <= target_step) {
@@ -215,12 +215,12 @@ JS::GCPtr<SessionHistoryEntry> Navigable::get_the_target_history_entry(int targe
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#activate-history-entry
-void Navigable::activate_history_entry(JS::GCPtr<SessionHistoryEntry> entry)
+void Navigable::activate_history_entry(GC::Ptr<SessionHistoryEntry> entry)
 {
     // FIXME: 1. Save persisted state to the navigable's active session history entry.
 
     // 2. Let newDocument be entry's document.
-    JS::GCPtr<DOM::Document> new_document = entry->document().ptr();
+    GC::Ptr<DOM::Document> new_document = entry->document().ptr();
 
     // 3. Assert: newDocument's is initial about:blank is false, i.e., we never traverse
     //    back to the initial about:blank Document because it always gets replaced when we
@@ -242,14 +242,14 @@ void Navigable::activate_history_entry(JS::GCPtr<SessionHistoryEntry> entry)
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-document
-JS::GCPtr<DOM::Document> Navigable::active_document()
+GC::Ptr<DOM::Document> Navigable::active_document()
 {
     // A navigable's active document is its active session history entry's document.
     return m_active_session_history_entry->document();
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-bc
-JS::GCPtr<BrowsingContext> Navigable::active_browsing_context()
+GC::Ptr<BrowsingContext> Navigable::active_browsing_context()
 {
     // A navigable's active browsing context is its active document's browsing context.
     // If this navigable is a traversable navigable, then its active browsing context will be a top-level browsing context.
@@ -259,7 +259,7 @@ JS::GCPtr<BrowsingContext> Navigable::active_browsing_context()
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-wp
-JS::GCPtr<HTML::WindowProxy> Navigable::active_window_proxy()
+GC::Ptr<HTML::WindowProxy> Navigable::active_window_proxy()
 {
     // A navigable's active WindowProxy is its active browsing context's associated WindowProxy.
     if (auto browsing_context = active_browsing_context())
@@ -268,7 +268,7 @@ JS::GCPtr<HTML::WindowProxy> Navigable::active_window_proxy()
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-window
-JS::GCPtr<HTML::Window> Navigable::active_window()
+GC::Ptr<HTML::Window> Navigable::active_window()
 {
     // A navigable's active window is its active WindowProxy's [[Window]].
     if (auto window_proxy = active_window_proxy())
@@ -284,14 +284,14 @@ String Navigable::target_name() const
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-container
-JS::GCPtr<NavigableContainer> Navigable::container() const
+GC::Ptr<NavigableContainer> Navigable::container() const
 {
     // The container of a navigable navigable is the navigable container whose nested navigable is navigable, or null if there is no such element.
     return NavigableContainer::navigable_container_with_content_navigable(const_cast<Navigable&>(*this));
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-container-document
-JS::GCPtr<DOM::Document> Navigable::container_document() const
+GC::Ptr<DOM::Document> Navigable::container_document() const
 {
     auto container = this->container();
 
@@ -304,7 +304,7 @@ JS::GCPtr<DOM::Document> Navigable::container_document() const
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-traversable
-JS::GCPtr<TraversableNavigable> Navigable::traversable_navigable() const
+GC::Ptr<TraversableNavigable> Navigable::traversable_navigable() const
 {
     // 1. Let navigable be inputNavigable.
     auto navigable = const_cast<Navigable*>(this);
@@ -318,7 +318,7 @@ JS::GCPtr<TraversableNavigable> Navigable::traversable_navigable() const
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-top
-JS::GCPtr<TraversableNavigable> Navigable::top_level_traversable()
+GC::Ptr<TraversableNavigable> Navigable::top_level_traversable()
 {
     // 1. Let navigable be inputNavigable.
     auto navigable = this;
@@ -349,7 +349,7 @@ void Navigable::set_ongoing_navigation(Variant<Empty, Traversal, String> ongoing
 Navigable::ChosenNavigable Navigable::choose_a_navigable(StringView name, TokenizedFeature::NoOpener no_opener, ActivateTab activate_tab, Optional<TokenizedFeature::Map const&> window_features)
 {
     // NOTE: Implementation for step 7 here.
-    JS::GCPtr<Navigable> same_name_navigable = nullptr;
+    GC::Ptr<Navigable> same_name_navigable = nullptr;
     if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv)) {
         for (auto& n : all_navigables()) {
             if (n->target_name() == name && !n->has_been_destroyed()) {
@@ -359,7 +359,7 @@ Navigable::ChosenNavigable Navigable::choose_a_navigable(StringView name, Tokeni
     }
 
     // 1. Let chosen be null.
-    JS::GCPtr<Navigable> chosen = nullptr;
+    GC::Ptr<Navigable> chosen = nullptr;
 
     // 2. Let windowType be "existing or none".
     auto window_type = WindowType::ExistingOrNone;
@@ -453,7 +453,7 @@ Navigable::ChosenNavigable Navigable::choose_a_navigable(StringView name, Tokeni
             if (!Infra::is_ascii_case_insensitive_match(name, "_blank"sv))
                 target_name = MUST(String::from_utf8(name));
 
-            auto create_new_traversable_closure = [this, no_opener, target_name, activate_tab, window_features](JS::GCPtr<BrowsingContext> opener) -> JS::NonnullGCPtr<Navigable> {
+            auto create_new_traversable_closure = [this, no_opener, target_name, activate_tab, window_features](GC::Ptr<BrowsingContext> opener) -> GC::Ref<Navigable> {
                 auto hints = WebViewHints::from_tokenised_features(window_features.value_or({}), traversable_navigable()->page());
                 auto [page, window_handle] = traversable_navigable()->page().client().page_did_request_new_web_view(activate_tab, hints, no_opener);
                 auto traversable = TraversableNavigable::create_a_new_top_level_traversable(*page, opener, target_name).release_value_but_fixme_should_propagate_errors();
@@ -461,7 +461,7 @@ Navigable::ChosenNavigable Navigable::choose_a_navigable(StringView name, Tokeni
                 traversable->set_window_handle(window_handle);
                 return traversable;
             };
-            auto create_new_traversable = JS::create_heap_function(heap(), move(create_new_traversable_closure));
+            auto create_new_traversable = GC::create_function(heap(), move(create_new_traversable_closure));
 
             // 7. If noopener is true, then set chosen to the result of creating a new top-level traversable given null and targetName.
             if (no_opener == TokenizedFeature::NoOpener::Yes) {
@@ -498,7 +498,7 @@ Navigable::ChosenNavigable Navigable::choose_a_navigable(StringView name, Tokeni
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-session-history-entries
-Vector<JS::NonnullGCPtr<SessionHistoryEntry>>& Navigable::get_session_history_entries() const
+Vector<GC::Ref<SessionHistoryEntry>>& Navigable::get_session_history_entries() const
 {
     // 1. Let traversable be navigable's traversable navigable.
     auto traversable = traversable_navigable();
@@ -510,7 +510,7 @@ Vector<JS::NonnullGCPtr<SessionHistoryEntry>>& Navigable::get_session_history_en
         return traversable->session_history_entries();
 
     // 4. Let docStates be an empty ordered set of document states.
-    Vector<JS::GCPtr<DocumentState>> doc_states;
+    Vector<GC::Ptr<DocumentState>> doc_states;
 
     // 5. For each entry of traversable's session history entries, append entry's document state to docStates.
     for (auto& entry : traversable->session_history_entries())
@@ -575,7 +575,7 @@ static PolicyContainer determine_navigation_params_policy_container(URL::URL con
 }
 
 // https://html.spec.whatwg.org/multipage/browsers.html#obtain-coop
-static OpenerPolicy obtain_an_opener_policy(JS::NonnullGCPtr<Fetch::Infrastructure::Response>, Fetch::Infrastructure::Request::ReservedClientType const& reserved_client)
+static OpenerPolicy obtain_an_opener_policy(GC::Ref<Fetch::Infrastructure::Response>, Fetch::Infrastructure::Request::ReservedClientType const& reserved_client)
 {
 
     // 1. Let policy be a new opener policy.
@@ -604,7 +604,7 @@ static OpenerPolicy obtain_an_opener_policy(JS::NonnullGCPtr<Fetch::Infrastructu
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#attempt-to-create-a-non-fetch-scheme-document
-static JS::GCPtr<DOM::Document> attempt_to_create_a_non_fetch_scheme_document(NonFetchSchemeNavigationParams const& params)
+static GC::Ptr<DOM::Document> attempt_to_create_a_non_fetch_scheme_document(NonFetchSchemeNavigationParams const& params)
 {
     // FIXME: Implement this algorithm to hand off to external software or display inline content
     dbgln("(FIXME) Don't know how to navigate to {}", params.url);
@@ -612,7 +612,7 @@ static JS::GCPtr<DOM::Document> attempt_to_create_a_non_fetch_scheme_document(No
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#create-navigation-params-from-a-srcdoc-resource
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<NavigationParams>> create_navigation_params_from_a_srcdoc_resource(JS::GCPtr<SessionHistoryEntry> entry, JS::GCPtr<Navigable> navigable, TargetSnapshotParams const& target_snapshot_params, Optional<String> navigation_id)
+static WebIDL::ExceptionOr<GC::Ref<NavigationParams>> create_navigation_params_from_a_srcdoc_resource(GC::Ptr<SessionHistoryEntry> entry, GC::Ptr<Navigable> navigable, TargetSnapshotParams const& target_snapshot_params, Optional<String> navigation_id)
 {
     auto& vm = navigable->vm();
     VERIFY(navigable->active_window());
@@ -693,7 +693,7 @@ static WebIDL::ExceptionOr<JS::NonnullGCPtr<NavigationParams>> create_navigation
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#create-navigation-params-by-fetching
-static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation_params_by_fetching(JS::GCPtr<SessionHistoryEntry> entry, JS::GCPtr<Navigable> navigable, SourceSnapshotParams const& source_snapshot_params, TargetSnapshotParams const& target_snapshot_params, CSPNavigationType csp_navigation_type, Optional<String> navigation_id)
+static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation_params_by_fetching(GC::Ptr<SessionHistoryEntry> entry, GC::Ptr<Navigable> navigable, SourceSnapshotParams const& source_snapshot_params, TargetSnapshotParams const& target_snapshot_params, CSPNavigationType csp_navigation_type, Optional<String> navigation_id)
 {
     auto& vm = navigable->vm();
     VERIFY(navigable->active_window());
@@ -809,7 +809,7 @@ static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation
     Optional<URL::Origin> response_origin;
 
     // 11. Let fetchController be null.
-    JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller = nullptr;
+    GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller = nullptr;
 
     // 12. Let coopEnforcementResult be a new opener policy enforcement result, with
     // - url: navigable's active document's URL
@@ -858,7 +858,7 @@ static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation
             // FIXME: Let processEarlyHintsResponse be the following algorithm given a response earlyResponse:
 
             // Let processResponse be the following algorithm given a response fetchedResponse:
-            auto process_response = [response_holder](JS::NonnullGCPtr<Fetch::Infrastructure::Response> fetch_response) {
+            auto process_response = [response_holder](GC::Ref<Fetch::Infrastructure::Response> fetch_response) {
                 // 1. Set response to fetchedResponse.
                 response_holder->set_response(fetch_response);
             };
@@ -883,7 +883,7 @@ static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation
         }
 
         // 7. Wait until either response is non-null, or navigable's ongoing navigation changes to no longer equal navigationId.
-        HTML::main_thread_event_loop().spin_until(JS::create_heap_function(vm.heap(), [&]() {
+        HTML::main_thread_event_loop().spin_until(GC::create_function(vm.heap(), [&]() {
             if (response_holder->response() != nullptr)
                 return true;
 
@@ -1063,14 +1063,14 @@ static WebIDL::ExceptionOr<Navigable::NavigationParamsVariant> create_navigation
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#attempt-to-populate-the-history-entry's-document
 WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
-    JS::GCPtr<SessionHistoryEntry> entry,
+    GC::Ptr<SessionHistoryEntry> entry,
     SourceSnapshotParams const& source_snapshot_params,
     TargetSnapshotParams const& target_snapshot_params,
     Optional<String> navigation_id,
     Navigable::NavigationParamsVariant navigation_params,
     CSPNavigationType csp_navigation_type,
     bool allow_POST,
-    JS::GCPtr<JS::HeapFunction<void()>> completion_steps)
+    GC::Ptr<GC::Function<void()>> completion_steps)
 {
     // AD-HOC: Not in the spec but subsequent steps will fail if the navigable doesn't have an active window.
     if (!active_window())
@@ -1080,7 +1080,7 @@ WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
 
     // 2. Assert: if navigationParams is non-null, then navigationParams's response is non-null.
     if (!navigation_params.has<Empty>() && !navigation_params.has<NullWithError>())
-        VERIFY(navigation_params.has<JS::NonnullGCPtr<NavigationParams>>() && navigation_params.get<JS::NonnullGCPtr<NavigationParams>>()->response);
+        VERIFY(navigation_params.has<GC::Ref<NavigationParams>>() && navigation_params.get<GC::Ref<NavigationParams>>()->response);
 
     // 3. Let currentBrowsingContext be navigable's active browsing context.
     [[maybe_unused]] auto current_browsing_context = active_browsing_context();
@@ -1128,7 +1128,7 @@ WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
         return {};
 
     // 6. Queue a global task on the navigation and traversal task source, given navigable's active window, to run these steps:
-    queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), JS::create_heap_function(heap(), [this, entry, navigation_params = move(navigation_params), navigation_id, completion_steps]() mutable {
+    queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), GC::create_function(heap(), [this, entry, navigation_params = move(navigation_params), navigation_id, completion_steps]() mutable {
         // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
         if (has_been_destroyed())
             return;
@@ -1144,9 +1144,9 @@ WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
         auto saveExtraDocumentState = true;
 
         // 3. If navigationParams is a non-fetch scheme navigation params, then:
-        if (navigation_params.has<JS::NonnullGCPtr<NonFetchSchemeNavigationParams>>()) {
+        if (navigation_params.has<GC::Ref<NonFetchSchemeNavigationParams>>()) {
             // 1. Set entry's document state's document to the result of running attempt to create a non-fetch scheme document given navigationParams.
-            entry->document_state()->set_document(attempt_to_create_a_non_fetch_scheme_document(navigation_params.get<JS::NonnullGCPtr<NonFetchSchemeNavigationParams>>()));
+            entry->document_state()->set_document(attempt_to_create_a_non_fetch_scheme_document(navigation_params.get<GC::Ref<NonFetchSchemeNavigationParams>>()));
             if (entry->document()) {
                 entry->document_state()->set_ever_populated(true);
             }
@@ -1187,8 +1187,8 @@ WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
         //            header specifying the attachment disposition type, then:
         // 6. Otherwise, if navigationParams's response's status is not 204 and is not 205, then set entry's document state's document to the result of
         //    loading a document given navigationParams, sourceSnapshotParams, and entry's document state's initiator origin.
-        else if (auto const& response = navigation_params.get<JS::NonnullGCPtr<NavigationParams>>()->response; response->status() != 204 && response->status() != 205) {
-            auto document = load_document(navigation_params.get<JS::NonnullGCPtr<NavigationParams>>());
+        else if (auto const& response = navigation_params.get<GC::Ref<NavigationParams>>()->response; response->status() != 204 && response->status() != 205) {
+            auto document = load_document(navigation_params.get<GC::Ref<NavigationParams>>());
             entry->document_state()->set_document(document);
         }
 
@@ -1210,12 +1210,12 @@ WebIDL::ExceptionOr<void> Navigable::populate_session_history_entry_document(
 
             // 3. If entry's document state's request referrer is "client", and navigationParams is a navigation params (i.e., neither null nor a non-fetch scheme navigation params), then:
             if (entry->document_state()->request_referrer() == Fetch::Infrastructure::Request::Referrer::Client
-                && (!navigation_params.has<Empty>() && !navigation_params.has<NullWithError>() && navigation_params.has<JS::NonnullGCPtr<NonFetchSchemeNavigationParams>>())) {
+                && (!navigation_params.has<Empty>() && !navigation_params.has<NullWithError>() && navigation_params.has<GC::Ref<NonFetchSchemeNavigationParams>>())) {
                 // 1. Assert: navigationParams's request is not null.
-                VERIFY(navigation_params.has<JS::NonnullGCPtr<NavigationParams>>() && navigation_params.get<JS::NonnullGCPtr<NavigationParams>>()->request);
+                VERIFY(navigation_params.has<GC::Ref<NavigationParams>>() && navigation_params.get<GC::Ref<NavigationParams>>()->request);
 
                 // 2. Set entry's document state's request referrer to navigationParams's request's referrer.
-                entry->document_state()->set_request_referrer(navigation_params.get<JS::NonnullGCPtr<NavigationParams>>()->request->referrer());
+                entry->document_state()->set_request_referrer(navigation_params.get<GC::Ref<NavigationParams>>()->request->referrer());
             }
         }
 
@@ -1356,7 +1356,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
     if (url.scheme() == "javascript"sv) {
         // 1. Queue a global task on the navigation and traversal task source given navigable's active window to navigate to a javascript: URL given navigable, url, historyHandling, initiatorOriginSnapshot, and cspNavigationType.
         VERIFY(active_window());
-        queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), JS::create_heap_function(heap(), [this, url, history_handling, initiator_origin_snapshot, csp_navigation_type, navigation_id] {
+        queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), GC::create_function(heap(), [this, url, history_handling, initiator_origin_snapshot, csp_navigation_type, navigation_id] {
             (void)navigate_to_a_javascript_url(url, to_history_handling_behavior(history_handling), initiator_origin_snapshot, csp_navigation_type, navigation_id);
         }));
 
@@ -1401,7 +1401,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
     }
 
     // 20. In parallel, run these steps:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(heap(), [this, source_snapshot_params, target_snapshot_params, csp_navigation_type, document_resource, url, navigation_id, referrer_policy, initiator_origin_snapshot, response, history_handling, initiator_base_url_snapshot] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(heap(), [this, source_snapshot_params, target_snapshot_params, csp_navigation_type, document_resource, url, navigation_id, referrer_policy, initiator_origin_snapshot, response, history_handling, initiator_base_url_snapshot] {
         // AD-HOC: Not in the spec but subsequent steps will fail if the navigable doesn't have an active window.
         if (!active_window()) {
             set_delaying_load_events(false);
@@ -1427,7 +1427,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
         }
 
         // 3. Queue a global task on the navigation and traversal task source given navigable's active window to abort a document and its descendants given navigable's active document.
-        queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), JS::create_heap_function(heap(), [this] {
+        queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), GC::create_function(heap(), [this] {
             VERIFY(this->active_document());
             this->active_document()->abort_a_document_and_its_descendants();
         }));
@@ -1437,7 +1437,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
         //    initiator origin: initiatorOriginSnapshot
         //    resource: documentResource
         //    navigable target name: navigable's target name
-        JS::NonnullGCPtr<DocumentState> document_state = *heap().allocate<DocumentState>();
+        GC::Ref<DocumentState> document_state = *heap().allocate<DocumentState>();
         document_state->set_request_referrer_policy(referrer_policy);
         document_state->set_initiator_origin(initiator_origin_snapshot);
         document_state->set_resource(document_resource);
@@ -1458,7 +1458,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
         }
 
         // 6. Let historyEntry be a new session history entry, with its URL set to url and its document state set to documentState.
-        JS::NonnullGCPtr<SessionHistoryEntry> history_entry = *heap().allocate<SessionHistoryEntry>();
+        GC::Ref<SessionHistoryEntry> history_entry = *heap().allocate<SessionHistoryEntry>();
         history_entry->set_url(url);
         history_entry->set_document_state(document_state);
 
@@ -1473,9 +1473,9 @@ WebIDL::ExceptionOr<void> Navigable::navigate(NavigateParams params)
         //     for historyEntry, given navigable, "navigate", sourceSnapshotParams,
         //     targetSnapshotParams, navigationId, navigationParams, cspNavigationType, with allowPOST
         //     set to true and completionSteps set to the following step:
-        populate_session_history_entry_document(history_entry, source_snapshot_params, target_snapshot_params, navigation_id, navigation_params, csp_navigation_type, true, JS::create_heap_function(heap(), [this, history_entry, history_handling, navigation_id] {
+        populate_session_history_entry_document(history_entry, source_snapshot_params, target_snapshot_params, navigation_id, navigation_params, csp_navigation_type, true, GC::create_function(heap(), [this, history_entry, history_handling, navigation_id] {
             // 1.     Append session history traversal steps to navigable's traversable to finalize a cross-document navigation given navigable, historyHandling, and historyEntry.
-            traversable_navigable()->append_session_history_traversal_steps(JS::create_heap_function(heap(), [this, history_entry, history_handling, navigation_id] {
+            traversable_navigable()->append_session_history_traversal_steps(GC::create_function(heap(), [this, history_entry, history_handling, navigation_id] {
                 if (this->has_been_destroyed()) {
                     // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
                     set_delaying_load_events(false);
@@ -1521,7 +1521,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate_to_a_fragment(URL::URL const& url,
     //      document state: navigable's active session history entry's document state
     //      navigation API state: destinationNavigationAPIState
     //      scroll restoration mode: navigable's active session history entry's scroll restoration mode
-    JS::NonnullGCPtr<SessionHistoryEntry> history_entry = heap().allocate<SessionHistoryEntry>();
+    GC::Ref<SessionHistoryEntry> history_entry = heap().allocate<SessionHistoryEntry>();
     history_entry->set_url(url);
     history_entry->set_document_state(active_session_history_entry()->document_state());
     history_entry->set_navigation_api_state(destination_navigation_api_state);
@@ -1570,7 +1570,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate_to_a_fragment(URL::URL const& url,
     auto traversable = traversable_navigable();
 
     // 17. Append the following session history synchronous navigation steps involving navigable to traversable:
-    traversable->append_session_history_synchronous_navigation_steps(*this, JS::create_heap_function(heap(), [this, traversable, history_entry, entry_to_replace, navigation_id, history_handling] {
+    traversable->append_session_history_synchronous_navigation_steps(*this, GC::create_function(heap(), [this, traversable, history_entry, entry_to_replace, navigation_id, history_handling] {
         // 1. Finalize a same-document navigation given traversable, navigable, historyEntry, and entryToReplace.
         finalize_a_same_document_navigation(*traversable, *this, history_entry, entry_to_replace, history_handling);
 
@@ -1584,7 +1584,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate_to_a_fragment(URL::URL const& url,
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#evaluate-a-javascript:-url
 // https://whatpr.org/html/9893/browsing-the-web.html#evaluate-a-javascript:-url
-WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> Navigable::evaluate_javascript_url(URL::URL const& url, URL::Origin const& new_document_origin, String navigation_id)
+WebIDL::ExceptionOr<GC::Ptr<DOM::Document>> Navigable::evaluate_javascript_url(URL::URL const& url, URL::Origin const& new_document_origin, String navigation_id)
 {
     auto& vm = this->vm();
     VERIFY(active_window());
@@ -1734,7 +1734,7 @@ WebIDL::ExceptionOr<void> Navigable::navigate_to_a_javascript_url(URL::URL const
     //     resource: null
     //     ever populated: true
     //     navigable target name: oldDocState's navigable target name
-    JS::NonnullGCPtr<DocumentState> document_state = *heap().allocate<DocumentState>();
+    GC::Ref<DocumentState> document_state = *heap().allocate<DocumentState>();
     document_state->set_document(new_document);
     document_state->set_history_policy_container(old_doc_state->history_policy_container());
     document_state->set_request_referrer(old_doc_state->request_referrer());
@@ -1748,12 +1748,12 @@ WebIDL::ExceptionOr<void> Navigable::navigate_to_a_javascript_url(URL::URL const
     // 12. Let historyEntry be a new session history entry, with
     //     URL: entryToReplace's URL
     //     document state: documentState
-    JS::NonnullGCPtr<SessionHistoryEntry> history_entry = *heap().allocate<SessionHistoryEntry>();
+    GC::Ref<SessionHistoryEntry> history_entry = *heap().allocate<SessionHistoryEntry>();
     history_entry->set_url(entry_to_replace->url());
     history_entry->set_document_state(document_state);
 
     // 13. Append session history traversal steps to targetNavigable's traversable to finalize a cross-document navigation with targetNavigable, historyHandling, and historyEntry.
-    traversable_navigable()->append_session_history_traversal_steps(JS::create_heap_function(heap(), [this, history_entry, history_handling, navigation_id] {
+    traversable_navigable()->append_session_history_traversal_steps(GC::create_function(heap(), [this, history_entry, history_handling, navigation_id] {
         finalize_a_cross_document_navigation(*this, history_handling, history_entry);
     }));
 
@@ -1770,7 +1770,7 @@ void Navigable::reload()
     auto traversable = traversable_navigable();
 
     // 3. Append the following session history traversal steps to traversable:
-    traversable->append_session_history_traversal_steps(JS::create_heap_function(heap(), [traversable] {
+    traversable->append_session_history_traversal_steps(GC::create_function(heap(), [traversable] {
         // 1. Apply the reload history step to traversable.
         traversable->apply_the_reload_history_step();
     }));
@@ -1855,7 +1855,7 @@ TargetSnapshotParams Navigable::snapshot_target_snapshot_params()
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#finalize-a-cross-document-navigation
-void finalize_a_cross_document_navigation(JS::NonnullGCPtr<Navigable> navigable, HistoryHandlingBehavior history_handling, JS::NonnullGCPtr<SessionHistoryEntry> history_entry)
+void finalize_a_cross_document_navigation(GC::Ref<Navigable> navigable, HistoryHandlingBehavior history_handling, GC::Ref<SessionHistoryEntry> history_entry)
 {
     // NOTE: This is not in the spec but we should not navigate destroyed navigable.
     if (navigable->has_been_destroyed())
@@ -1939,7 +1939,7 @@ void perform_url_and_history_update_steps(DOM::Document& document, URL::URL new_
     //      document state: activeEntry's document state
     //      scroll restoration mode: activeEntry's scroll restoration mode
     // FIXME: persisted user state: activeEntry's persisted user state
-    JS::NonnullGCPtr<SessionHistoryEntry> new_entry = document.heap().allocate<SessionHistoryEntry>();
+    GC::Ref<SessionHistoryEntry> new_entry = document.heap().allocate<SessionHistoryEntry>();
     new_entry->set_url(new_url);
     new_entry->set_classic_history_api_state(serialized_data.value_or(active_entry->classic_history_api_state()));
     new_entry->set_document_state(active_entry->document_state());
@@ -1984,7 +1984,7 @@ void perform_url_and_history_update_steps(DOM::Document& document, URL::URL new_
     auto traversable = navigable->traversable_navigable();
 
     // 13. Append the following session history synchronous navigation steps involving navigable to traversable:
-    traversable->append_session_history_synchronous_navigation_steps(*navigable, JS::create_heap_function(document.realm().heap(), [traversable, navigable, new_entry, entry_to_replace, history_handling] {
+    traversable->append_session_history_synchronous_navigation_steps(*navigable, GC::create_function(document.realm().heap(), [traversable, navigable, new_entry, entry_to_replace, history_handling] {
         // 1. Finalize a same-document navigation given traversable, navigable, newEntry, and entryToReplace.
         finalize_a_same_document_navigation(*traversable, *navigable, new_entry, entry_to_replace, history_handling);
 
@@ -2111,7 +2111,7 @@ void Navigable::inform_the_navigation_api_about_aborting_navigation()
     if (!active_window())
         return;
 
-    queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), JS::create_heap_function(heap(), [this] {
+    queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), GC::create_function(heap(), [this] {
         // 2. Let navigation be navigable's active window's navigation API.
         VERIFY(active_window());
         auto navigation = active_window()->navigation();
diff --git a/Libraries/LibWeb/HTML/Navigable.h b/Libraries/LibWeb/HTML/Navigable.h
index 5d65b99ea9e..af71a559d82 100644
--- a/Libraries/LibWeb/HTML/Navigable.h
+++ b/Libraries/LibWeb/HTML/Navigable.h
@@ -48,27 +48,27 @@ struct TargetSnapshotParams {
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#navigable
 class Navigable : public JS::Cell {
-    JS_CELL(Navigable, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Navigable);
+    GC_CELL(Navigable, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Navigable);
 
 public:
     virtual ~Navigable() override;
 
     using NullWithError = StringView;
-    using NavigationParamsVariant = Variant<Empty, NullWithError, JS::NonnullGCPtr<NavigationParams>, JS::NonnullGCPtr<NonFetchSchemeNavigationParams>>;
+    using NavigationParamsVariant = Variant<Empty, NullWithError, GC::Ref<NavigationParams>, GC::Ref<NonFetchSchemeNavigationParams>>;
 
-    ErrorOr<void> initialize_navigable(JS::NonnullGCPtr<DocumentState> document_state, JS::GCPtr<Navigable> parent);
+    ErrorOr<void> initialize_navigable(GC::Ref<DocumentState> document_state, GC::Ptr<Navigable> parent);
 
     void register_navigation_observer(Badge<NavigationObserver>, NavigationObserver&);
     void unregister_navigation_observer(Badge<NavigationObserver>, NavigationObserver&);
 
-    Vector<JS::Handle<Navigable>> child_navigables() const;
+    Vector<GC::Root<Navigable>> child_navigables() const;
 
     bool is_traversable() const;
 
     String const& id() const { return m_id; }
-    JS::GCPtr<Navigable> parent() const { return m_parent; }
-    bool is_ancestor_of(JS::NonnullGCPtr<Navigable>) const;
+    GC::Ptr<Navigable> parent() const { return m_parent; }
+    bool is_ancestor_of(GC::Ref<Navigable>) const;
 
     bool is_closing() const { return m_closing; }
     void set_closing(bool value) { m_closing = value; }
@@ -77,29 +77,29 @@ public:
     void set_delaying_load_events(bool value);
     bool is_delaying_load_events() const { return m_delaying_the_load_event.has_value(); }
 
-    JS::GCPtr<SessionHistoryEntry> active_session_history_entry() const { return m_active_session_history_entry; }
-    void set_active_session_history_entry(JS::GCPtr<SessionHistoryEntry> entry) { m_active_session_history_entry = entry; }
-    JS::GCPtr<SessionHistoryEntry> current_session_history_entry() const { return m_current_session_history_entry; }
-    void set_current_session_history_entry(JS::GCPtr<SessionHistoryEntry> entry) { m_current_session_history_entry = entry; }
+    GC::Ptr<SessionHistoryEntry> active_session_history_entry() const { return m_active_session_history_entry; }
+    void set_active_session_history_entry(GC::Ptr<SessionHistoryEntry> entry) { m_active_session_history_entry = entry; }
+    GC::Ptr<SessionHistoryEntry> current_session_history_entry() const { return m_current_session_history_entry; }
+    void set_current_session_history_entry(GC::Ptr<SessionHistoryEntry> entry) { m_current_session_history_entry = entry; }
 
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>>& get_session_history_entries() const;
+    Vector<GC::Ref<SessionHistoryEntry>>& get_session_history_entries() const;
 
-    void activate_history_entry(JS::GCPtr<SessionHistoryEntry>);
+    void activate_history_entry(GC::Ptr<SessionHistoryEntry>);
 
-    JS::GCPtr<DOM::Document> active_document();
-    JS::GCPtr<BrowsingContext> active_browsing_context();
-    JS::GCPtr<WindowProxy> active_window_proxy();
-    JS::GCPtr<Window> active_window();
+    GC::Ptr<DOM::Document> active_document();
+    GC::Ptr<BrowsingContext> active_browsing_context();
+    GC::Ptr<WindowProxy> active_window_proxy();
+    GC::Ptr<Window> active_window();
 
-    JS::GCPtr<SessionHistoryEntry> get_the_target_history_entry(int target_step) const;
+    GC::Ptr<SessionHistoryEntry> get_the_target_history_entry(int target_step) const;
 
     String target_name() const;
 
-    JS::GCPtr<NavigableContainer> container() const;
-    JS::GCPtr<DOM::Document> container_document() const;
+    GC::Ptr<NavigableContainer> container() const;
+    GC::Ptr<DOM::Document> container_document() const;
 
-    JS::GCPtr<TraversableNavigable> traversable_navigable() const;
-    JS::GCPtr<TraversableNavigable> top_level_traversable();
+    GC::Ptr<TraversableNavigable> traversable_navigable() const;
+    GC::Ptr<TraversableNavigable> top_level_traversable();
 
     virtual bool is_top_level_traversable() const { return false; }
 
@@ -112,13 +112,13 @@ public:
     };
 
     struct ChosenNavigable {
-        JS::GCPtr<Navigable> navigable;
+        GC::Ptr<Navigable> navigable;
         WindowType window_type;
     };
 
     ChosenNavigable choose_a_navigable(StringView name, TokenizedFeature::NoOpener no_opener, ActivateTab = ActivateTab::Yes, Optional<TokenizedFeature::Map const&> window_features = {});
 
-    static JS::GCPtr<Navigable> navigable_with_active_document(JS::NonnullGCPtr<DOM::Document>);
+    static GC::Ptr<Navigable> navigable_with_active_document(GC::Ref<DOM::Document>);
 
     enum class Traversal {
         Tag
@@ -128,20 +128,20 @@ public:
     void set_ongoing_navigation(Variant<Empty, Traversal, String> ongoing_navigation);
 
     WebIDL::ExceptionOr<void> populate_session_history_entry_document(
-        JS::GCPtr<SessionHistoryEntry> entry,
+        GC::Ptr<SessionHistoryEntry> entry,
         SourceSnapshotParams const& source_snapshot_params,
         TargetSnapshotParams const& target_snapshot_params,
         Optional<String> navigation_id = {},
         NavigationParamsVariant navigation_params = Empty {},
         CSPNavigationType csp_navigation_type = CSPNavigationType::Other,
         bool allow_POST = false,
-        JS::GCPtr<JS::HeapFunction<void()>> completion_steps = {});
+        GC::Ptr<GC::Function<void()>> completion_steps = {});
 
     struct NavigateParams {
         URL::URL const& url;
-        JS::NonnullGCPtr<DOM::Document> source_document;
+        GC::Ref<DOM::Document> source_document;
         Variant<Empty, String, POSTResource> document_resource = Empty {};
-        JS::GCPtr<Fetch::Infrastructure::Response> response = nullptr;
+        GC::Ptr<Fetch::Infrastructure::Response> response = nullptr;
         bool exceptions_enabled = false;
         Bindings::NavigationHistoryBehavior history_handling = Bindings::NavigationHistoryBehavior::Auto;
         Optional<SerializationRecord> navigation_api_state = {};
@@ -154,7 +154,7 @@ public:
 
     WebIDL::ExceptionOr<void> navigate_to_a_fragment(URL::URL const&, HistoryHandlingBehavior, UserNavigationInvolvement, Optional<SerializationRecord> navigation_api_state, String navigation_id);
 
-    WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> evaluate_javascript_url(URL::URL const&, URL::Origin const& new_document_origin, String navigation_id);
+    WebIDL::ExceptionOr<GC::Ptr<DOM::Document>> evaluate_javascript_url(URL::URL const&, URL::Origin const& new_document_origin, String navigation_id);
     WebIDL::ExceptionOr<void> navigate_to_a_javascript_url(URL::URL const&, HistoryHandlingBehavior, URL::Origin const& initiator_origin, CSPNavigationType csp_navigation_type, String navigation_id);
 
     bool allowed_by_sandboxing_to_navigate(Navigable const& target, SourceSnapshotParams const&);
@@ -195,7 +195,7 @@ public:
     Web::EventHandler const& event_handler() const { return m_event_handler; }
 
 protected:
-    explicit Navigable(JS::NonnullGCPtr<Page>);
+    explicit Navigable(GC::Ref<Page>);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
@@ -216,13 +216,13 @@ private:
     String m_id;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-parent
-    JS::GCPtr<Navigable> m_parent;
+    GC::Ptr<Navigable> m_parent;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-current-history-entry
-    JS::GCPtr<SessionHistoryEntry> m_current_session_history_entry;
+    GC::Ptr<SessionHistoryEntry> m_current_session_history_entry;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#nav-active-history-entry
-    JS::GCPtr<SessionHistoryEntry> m_active_session_history_entry;
+    GC::Ptr<SessionHistoryEntry> m_active_session_history_entry;
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#is-closing
     bool m_closing { false };
@@ -231,11 +231,11 @@ private:
     Optional<DOM::DocumentLoadEventDelayer> m_delaying_the_load_event;
 
     // Implied link between navigable and its container.
-    JS::GCPtr<NavigableContainer> m_container;
+    GC::Ptr<NavigableContainer> m_container;
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
 
-    HashTable<JS::NonnullGCPtr<NavigationObserver>> m_navigation_observers;
+    HashTable<GC::Ref<NavigationObserver>> m_navigation_observers;
 
     bool m_has_been_destroyed { false };
 
@@ -248,7 +248,7 @@ private:
 HashTable<Navigable*>& all_navigables();
 
 bool navigation_must_be_a_replace(URL::URL const& url, DOM::Document const& document);
-void finalize_a_cross_document_navigation(JS::NonnullGCPtr<Navigable>, HistoryHandlingBehavior, JS::NonnullGCPtr<SessionHistoryEntry>);
+void finalize_a_cross_document_navigation(GC::Ref<Navigable>, HistoryHandlingBehavior, GC::Ref<SessionHistoryEntry>);
 void perform_url_and_history_update_steps(DOM::Document& document, URL::URL new_url, Optional<SerializationRecord> = {}, HistoryHandlingBehavior history_handling = HistoryHandlingBehavior::Replace);
 UserNavigationInvolvement user_navigation_involvement(DOM::Event const&);
 
diff --git a/Libraries/LibWeb/HTML/NavigableContainer.cpp b/Libraries/LibWeb/HTML/NavigableContainer.cpp
index b0fe12166eb..626e3d419ea 100644
--- a/Libraries/LibWeb/HTML/NavigableContainer.cpp
+++ b/Libraries/LibWeb/HTML/NavigableContainer.cpp
@@ -49,7 +49,7 @@ void NavigableContainer::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_content_navigable);
 }
 
-JS::GCPtr<NavigableContainer> NavigableContainer::navigable_container_with_content_navigable(JS::NonnullGCPtr<Navigable> navigable)
+GC::Ptr<NavigableContainer> NavigableContainer::navigable_container_with_content_navigable(GC::Ref<Navigable> navigable)
 {
     for (auto* navigable_container : all_instances()) {
         if (navigable_container->content_navigable() == navigable)
@@ -59,7 +59,7 @@ JS::GCPtr<NavigableContainer> NavigableContainer::navigable_container_with_conte
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#create-a-new-child-navigable
-WebIDL::ExceptionOr<void> NavigableContainer::create_new_child_navigable(JS::GCPtr<JS::HeapFunction<void()>> after_session_history_update)
+WebIDL::ExceptionOr<void> NavigableContainer::create_new_child_navigable(GC::Ptr<GC::Function<void()>> after_session_history_update)
 {
     // 1. Let parentNavigable be element's node navigable.
     auto parent_navigable = navigable();
@@ -86,7 +86,7 @@ WebIDL::ExceptionOr<void> NavigableContainer::create_new_child_navigable(JS::GCP
     //  - origin: document's origin
     //  - navigable target name: targetName
     //  - about base URL: document's about base URL
-    JS::NonnullGCPtr<DocumentState> document_state = *heap().allocate<HTML::DocumentState>();
+    GC::Ref<DocumentState> document_state = *heap().allocate<HTML::DocumentState>();
     document_state->set_document(document);
     document_state->set_initiator_origin(document->origin());
     document_state->set_origin(document->origin());
@@ -95,7 +95,7 @@ WebIDL::ExceptionOr<void> NavigableContainer::create_new_child_navigable(JS::GCP
     document_state->set_about_base_url(document->about_base_url());
 
     // 7. Let navigable be a new navigable.
-    JS::NonnullGCPtr<Navigable> navigable = *heap().allocate<Navigable>(page);
+    GC::Ref<Navigable> navigable = *heap().allocate<Navigable>(page);
 
     // 8. Initialize the navigable navigable given documentState and parentNavigable.
     TRY_OR_THROW_OOM(vm(), navigable->initialize_navigable(document_state, parent_navigable));
@@ -110,7 +110,7 @@ WebIDL::ExceptionOr<void> NavigableContainer::create_new_child_navigable(JS::GCP
     auto traversable = parent_navigable->traversable_navigable();
 
     // 12. Append the following session history traversal steps to traversable:
-    traversable->append_session_history_traversal_steps(JS::create_heap_function(heap(), [traversable, navigable, parent_navigable, history_entry, after_session_history_update] {
+    traversable->append_session_history_traversal_steps(GC::create_function(heap(), [traversable, navigable, parent_navigable, history_entry, after_session_history_update] {
         // 1. Let parentDocState be parentNavigable's active session history entry's document state.
         auto parent_doc_state = parent_navigable->active_session_history_entry()->document_state();
 
@@ -278,7 +278,7 @@ void NavigableContainer::destroy_the_child_navigable()
     // FIXME: 4. Inform the navigation API about child navigable destruction given navigable.
 
     // 5. Destroy a document and its descendants given navigable's active document.
-    navigable->active_document()->destroy_a_document_and_its_descendants(JS::create_heap_function(heap(), [this, navigable] {
+    navigable->active_document()->destroy_a_document_and_its_descendants(GC::create_function(heap(), [this, navigable] {
         // 3. Set container's content navigable to null.
         m_content_navigable = nullptr;
 
@@ -297,7 +297,7 @@ void NavigableContainer::destroy_the_child_navigable()
         auto traversable = this->navigable()->traversable_navigable();
 
         // 9. Append the following session history traversal steps to traversable:
-        traversable->append_session_history_traversal_steps(JS::create_heap_function(heap(), [traversable] {
+        traversable->append_session_history_traversal_steps(GC::create_function(heap(), [traversable] {
             // 1. Update for navigable creation/destruction given traversable.
             traversable->update_for_navigable_creation_or_destruction();
         }));
diff --git a/Libraries/LibWeb/HTML/NavigableContainer.h b/Libraries/LibWeb/HTML/NavigableContainer.h
index 16895bba070..b4cda3d6e94 100644
--- a/Libraries/LibWeb/HTML/NavigableContainer.h
+++ b/Libraries/LibWeb/HTML/NavigableContainer.h
@@ -15,14 +15,14 @@ class NavigableContainer : public HTMLElement {
     WEB_PLATFORM_OBJECT(NavigableContainer, HTMLElement);
 
 public:
-    static JS::GCPtr<NavigableContainer> navigable_container_with_content_navigable(JS::NonnullGCPtr<Navigable> navigable);
+    static GC::Ptr<NavigableContainer> navigable_container_with_content_navigable(GC::Ref<Navigable> navigable);
 
     virtual ~NavigableContainer() override;
 
     static HashTable<NavigableContainer*>& all_instances();
 
-    JS::GCPtr<Navigable> content_navigable() { return m_content_navigable; }
-    JS::GCPtr<Navigable const> content_navigable() const { return m_content_navigable.ptr(); }
+    GC::Ptr<Navigable> content_navigable() { return m_content_navigable; }
+    GC::Ptr<Navigable const> content_navigable() const { return m_content_navigable.ptr(); }
 
     const DOM::Document* content_document() const;
     DOM::Document const* content_document_without_origin_check() const;
@@ -51,10 +51,10 @@ protected:
     // https://html.spec.whatwg.org/multipage/iframe-embed-object.html#navigate-an-iframe-or-frame
     void navigate_an_iframe_or_frame(URL::URL url, ReferrerPolicy::ReferrerPolicy referrer_policy, Optional<String> srcdoc_string = {});
 
-    WebIDL::ExceptionOr<void> create_new_child_navigable(JS::GCPtr<JS::HeapFunction<void()>> after_session_history_update = {});
+    WebIDL::ExceptionOr<void> create_new_child_navigable(GC::Ptr<GC::Function<void()>> after_session_history_update = {});
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#content-navigable
-    JS::GCPtr<Navigable> m_content_navigable { nullptr };
+    GC::Ptr<Navigable> m_content_navigable { nullptr };
 
     void set_potentially_delays_the_load_event(bool value) { m_potentially_delays_the_load_event = value; }
 
diff --git a/Libraries/LibWeb/HTML/NavigateEvent.cpp b/Libraries/LibWeb/HTML/NavigateEvent.cpp
index a6639e17f62..657e19166d8 100644
--- a/Libraries/LibWeb/HTML/NavigateEvent.cpp
+++ b/Libraries/LibWeb/HTML/NavigateEvent.cpp
@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibGC/Heap.h>
 #include <LibJS/Console.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/ConsoleObject.h>
 #include <LibJS/Runtime/Promise.h>
 #include <LibJS/Runtime/Realm.h>
@@ -23,9 +23,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigateEvent);
+GC_DEFINE_ALLOCATOR(NavigateEvent);
 
-JS::NonnullGCPtr<NavigateEvent> NavigateEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, NavigateEventInit const& event_init)
+GC::Ref<NavigateEvent> NavigateEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, NavigateEventInit const& event_init)
 {
     return realm.create<NavigateEvent>(realm, event_name, event_init);
 }
@@ -248,7 +248,7 @@ void NavigateEvent::potentially_reset_the_focus()
     auto& document = relevant_global_object.associated_document();
 
     // 8. FIXME: Let focusTarget be the autofocus delegate for document.
-    JS::GCPtr<DOM::Node> focus_target = nullptr;
+    GC::Ptr<DOM::Node> focus_target = nullptr;
 
     // 9. If focusTarget is null, then set focusTarget to document's body element.
     if (focus_target == nullptr)
diff --git a/Libraries/LibWeb/HTML/NavigateEvent.h b/Libraries/LibWeb/HTML/NavigateEvent.h
index a948be935f3..3b23533bbdb 100644
--- a/Libraries/LibWeb/HTML/NavigateEvent.h
+++ b/Libraries/LibWeb/HTML/NavigateEvent.h
@@ -16,23 +16,23 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigateeventinit
 struct NavigateEventInit : public DOM::EventInit {
     Bindings::NavigationType navigation_type = Bindings::NavigationType::Push;
-    JS::GCPtr<NavigationDestination> destination;
+    GC::Ptr<NavigationDestination> destination;
     bool can_intercept = false;
     bool user_initiated = false;
     bool hash_change = false;
-    JS::GCPtr<DOM::AbortSignal> signal;
-    JS::GCPtr<XHR::FormData> form_data = nullptr;
+    GC::Ptr<DOM::AbortSignal> signal;
+    GC::Ptr<XHR::FormData> form_data = nullptr;
     Optional<String> download_request = {};
     Optional<JS::Value> info;
     bool has_ua_visual_transition = false;
 };
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationintercepthandler
-using NavigationInterceptHandler = JS::NonnullGCPtr<WebIDL::CallbackType>;
+using NavigationInterceptHandler = GC::Ref<WebIDL::CallbackType>;
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationinterceptoptions
 struct NavigationInterceptOptions {
-    JS::GCPtr<WebIDL::CallbackType> handler;
+    GC::Ptr<WebIDL::CallbackType> handler;
     Optional<Bindings::NavigationFocusReset> focus_reset;
     Optional<Bindings::NavigationScrollBehavior> scroll;
 };
@@ -40,7 +40,7 @@ struct NavigationInterceptOptions {
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigateevent
 class NavigateEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(NavigateEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(NavigateEvent);
+    GC_DECLARE_ALLOCATOR(NavigateEvent);
 
 public:
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigateevent-interception-state
@@ -52,17 +52,17 @@ public:
         Finished
     };
 
-    [[nodiscard]] static JS::NonnullGCPtr<NavigateEvent> construct_impl(JS::Realm&, FlyString const& event_name, NavigateEventInit const&);
+    [[nodiscard]] static GC::Ref<NavigateEvent> construct_impl(JS::Realm&, FlyString const& event_name, NavigateEventInit const&);
 
     // The navigationType, destination, canIntercept, userInitiated, hashChange, signal, formData,
     // downloadRequest, info, and hasUAVisualTransition attributes must return the values they are initialized to.
     Bindings::NavigationType navigation_type() const { return m_navigation_type; }
-    JS::NonnullGCPtr<NavigationDestination> destination() const { return m_destination; }
+    GC::Ref<NavigationDestination> destination() const { return m_destination; }
     bool can_intercept() const { return m_can_intercept; }
     bool user_initiated() const { return m_user_initiated; }
     bool hash_change() const { return m_hash_change; }
-    JS::NonnullGCPtr<DOM::AbortSignal> signal() const { return m_signal; }
-    JS::GCPtr<XHR::FormData> form_data() const { return m_form_data; }
+    GC::Ref<DOM::AbortSignal> signal() const { return m_signal; }
+    GC::Ptr<XHR::FormData> form_data() const { return m_form_data; }
     Optional<String> download_request() const { return m_download_request; }
     JS::Value info() const { return m_info; }
     bool has_ua_visual_transition() const { return m_has_ua_visual_transition; }
@@ -72,12 +72,12 @@ public:
 
     virtual ~NavigateEvent() override;
 
-    JS::NonnullGCPtr<DOM::AbortController> abort_controller() const { return *m_abort_controller; }
+    GC::Ref<DOM::AbortController> abort_controller() const { return *m_abort_controller; }
     InterceptionState interception_state() const { return m_interception_state; }
     Vector<NavigationInterceptHandler> const& navigation_handler_list() const { return m_navigation_handler_list; }
     Optional<SerializationRecord> classic_history_api_state() const { return m_classic_history_api_state; }
 
-    void set_abort_controller(JS::NonnullGCPtr<DOM::AbortController> c) { m_abort_controller = c; }
+    void set_abort_controller(GC::Ref<DOM::AbortController> c) { m_abort_controller = c; }
     void set_interception_state(InterceptionState s) { m_interception_state = s; }
     void set_classic_history_api_state(Optional<SerializationRecord> r) { m_classic_history_api_state = move(r); }
 
@@ -107,7 +107,7 @@ private:
     Optional<Bindings::NavigationScrollBehavior> m_scroll_behavior = {};
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigateevent-abort-controller
-    JS::GCPtr<DOM::AbortController> m_abort_controller = { nullptr };
+    GC::Ptr<DOM::AbortController> m_abort_controller = { nullptr };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigateevent-classic-history-api-state
     Optional<SerializationRecord> m_classic_history_api_state = {};
@@ -116,7 +116,7 @@ private:
     Bindings::NavigationType m_navigation_type = { Bindings::NavigationType::Push };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigateevent-destination
-    JS::NonnullGCPtr<NavigationDestination> m_destination;
+    GC::Ref<NavigationDestination> m_destination;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigateevent-canintercept
     bool m_can_intercept = { false };
@@ -128,10 +128,10 @@ private:
     bool m_hash_change = { false };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigateevent-signal
-    JS::NonnullGCPtr<DOM::AbortSignal> m_signal;
+    GC::Ref<DOM::AbortSignal> m_signal;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigateevent-formdata
-    JS::GCPtr<XHR::FormData> m_form_data;
+    GC::Ptr<XHR::FormData> m_form_data;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigateevent-downloadrequest
     Optional<String> m_download_request;
diff --git a/Libraries/LibWeb/HTML/Navigation.cpp b/Libraries/LibWeb/HTML/Navigation.cpp
index 0c7f8af6be5..cee329954b5 100644
--- a/Libraries/LibWeb/HTML/Navigation.cpp
+++ b/Libraries/LibWeb/HTML/Navigation.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
@@ -30,18 +30,18 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Navigation);
-JS_DEFINE_ALLOCATOR(NavigationAPIMethodTracker);
+GC_DEFINE_ALLOCATOR(Navigation);
+GC_DEFINE_ALLOCATOR(NavigationAPIMethodTracker);
 
-static NavigationResult navigation_api_method_tracker_derived_result(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker);
+static NavigationResult navigation_api_method_tracker_derived_result(GC::Ref<NavigationAPIMethodTracker> api_method_tracker);
 
-NavigationAPIMethodTracker::NavigationAPIMethodTracker(JS::NonnullGCPtr<Navigation> navigation,
+NavigationAPIMethodTracker::NavigationAPIMethodTracker(GC::Ref<Navigation> navigation,
     Optional<String> key,
     JS::Value info,
     Optional<SerializationRecord> serialized_state,
-    JS::GCPtr<NavigationHistoryEntry> commited_to_entry,
-    JS::NonnullGCPtr<WebIDL::Promise> committed_promise,
-    JS::NonnullGCPtr<WebIDL::Promise> finished_promise)
+    GC::Ptr<NavigationHistoryEntry> commited_to_entry,
+    GC::Ref<WebIDL::Promise> committed_promise,
+    GC::Ref<WebIDL::Promise> finished_promise)
     : navigation(navigation)
     , key(move(key))
     , info(info)
@@ -62,7 +62,7 @@ void NavigationAPIMethodTracker::visit_edges(Cell::Visitor& visitor)
     visitor.visit(finished_promise);
 }
 
-JS::NonnullGCPtr<Navigation> Navigation::create(JS::Realm& realm)
+GC::Ref<Navigation> Navigation::create(JS::Realm& realm)
 {
     return realm.create<Navigation>(realm);
 }
@@ -92,7 +92,7 @@ void Navigation::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigation-entries
-Vector<JS::NonnullGCPtr<NavigationHistoryEntry>> Navigation::entries() const
+Vector<GC::Ref<NavigationHistoryEntry>> Navigation::entries() const
 {
     // The entries() method steps are:
 
@@ -108,7 +108,7 @@ Vector<JS::NonnullGCPtr<NavigationHistoryEntry>> Navigation::entries() const
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-current-entry
-JS::GCPtr<NavigationHistoryEntry> Navigation::current_entry() const
+GC::Ptr<NavigationHistoryEntry> Navigation::current_entry() const
 {
     // The current entry of a Navigation navigation is the result of running the following steps:
 
@@ -506,7 +506,7 @@ NavigationResult Navigation::early_error_result(AnyException e)
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-api-method-tracker-derived-result
-NavigationResult navigation_api_method_tracker_derived_result(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker)
+NavigationResult navigation_api_method_tracker_derived_result(GC::Ref<NavigationAPIMethodTracker> api_method_tracker)
 {
     // A navigation API method tracker-derived result for a navigation API method tracker is a NavigationResult
     /// dictionary instance given by «[ "committed" apiMethodTracker's committed promise, "finished" → apiMethodTracker's finished promise ]».
@@ -517,7 +517,7 @@ NavigationResult navigation_api_method_tracker_derived_result(JS::NonnullGCPtr<N
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#upcoming-non-traverse-api-method-tracker
-JS::NonnullGCPtr<NavigationAPIMethodTracker> Navigation::maybe_set_the_upcoming_non_traverse_api_method_tracker(JS::Value info, Optional<SerializationRecord> serialized_state)
+GC::Ref<NavigationAPIMethodTracker> Navigation::maybe_set_the_upcoming_non_traverse_api_method_tracker(JS::Value info, Optional<SerializationRecord> serialized_state)
 {
     auto& realm = relevant_realm(*this);
     auto& vm = this->vm();
@@ -574,7 +574,7 @@ JS::NonnullGCPtr<NavigationAPIMethodTracker> Navigation::maybe_set_the_upcoming_
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#add-an-upcoming-traverse-api-method-tracker
-JS::NonnullGCPtr<NavigationAPIMethodTracker> Navigation::add_an_upcoming_traverse_api_method_tracker(String destination_key, JS::Value info)
+GC::Ref<NavigationAPIMethodTracker> Navigation::add_an_upcoming_traverse_api_method_tracker(String destination_key, JS::Value info)
 {
     auto& vm = this->vm();
     auto& realm = relevant_realm(*this);
@@ -664,7 +664,7 @@ WebIDL::ExceptionOr<NavigationResult> Navigation::perform_a_navigation_api_trave
     auto source_snapshot_params = document.snapshot_source_snapshot_params();
 
     // 12. Append the following session history traversal steps to traversable:
-    traversable->append_session_history_traversal_steps(JS::create_heap_function(heap(), [key, api_method_tracker, navigable, source_snapshot_params, traversable, this] {
+    traversable->append_session_history_traversal_steps(GC::create_function(heap(), [key, api_method_tracker, navigable, source_snapshot_params, traversable, this] {
         // 1. Let navigableSHEs be the result of getting session history entries given navigable.
         auto navigable_shes = navigable->get_session_history_entries();
 
@@ -678,7 +678,7 @@ WebIDL::ExceptionOr<NavigationResult> Navigation::perform_a_navigation_api_trave
 
             // 1. Queue a global task on the navigation and traversal task source given navigation's relevant global object
             //    to reject the finished promise for apiMethodTracker with an "InvalidStateError" DOMException.
-            queue_global_task(HTML::Task::Source::NavigationAndTraversal, relevant_global_object(*this), JS::create_heap_function(heap(), [this, api_method_tracker] {
+            queue_global_task(HTML::Task::Source::NavigationAndTraversal, relevant_global_object(*this), GC::create_function(heap(), [this, api_method_tracker] {
                 auto& reject_realm = relevant_realm(*this);
                 TemporaryExecutionContext execution_context { reject_realm };
                 WebIDL::reject_promise(reject_realm, api_method_tracker->finished_promise,
@@ -711,7 +711,7 @@ WebIDL::ExceptionOr<NavigationResult> Navigation::perform_a_navigation_api_trave
         auto& realm = relevant_realm(*this);
         auto& global = relevant_global_object(*this);
         if (result == TraversableNavigable::HistoryStepResult::CanceledByBeforeUnload) {
-            queue_global_task(Task::Source::NavigationAndTraversal, global, JS::create_heap_function(heap(), [this, api_method_tracker, &realm] {
+            queue_global_task(Task::Source::NavigationAndTraversal, global, GC::create_function(heap(), [this, api_method_tracker, &realm] {
                 TemporaryExecutionContext execution_context { realm };
                 reject_the_finished_promise(api_method_tracker, WebIDL::AbortError::create(realm, "Navigation cancelled by beforeunload"_string));
             }));
@@ -721,7 +721,7 @@ WebIDL::ExceptionOr<NavigationResult> Navigation::perform_a_navigation_api_trave
         //    given navigation's relevant global object to reject the finished promise for apiMethodTracker with a
         //    new "SecurityError" DOMException created in navigation's relevant realm.
         if (result == TraversableNavigable::HistoryStepResult::InitiatorDisallowed) {
-            queue_global_task(Task::Source::NavigationAndTraversal, global, JS::create_heap_function(heap(), [this, api_method_tracker, &realm] {
+            queue_global_task(Task::Source::NavigationAndTraversal, global, GC::create_function(heap(), [this, api_method_tracker, &realm] {
                 TemporaryExecutionContext execution_context { realm };
                 reject_the_finished_promise(api_method_tracker, WebIDL::SecurityError::create(realm, "Navigation disallowed from this origin"_string));
             }));
@@ -733,7 +733,7 @@ WebIDL::ExceptionOr<NavigationResult> Navigation::perform_a_navigation_api_trave
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#abort-the-ongoing-navigation
-void Navigation::abort_the_ongoing_navigation(JS::GCPtr<WebIDL::DOMException> error)
+void Navigation::abort_the_ongoing_navigation(GC::Ptr<WebIDL::DOMException> error)
 {
     auto& realm = relevant_realm(*this);
 
@@ -826,7 +826,7 @@ void Navigation::promote_an_upcoming_api_method_tracker_to_ongoing(Optional<Stri
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-api-method-tracker-clean-up
-void Navigation::clean_up(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker)
+void Navigation::clean_up(GC::Ref<NavigationAPIMethodTracker> api_method_tracker)
 {
     // 1. Let navigation be apiMethodTracker's navigation object.
     VERIFY(api_method_tracker->navigation == this);
@@ -852,7 +852,7 @@ void Navigation::clean_up(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_metho
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#resolve-the-finished-promise
-void Navigation::resolve_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker)
+void Navigation::resolve_the_finished_promise(GC::Ref<NavigationAPIMethodTracker> api_method_tracker)
 {
     auto& realm = this->realm();
 
@@ -870,7 +870,7 @@ void Navigation::resolve_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMeth
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#reject-the-finished-promise
-void Navigation::reject_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker, JS::Value exception)
+void Navigation::reject_the_finished_promise(GC::Ref<NavigationAPIMethodTracker> api_method_tracker, JS::Value exception)
 {
     auto& realm = this->realm();
 
@@ -887,7 +887,7 @@ void Navigation::reject_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMetho
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#notify-about-the-committed-to-entry
-void Navigation::notify_about_the_committed_to_entry(JS::NonnullGCPtr<NavigationAPIMethodTracker> api_method_tracker, JS::NonnullGCPtr<NavigationHistoryEntry> nhe)
+void Navigation::notify_about_the_committed_to_entry(GC::Ref<NavigationAPIMethodTracker> api_method_tracker, GC::Ref<NavigationHistoryEntry> nhe)
 {
     auto& realm = this->realm();
 
@@ -911,7 +911,7 @@ void Navigation::notify_about_the_committed_to_entry(JS::NonnullGCPtr<Navigation
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#inner-navigate-event-firing-algorithm
 bool Navigation::inner_navigate_event_firing_algorithm(
     Bindings::NavigationType navigation_type,
-    JS::NonnullGCPtr<NavigationDestination> destination,
+    GC::Ref<NavigationDestination> destination,
     UserNavigationInvolvement user_involvement,
     Optional<Vector<XHR::FormDataEntry>&> form_data_entry_list,
     Optional<String> download_request_filename,
@@ -1131,7 +1131,7 @@ bool Navigation::inner_navigate_event_firing_algorithm(
     // 33. If endResultIsSameDocument is true:
     if (end_result_is_same_document) {
         // 1. Let promisesList be an empty list.
-        JS::MarkedVector<JS::NonnullGCPtr<WebIDL::Promise>> promises_list(realm.heap());
+        GC::MarkedVector<GC::Ref<WebIDL::Promise>> promises_list(realm.heap());
 
         // 2. For each handler of event's navigation handler list:
         for (auto const& handler : event->navigation_handler_list()) {
@@ -1251,7 +1251,7 @@ bool Navigation::inner_navigate_event_firing_algorithm(
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#fire-a-traverse-navigate-event
-bool Navigation::fire_a_traverse_navigate_event(JS::NonnullGCPtr<SessionHistoryEntry> destination_she, UserNavigationInvolvement user_involvement)
+bool Navigation::fire_a_traverse_navigate_event(GC::Ref<SessionHistoryEntry> destination_she, UserNavigationInvolvement user_involvement)
 {
     auto& realm = relevant_realm(*this);
     auto& vm = this->vm();
@@ -1373,7 +1373,7 @@ bool Navigation::fire_a_download_request_navigate_event(URL::URL destination_url
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#initialize-the-navigation-api-entries-for-a-new-document
-void Navigation::initialize_the_navigation_api_entries_for_a_new_document(Vector<JS::NonnullGCPtr<SessionHistoryEntry>> const& new_shes, JS::NonnullGCPtr<SessionHistoryEntry> initial_she)
+void Navigation::initialize_the_navigation_api_entries_for_a_new_document(Vector<GC::Ref<SessionHistoryEntry>> const& new_shes, GC::Ref<SessionHistoryEntry> initial_she)
 {
     auto& realm = relevant_realm(*this);
 
@@ -1403,7 +1403,7 @@ void Navigation::initialize_the_navigation_api_entries_for_a_new_document(Vector
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#update-the-navigation-api-entries-for-a-same-document-navigation
 // https://whatpr.org/html/9893/nav-history-apis.html#update-the-navigation-api-entries-for-a-same-document-navigation
-void Navigation::update_the_navigation_api_entries_for_a_same_document_navigation(JS::NonnullGCPtr<SessionHistoryEntry> destination_she, Bindings::NavigationType navigation_type)
+void Navigation::update_the_navigation_api_entries_for_a_same_document_navigation(GC::Ref<SessionHistoryEntry> destination_she, Bindings::NavigationType navigation_type)
 {
     auto& realm = relevant_realm(*this);
 
@@ -1415,7 +1415,7 @@ void Navigation::update_the_navigation_api_entries_for_a_same_document_navigatio
     auto old_current_nhe = current_entry();
 
     // 3. Let disposedNHEs be a new empty list.
-    Vector<JS::NonnullGCPtr<NavigationHistoryEntry>> disposed_nhes;
+    Vector<GC::Ref<NavigationHistoryEntry>> disposed_nhes;
 
     // 4. If navigationType is "traverse", then:
     if (navigation_type == Bindings::NavigationType::Traverse) {
diff --git a/Libraries/LibWeb/HTML/Navigation.h b/Libraries/LibWeb/HTML/Navigation.h
index 1246b6ebcd4..342b962b7c8 100644
--- a/Libraries/LibWeb/HTML/Navigation.h
+++ b/Libraries/LibWeb/HTML/Navigation.h
@@ -39,49 +39,49 @@ struct NavigationReloadOptions : public NavigationOptions {
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationresult
 struct NavigationResult {
-    JS::NonnullGCPtr<WebIDL::Promise> committed;
-    JS::NonnullGCPtr<WebIDL::Promise> finished;
+    GC::Ref<WebIDL::Promise> committed;
+    GC::Ref<WebIDL::Promise> finished;
 };
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-api-method-tracker
 struct NavigationAPIMethodTracker final : public JS::Cell {
-    JS_CELL(NavigationAPIMethodTracker, JS::Cell);
-    JS_DECLARE_ALLOCATOR(NavigationAPIMethodTracker);
+    GC_CELL(NavigationAPIMethodTracker, JS::Cell);
+    GC_DECLARE_ALLOCATOR(NavigationAPIMethodTracker);
 
-    NavigationAPIMethodTracker(JS::NonnullGCPtr<Navigation> navigation,
+    NavigationAPIMethodTracker(GC::Ref<Navigation> navigation,
         Optional<String> key,
         JS::Value info,
         Optional<SerializationRecord> serialized_state,
-        JS::GCPtr<NavigationHistoryEntry> commited_to_entry,
-        JS::NonnullGCPtr<WebIDL::Promise> committed_promise,
-        JS::NonnullGCPtr<WebIDL::Promise> finished_promise);
+        GC::Ptr<NavigationHistoryEntry> commited_to_entry,
+        GC::Ref<WebIDL::Promise> committed_promise,
+        GC::Ref<WebIDL::Promise> finished_promise);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<Navigation> navigation;
+    GC::Ref<Navigation> navigation;
     Optional<String> key;
     JS::Value info;
     Optional<SerializationRecord> serialized_state;
-    JS::GCPtr<NavigationHistoryEntry> commited_to_entry;
-    JS::NonnullGCPtr<WebIDL::Promise> committed_promise;
-    JS::NonnullGCPtr<WebIDL::Promise> finished_promise;
+    GC::Ptr<NavigationHistoryEntry> commited_to_entry;
+    GC::Ref<WebIDL::Promise> committed_promise;
+    GC::Ref<WebIDL::Promise> finished_promise;
 };
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-interface
 class Navigation : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(Navigation, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Navigation);
+    GC_DECLARE_ALLOCATOR(Navigation);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Navigation> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Navigation> create(JS::Realm&);
 
     // IDL properties and methods
-    Vector<JS::NonnullGCPtr<NavigationHistoryEntry>> entries() const;
-    JS::GCPtr<NavigationHistoryEntry> current_entry() const;
+    Vector<GC::Ref<NavigationHistoryEntry>> entries() const;
+    GC::Ptr<NavigationHistoryEntry> current_entry() const;
     WebIDL::ExceptionOr<void> update_current_entry(NavigationUpdateCurrentEntryOptions);
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigation-transition
-    JS::GCPtr<NavigationTransition> transition() const { return m_transition; }
+    GC::Ptr<NavigationTransition> transition() const { return m_transition; }
 
     bool can_go_back() const;
     bool can_go_forward() const;
@@ -109,8 +109,8 @@ public:
     // Abstract Operations
     bool has_entries_and_events_disabled() const;
     i64 get_the_navigation_api_entry_index(SessionHistoryEntry const&) const;
-    void abort_the_ongoing_navigation(JS::GCPtr<WebIDL::DOMException> error = {});
-    bool fire_a_traverse_navigate_event(JS::NonnullGCPtr<SessionHistoryEntry> destination_she, UserNavigationInvolvement = UserNavigationInvolvement::None);
+    void abort_the_ongoing_navigation(GC::Ptr<WebIDL::DOMException> error = {});
+    bool fire_a_traverse_navigate_event(GC::Ref<SessionHistoryEntry> destination_she, UserNavigationInvolvement = UserNavigationInvolvement::None);
     bool fire_a_push_replace_reload_navigate_event(
         Bindings::NavigationType,
         URL::URL destination_url,
@@ -121,13 +121,13 @@ public:
         Optional<SerializationRecord> classic_history_api_state = {});
     bool fire_a_download_request_navigate_event(URL::URL destination_url, UserNavigationInvolvement user_involvement, String filename);
 
-    void initialize_the_navigation_api_entries_for_a_new_document(Vector<JS::NonnullGCPtr<SessionHistoryEntry>> const& new_shes, JS::NonnullGCPtr<SessionHistoryEntry> initial_she);
-    void update_the_navigation_api_entries_for_a_same_document_navigation(JS::NonnullGCPtr<SessionHistoryEntry> destination_she, Bindings::NavigationType);
+    void initialize_the_navigation_api_entries_for_a_new_document(Vector<GC::Ref<SessionHistoryEntry>> const& new_shes, GC::Ref<SessionHistoryEntry> initial_she);
+    void update_the_navigation_api_entries_for_a_same_document_navigation(GC::Ref<SessionHistoryEntry> destination_she, Bindings::NavigationType);
 
     virtual ~Navigation() override;
 
     // Internal Getters/Setters
-    JS::GCPtr<NavigateEvent> ongoing_navigate_event() const { return m_ongoing_navigate_event; }
+    GC::Ptr<NavigateEvent> ongoing_navigate_event() const { return m_ongoing_navigate_event; }
 
     bool focus_changed_during_ongoing_navigation() const { return m_focus_changed_during_ongoing_navigation; }
     void set_focus_changed_during_ongoing_navigation(bool b) { m_focus_changed_during_ongoing_navigation = b; }
@@ -141,18 +141,18 @@ private:
     using AnyException = decltype(declval<WebIDL::ExceptionOr<void>>().exception());
     NavigationResult early_error_result(AnyException);
 
-    JS::NonnullGCPtr<NavigationAPIMethodTracker> maybe_set_the_upcoming_non_traverse_api_method_tracker(JS::Value info, Optional<SerializationRecord>);
-    JS::NonnullGCPtr<NavigationAPIMethodTracker> add_an_upcoming_traverse_api_method_tracker(String destination_key, JS::Value info);
+    GC::Ref<NavigationAPIMethodTracker> maybe_set_the_upcoming_non_traverse_api_method_tracker(JS::Value info, Optional<SerializationRecord>);
+    GC::Ref<NavigationAPIMethodTracker> add_an_upcoming_traverse_api_method_tracker(String destination_key, JS::Value info);
     WebIDL::ExceptionOr<NavigationResult> perform_a_navigation_api_traversal(String key, NavigationOptions const&);
     void promote_an_upcoming_api_method_tracker_to_ongoing(Optional<String> destination_key);
-    void resolve_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMethodTracker>);
-    void reject_the_finished_promise(JS::NonnullGCPtr<NavigationAPIMethodTracker>, JS::Value exception);
-    void clean_up(JS::NonnullGCPtr<NavigationAPIMethodTracker>);
-    void notify_about_the_committed_to_entry(JS::NonnullGCPtr<NavigationAPIMethodTracker>, JS::NonnullGCPtr<NavigationHistoryEntry>);
+    void resolve_the_finished_promise(GC::Ref<NavigationAPIMethodTracker>);
+    void reject_the_finished_promise(GC::Ref<NavigationAPIMethodTracker>, JS::Value exception);
+    void clean_up(GC::Ref<NavigationAPIMethodTracker>);
+    void notify_about_the_committed_to_entry(GC::Ref<NavigationAPIMethodTracker>, GC::Ref<NavigationHistoryEntry>);
 
     bool inner_navigate_event_firing_algorithm(
         Bindings::NavigationType,
-        JS::NonnullGCPtr<NavigationDestination>,
+        GC::Ref<NavigationDestination>,
         UserNavigationInvolvement,
         Optional<Vector<XHR::FormDataEntry>&> form_data_entry_list,
         Optional<String> download_request_filename,
@@ -160,7 +160,7 @@ private:
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-entry-list
     // Each Navigation has an associated entry list, a list of NavigationHistoryEntry objects, initially empty.
-    Vector<JS::NonnullGCPtr<NavigationHistoryEntry>> m_entry_list;
+    Vector<GC::Ref<NavigationHistoryEntry>> m_entry_list;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-current-entry-index
     // Each Navigation has an associated current entry index, an integer, initially −1.
@@ -168,10 +168,10 @@ private:
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigation-transition
     // Each Navigation has a transition, which is a NavigationTransition or null, initially null.
-    JS::GCPtr<NavigationTransition> m_transition { nullptr };
+    GC::Ptr<NavigationTransition> m_transition { nullptr };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#ongoing-navigate-event
-    JS::GCPtr<NavigateEvent> m_ongoing_navigate_event { nullptr };
+    GC::Ptr<NavigateEvent> m_ongoing_navigate_event { nullptr };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#focus-changed-during-ongoing-navigation
     bool m_focus_changed_during_ongoing_navigation { false };
@@ -180,13 +180,13 @@ private:
     bool m_suppress_scroll_restoration_during_ongoing_navigation { false };
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#ongoing-api-method-tracker
-    JS::GCPtr<NavigationAPIMethodTracker> m_ongoing_api_method_tracker = nullptr;
+    GC::Ptr<NavigationAPIMethodTracker> m_ongoing_api_method_tracker = nullptr;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#upcoming-non-traverse-api-method-tracker
-    JS::GCPtr<NavigationAPIMethodTracker> m_upcoming_non_traverse_api_method_tracker = nullptr;
+    GC::Ptr<NavigationAPIMethodTracker> m_upcoming_non_traverse_api_method_tracker = nullptr;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#upcoming-non-traverse-api-method-tracker
-    HashMap<String, JS::NonnullGCPtr<NavigationAPIMethodTracker>> m_upcoming_traverse_api_method_trackers;
+    HashMap<String, GC::Ref<NavigationAPIMethodTracker>> m_upcoming_traverse_api_method_trackers;
 };
 
 HistoryHandlingBehavior to_history_handling_behavior(Bindings::NavigationHistoryBehavior);
diff --git a/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.cpp b/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.cpp
index eeef4b3b82f..98bc0585c61 100644
--- a/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.cpp
+++ b/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/NavigationCurrentEntryChangeEventPrototype.h>
@@ -13,9 +13,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationCurrentEntryChangeEvent);
+GC_DEFINE_ALLOCATOR(NavigationCurrentEntryChangeEvent);
 
-JS::NonnullGCPtr<NavigationCurrentEntryChangeEvent> NavigationCurrentEntryChangeEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, NavigationCurrentEntryChangeEventInit const& event_init)
+GC::Ref<NavigationCurrentEntryChangeEvent> NavigationCurrentEntryChangeEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, NavigationCurrentEntryChangeEventInit const& event_init)
 {
     return realm.create<NavigationCurrentEntryChangeEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.h b/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.h
index 8351a26c79e..b3167baac1b 100644
--- a/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.h
+++ b/Libraries/LibWeb/HTML/NavigationCurrentEntryChangeEvent.h
@@ -13,20 +13,20 @@ namespace Web::HTML {
 
 struct NavigationCurrentEntryChangeEventInit : public DOM::EventInit {
     Optional<Bindings::NavigationType> navigation_type = {};
-    JS::GCPtr<NavigationHistoryEntry> from;
+    GC::Ptr<NavigationHistoryEntry> from;
 };
 
 class NavigationCurrentEntryChangeEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(NavigationCurrentEntryChangeEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(NavigationCurrentEntryChangeEvent);
+    GC_DECLARE_ALLOCATOR(NavigationCurrentEntryChangeEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NavigationCurrentEntryChangeEvent> construct_impl(JS::Realm&, FlyString const& event_name, NavigationCurrentEntryChangeEventInit const&);
+    [[nodiscard]] static GC::Ref<NavigationCurrentEntryChangeEvent> construct_impl(JS::Realm&, FlyString const& event_name, NavigationCurrentEntryChangeEventInit const&);
 
     virtual ~NavigationCurrentEntryChangeEvent() override;
 
     Optional<Bindings::NavigationType> const& navigation_type() const { return m_navigation_type; }
-    JS::NonnullGCPtr<NavigationHistoryEntry> from() const { return m_from; }
+    GC::Ref<NavigationHistoryEntry> from() const { return m_from; }
 
 private:
     NavigationCurrentEntryChangeEvent(JS::Realm&, FlyString const& event_name, NavigationCurrentEntryChangeEventInit const& event_init);
@@ -35,7 +35,7 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
 
     Optional<Bindings::NavigationType> m_navigation_type;
-    JS::NonnullGCPtr<NavigationHistoryEntry> m_from;
+    GC::Ref<NavigationHistoryEntry> m_from;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/NavigationDestination.cpp b/Libraries/LibWeb/HTML/NavigationDestination.cpp
index 2e573952909..e25d1b094a6 100644
--- a/Libraries/LibWeb/HTML/NavigationDestination.cpp
+++ b/Libraries/LibWeb/HTML/NavigationDestination.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/NavigationDestinationPrototype.h>
@@ -13,9 +13,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationDestination);
+GC_DEFINE_ALLOCATOR(NavigationDestination);
 
-JS::NonnullGCPtr<NavigationDestination> NavigationDestination::create(JS::Realm& realm)
+GC::Ref<NavigationDestination> NavigationDestination::create(JS::Realm& realm)
 {
     return realm.create<NavigationDestination>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/NavigationDestination.h b/Libraries/LibWeb/HTML/NavigationDestination.h
index 9a9597c7347..62f4308d84f 100644
--- a/Libraries/LibWeb/HTML/NavigationDestination.h
+++ b/Libraries/LibWeb/HTML/NavigationDestination.h
@@ -15,10 +15,10 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationdestination
 class NavigationDestination : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NavigationDestination, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NavigationDestination);
+    GC_DECLARE_ALLOCATOR(NavigationDestination);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NavigationDestination> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<NavigationDestination> create(JS::Realm&);
 
     WebIDL::ExceptionOr<String> url() const;
     String key() const;
@@ -28,11 +28,11 @@ public:
     WebIDL::ExceptionOr<JS::Value> get_state();
 
     // Non-spec'd getter, not exposed to JS
-    JS::GCPtr<NavigationHistoryEntry> navigation_history_entry() const { return m_entry; }
+    GC::Ptr<NavigationHistoryEntry> navigation_history_entry() const { return m_entry; }
 
     // Setters are not available to JS, but expected in many spec algorithms
     void set_url(URL::URL const& url) { m_url = url; }
-    void set_entry(JS::GCPtr<NavigationHistoryEntry> entry) { m_entry = entry; }
+    void set_entry(GC::Ptr<NavigationHistoryEntry> entry) { m_entry = entry; }
     void set_state(SerializationRecord state) { m_state = move(state); }
     void set_is_same_document(bool b) { m_is_same_document = b; }
 
@@ -50,7 +50,7 @@ private:
     URL::URL m_url;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigationdestination-url
-    JS::GCPtr<NavigationHistoryEntry> m_entry;
+    GC::Ptr<NavigationHistoryEntry> m_entry;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigationdestination-state
     SerializationRecord m_state;
diff --git a/Libraries/LibWeb/HTML/NavigationHistoryEntry.cpp b/Libraries/LibWeb/HTML/NavigationHistoryEntry.cpp
index 078db760779..694704dbf27 100644
--- a/Libraries/LibWeb/HTML/NavigationHistoryEntry.cpp
+++ b/Libraries/LibWeb/HTML/NavigationHistoryEntry.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/NavigationHistoryEntryPrototype.h>
@@ -16,14 +16,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationHistoryEntry);
+GC_DEFINE_ALLOCATOR(NavigationHistoryEntry);
 
-JS::NonnullGCPtr<NavigationHistoryEntry> NavigationHistoryEntry::create(JS::Realm& realm, JS::NonnullGCPtr<SessionHistoryEntry> she)
+GC::Ref<NavigationHistoryEntry> NavigationHistoryEntry::create(JS::Realm& realm, GC::Ref<SessionHistoryEntry> she)
 {
     return realm.create<NavigationHistoryEntry>(realm, she);
 }
 
-NavigationHistoryEntry::NavigationHistoryEntry(JS::Realm& realm, JS::NonnullGCPtr<SessionHistoryEntry> she)
+NavigationHistoryEntry::NavigationHistoryEntry(JS::Realm& realm, GC::Ref<SessionHistoryEntry> she)
     : DOM::EventTarget(realm)
     , m_session_history_entry(she)
 {
diff --git a/Libraries/LibWeb/HTML/NavigationHistoryEntry.h b/Libraries/LibWeb/HTML/NavigationHistoryEntry.h
index 5651e423ce6..2f21bbb8451 100644
--- a/Libraries/LibWeb/HTML/NavigationHistoryEntry.h
+++ b/Libraries/LibWeb/HTML/NavigationHistoryEntry.h
@@ -13,10 +13,10 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationhistoryentry
 class NavigationHistoryEntry : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(NavigationHistoryEntry, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(NavigationHistoryEntry);
+    GC_DECLARE_ALLOCATOR(NavigationHistoryEntry);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NavigationHistoryEntry> create(JS::Realm&, JS::NonnullGCPtr<SessionHistoryEntry>);
+    [[nodiscard]] static GC::Ref<NavigationHistoryEntry> create(JS::Realm&, GC::Ref<SessionHistoryEntry>);
 
     WebIDL::ExceptionOr<Optional<String>> url() const;
     String key() const;
@@ -35,11 +35,11 @@ public:
     virtual ~NavigationHistoryEntry() override;
 
 private:
-    NavigationHistoryEntry(JS::Realm&, JS::NonnullGCPtr<SessionHistoryEntry>);
+    NavigationHistoryEntry(JS::Realm&, GC::Ref<SessionHistoryEntry>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<SessionHistoryEntry> m_session_history_entry;
+    GC::Ref<SessionHistoryEntry> m_session_history_entry;
 };
 }
diff --git a/Libraries/LibWeb/HTML/NavigationObserver.cpp b/Libraries/LibWeb/HTML/NavigationObserver.cpp
index 7b95ccfa0e7..05757904415 100644
--- a/Libraries/LibWeb/HTML/NavigationObserver.cpp
+++ b/Libraries/LibWeb/HTML/NavigationObserver.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationObserver);
+GC_DEFINE_ALLOCATOR(NavigationObserver);
 
 NavigationObserver::NavigationObserver(JS::Realm& realm, Navigable& navigable)
     : Bindings::PlatformObject(realm)
@@ -35,7 +35,7 @@ void NavigationObserver::finalize()
 void NavigationObserver::set_navigation_complete(Function<void()> callback)
 {
     if (callback)
-        m_navigation_complete = JS::create_heap_function(vm().heap(), move(callback));
+        m_navigation_complete = GC::create_function(vm().heap(), move(callback));
     else
         m_navigation_complete = nullptr;
 }
diff --git a/Libraries/LibWeb/HTML/NavigationObserver.h b/Libraries/LibWeb/HTML/NavigationObserver.h
index 03be96d23b9..2089d78847d 100644
--- a/Libraries/LibWeb/HTML/NavigationObserver.h
+++ b/Libraries/LibWeb/HTML/NavigationObserver.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 
@@ -15,10 +15,10 @@ namespace Web::HTML {
 
 class NavigationObserver final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NavigationObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NavigationObserver);
+    GC_DECLARE_ALLOCATOR(NavigationObserver);
 
 public:
-    [[nodiscard]] JS::GCPtr<JS::HeapFunction<void()>> navigation_complete() const { return m_navigation_complete; }
+    [[nodiscard]] GC::Ptr<GC::Function<void()>> navigation_complete() const { return m_navigation_complete; }
     void set_navigation_complete(Function<void()>);
 
 private:
@@ -27,8 +27,8 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
     virtual void finalize() override;
 
-    JS::NonnullGCPtr<Navigable> m_navigable;
-    JS::GCPtr<JS::HeapFunction<void()>> m_navigation_complete;
+    GC::Ref<Navigable> m_navigable;
+    GC::Ptr<GC::Function<void()>> m_navigation_complete;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/NavigationParams.cpp b/Libraries/LibWeb/HTML/NavigationParams.cpp
index ebb039d46ac..6c535031bad 100644
--- a/Libraries/LibWeb/HTML/NavigationParams.cpp
+++ b/Libraries/LibWeb/HTML/NavigationParams.cpp
@@ -11,8 +11,8 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationParams);
-JS_DEFINE_ALLOCATOR(NonFetchSchemeNavigationParams);
+GC_DEFINE_ALLOCATOR(NavigationParams);
+GC_DEFINE_ALLOCATOR(NonFetchSchemeNavigationParams);
 
 void NavigationParams::visit_edges(Visitor& visitor)
 {
diff --git a/Libraries/LibWeb/HTML/NavigationParams.h b/Libraries/LibWeb/HTML/NavigationParams.h
index fe617d40cd4..0151bba9f2b 100644
--- a/Libraries/LibWeb/HTML/NavigationParams.h
+++ b/Libraries/LibWeb/HTML/NavigationParams.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Optional.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/Ptr.h>
 #include <LibURL/Origin.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Responses.h>
@@ -22,23 +22,23 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#navigation-params
 struct NavigationParams : JS::Cell {
-    JS_CELL(NavigationParams, JS::Cell);
-    JS_DECLARE_ALLOCATOR(NavigationParams);
+    GC_CELL(NavigationParams, JS::Cell);
+    GC_DECLARE_ALLOCATOR(NavigationParams);
 
     // null or a navigation ID
     Optional<String> id;
 
     // the navigable to be navigated
-    JS::GCPtr<Navigable> navigable;
+    GC::Ptr<Navigable> navigable;
 
     // null or a request that started the navigation
-    JS::GCPtr<Fetch::Infrastructure::Request> request;
+    GC::Ptr<Fetch::Infrastructure::Request> request;
 
     // a response that ultimately was navigated to (potentially a network error)
-    JS::GCPtr<Fetch::Infrastructure::Response> response;
+    GC::Ptr<Fetch::Infrastructure::Response> response;
 
     // null or a fetch controller
-    JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller { nullptr };
+    GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller { nullptr };
 
     // null or an algorithm accepting a Document, once it has been created
     Function<void(DOM::Document&)> commit_early_hints { nullptr };
@@ -71,14 +71,14 @@ struct NavigationParams : JS::Cell {
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#non-fetch-scheme-navigation-params
 struct NonFetchSchemeNavigationParams : JS::Cell {
-    JS_CELL(NonFetchSchemeNavigationParams, JS::Cell);
-    JS_DECLARE_ALLOCATOR(NonFetchSchemeNavigationParams);
+    GC_CELL(NonFetchSchemeNavigationParams, JS::Cell);
+    GC_DECLARE_ALLOCATOR(NonFetchSchemeNavigationParams);
 
     // null or a navigation ID
     Optional<String> id;
 
     // the navigable to be navigated
-    JS::GCPtr<Navigable> navigable;
+    GC::Ptr<Navigable> navigable;
 
     // a URL
     URL::URL url;
diff --git a/Libraries/LibWeb/HTML/NavigationTransition.cpp b/Libraries/LibWeb/HTML/NavigationTransition.cpp
index 3bdcd3a196a..90982f370df 100644
--- a/Libraries/LibWeb/HTML/NavigationTransition.cpp
+++ b/Libraries/LibWeb/HTML/NavigationTransition.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/NavigationTransitionPrototype.h>
@@ -14,14 +14,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(NavigationTransition);
+GC_DEFINE_ALLOCATOR(NavigationTransition);
 
-JS::NonnullGCPtr<NavigationTransition> NavigationTransition::create(JS::Realm& realm, Bindings::NavigationType navigation_type, JS::NonnullGCPtr<NavigationHistoryEntry> from_entry, JS::NonnullGCPtr<WebIDL::Promise> finished_promise)
+GC::Ref<NavigationTransition> NavigationTransition::create(JS::Realm& realm, Bindings::NavigationType navigation_type, GC::Ref<NavigationHistoryEntry> from_entry, GC::Ref<WebIDL::Promise> finished_promise)
 {
     return realm.create<NavigationTransition>(realm, navigation_type, from_entry, finished_promise);
 }
 
-NavigationTransition::NavigationTransition(JS::Realm& realm, Bindings::NavigationType navigation_type, JS::NonnullGCPtr<NavigationHistoryEntry> from_entry, JS::NonnullGCPtr<WebIDL::Promise> finished_promise)
+NavigationTransition::NavigationTransition(JS::Realm& realm, Bindings::NavigationType navigation_type, GC::Ref<NavigationHistoryEntry> from_entry, GC::Ref<WebIDL::Promise> finished_promise)
     : Bindings::PlatformObject(realm)
     , m_navigation_type(navigation_type)
     , m_from_entry(from_entry)
diff --git a/Libraries/LibWeb/HTML/NavigationTransition.h b/Libraries/LibWeb/HTML/NavigationTransition.h
index 6fdec435679..9f43ac036a2 100644
--- a/Libraries/LibWeb/HTML/NavigationTransition.h
+++ b/Libraries/LibWeb/HTML/NavigationTransition.h
@@ -14,24 +14,24 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigationtransition
 class NavigationTransition : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(NavigationTransition, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(NavigationTransition);
+    GC_DECLARE_ALLOCATOR(NavigationTransition);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<NavigationTransition> create(JS::Realm&, Bindings::NavigationType, JS::NonnullGCPtr<NavigationHistoryEntry>, JS::NonnullGCPtr<WebIDL::Promise>);
+    [[nodiscard]] static GC::Ref<NavigationTransition> create(JS::Realm&, Bindings::NavigationType, GC::Ref<NavigationHistoryEntry>, GC::Ref<WebIDL::Promise>);
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigationtransition-navigationtype
     Bindings::NavigationType navigation_type() const { return m_navigation_type; }
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigationtransition-from
-    JS::NonnullGCPtr<NavigationHistoryEntry> from() const { return m_from_entry; }
+    GC::Ref<NavigationHistoryEntry> from() const { return m_from_entry; }
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigationtransition-finished
-    JS::NonnullGCPtr<WebIDL::Promise> finished() const { return m_finished_promise; }
+    GC::Ref<WebIDL::Promise> finished() const { return m_finished_promise; }
 
     virtual ~NavigationTransition() override;
 
 private:
-    NavigationTransition(JS::Realm&, Bindings::NavigationType, JS::NonnullGCPtr<NavigationHistoryEntry>, JS::NonnullGCPtr<WebIDL::Promise>);
+    NavigationTransition(JS::Realm&, Bindings::NavigationType, GC::Ref<NavigationHistoryEntry>, GC::Ref<WebIDL::Promise>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
@@ -40,10 +40,10 @@ private:
     Bindings::NavigationType m_navigation_type;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigationtransition-from
-    JS::NonnullGCPtr<NavigationHistoryEntry> m_from_entry;
+    GC::Ref<NavigationHistoryEntry> m_from_entry;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#concept-navigationtransition-finished
-    JS::NonnullGCPtr<WebIDL::Promise> m_finished_promise;
+    GC::Ref<WebIDL::Promise> m_finished_promise;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Navigator.cpp b/Libraries/LibWeb/HTML/Navigator.cpp
index 57e844f67c5..478b975cb3f 100644
--- a/Libraries/LibWeb/HTML/Navigator.cpp
+++ b/Libraries/LibWeb/HTML/Navigator.cpp
@@ -6,7 +6,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/NavigatorPrototype.h>
@@ -20,9 +20,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Navigator);
+GC_DEFINE_ALLOCATOR(Navigator);
 
-JS::NonnullGCPtr<Navigator> Navigator::create(JS::Realm& realm)
+GC::Ref<Navigator> Navigator::create(JS::Realm& realm)
 {
     return realm.create<Navigator>(realm);
 }
@@ -70,28 +70,28 @@ void Navigator::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_media_capabilities);
 }
 
-JS::NonnullGCPtr<MimeTypeArray> Navigator::mime_types()
+GC::Ref<MimeTypeArray> Navigator::mime_types()
 {
     if (!m_mime_type_array)
         m_mime_type_array = realm().create<MimeTypeArray>(realm());
     return *m_mime_type_array;
 }
 
-JS::NonnullGCPtr<PluginArray> Navigator::plugins()
+GC::Ref<PluginArray> Navigator::plugins()
 {
     if (!m_plugin_array)
         m_plugin_array = realm().create<PluginArray>(realm());
     return *m_plugin_array;
 }
 
-JS::NonnullGCPtr<Clipboard::Clipboard> Navigator::clipboard()
+GC::Ref<Clipboard::Clipboard> Navigator::clipboard()
 {
     if (!m_clipboard)
         m_clipboard = realm().create<Clipboard::Clipboard>(realm());
     return *m_clipboard;
 }
 
-JS::NonnullGCPtr<UserActivation> Navigator::user_activation()
+GC::Ref<UserActivation> Navigator::user_activation()
 {
     if (!m_user_activation)
         m_user_activation = realm().create<UserActivation>(realm());
@@ -117,14 +117,14 @@ Optional<FlyString> Navigator::do_not_track() const
     return {};
 }
 
-JS::NonnullGCPtr<ServiceWorkerContainer> Navigator::service_worker()
+GC::Ref<ServiceWorkerContainer> Navigator::service_worker()
 {
     if (!m_service_worker_container)
         m_service_worker_container = realm().create<ServiceWorkerContainer>(realm());
     return *m_service_worker_container;
 }
 
-JS::NonnullGCPtr<MediaCapabilitiesAPI::MediaCapabilities> Navigator::media_capabilities()
+GC::Ref<MediaCapabilitiesAPI::MediaCapabilities> Navigator::media_capabilities()
 {
     if (!m_media_capabilities)
         m_media_capabilities = realm().create<MediaCapabilitiesAPI::MediaCapabilities>(realm());
diff --git a/Libraries/LibWeb/HTML/Navigator.h b/Libraries/LibWeb/HTML/Navigator.h
index a9b1e116d73..2a72bcb8f70 100644
--- a/Libraries/LibWeb/HTML/Navigator.h
+++ b/Libraries/LibWeb/HTML/Navigator.h
@@ -30,10 +30,10 @@ class Navigator : public Bindings::PlatformObject
     , public NavigatorOnLineMixin
     , public StorageAPI::NavigatorStorage {
     WEB_PLATFORM_OBJECT(Navigator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Navigator);
+    GC_DECLARE_ALLOCATOR(Navigator);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Navigator> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Navigator> create(JS::Realm&);
 
     // FIXME: Implement NavigatorContentUtilsMixin
 
@@ -50,16 +50,16 @@ public:
 
     bool webdriver() const;
 
-    [[nodiscard]] JS::NonnullGCPtr<MimeTypeArray> mime_types();
-    [[nodiscard]] JS::NonnullGCPtr<PluginArray> plugins();
-    [[nodiscard]] JS::NonnullGCPtr<Clipboard::Clipboard> clipboard();
-    [[nodiscard]] JS::NonnullGCPtr<UserActivation> user_activation();
+    [[nodiscard]] GC::Ref<MimeTypeArray> mime_types();
+    [[nodiscard]] GC::Ref<PluginArray> plugins();
+    [[nodiscard]] GC::Ref<Clipboard::Clipboard> clipboard();
+    [[nodiscard]] GC::Ref<UserActivation> user_activation();
 
     Optional<FlyString> do_not_track() const;
 
-    JS::NonnullGCPtr<ServiceWorkerContainer> service_worker();
+    GC::Ref<ServiceWorkerContainer> service_worker();
 
-    JS::NonnullGCPtr<MediaCapabilitiesAPI::MediaCapabilities> media_capabilities();
+    GC::Ref<MediaCapabilitiesAPI::MediaCapabilities> media_capabilities();
 
     static WebIDL::Long max_touch_points();
 
@@ -76,20 +76,20 @@ private:
     // ^StorageAPI::NavigatorStorage
     virtual Bindings::PlatformObject const& this_navigator_storage_object() const override { return *this; }
 
-    JS::GCPtr<PluginArray> m_plugin_array;
-    JS::GCPtr<MimeTypeArray> m_mime_type_array;
+    GC::Ptr<PluginArray> m_plugin_array;
+    GC::Ptr<MimeTypeArray> m_mime_type_array;
 
     // https://w3c.github.io/clipboard-apis/#dom-navigator-clipboard
-    JS::GCPtr<Clipboard::Clipboard> m_clipboard;
+    GC::Ptr<Clipboard::Clipboard> m_clipboard;
 
     // https://html.spec.whatwg.org/multipage/interaction.html#dom-navigator-useractivation
-    JS::GCPtr<UserActivation> m_user_activation;
+    GC::Ptr<UserActivation> m_user_activation;
 
     // https://w3c.github.io/ServiceWorker/#navigator-serviceworker
-    JS::GCPtr<ServiceWorkerContainer> m_service_worker_container;
+    GC::Ptr<ServiceWorkerContainer> m_service_worker_container;
 
     // https://w3c.github.io/media-capabilities/#dom-navigator-mediacapabilities
-    JS::GCPtr<MediaCapabilitiesAPI::MediaCapabilities> m_media_capabilities;
+    GC::Ptr<MediaCapabilitiesAPI::MediaCapabilities> m_media_capabilities;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/NavigatorBeacon.cpp b/Libraries/LibWeb/HTML/NavigatorBeacon.cpp
index a34fbfbb5d2..e753748b78c 100644
--- a/Libraries/LibWeb/HTML/NavigatorBeacon.cpp
+++ b/Libraries/LibWeb/HTML/NavigatorBeacon.cpp
@@ -44,7 +44,7 @@ WebIDL::ExceptionOr<bool> NavigatorBeaconMixin::send_beacon(String const& url, O
     auto cors_mode = Fetch::Infrastructure::Request::Mode::NoCORS;
 
     // 6. If data is not null:
-    JS::GCPtr<Fetch::Infrastructure::Body> transmitted_data;
+    GC::Ptr<Fetch::Infrastructure::Body> transmitted_data;
     if (data.has_value()) {
         // 6.1 Set transmittedData and contentType to the result of extracting data's byte stream with the keepalive flag set.
         auto body_with_type = TRY(Fetch::extract_body(realm, data.value(), true));
@@ -81,10 +81,10 @@ WebIDL::ExceptionOr<bool> NavigatorBeaconMixin::send_beacon(String const& url, O
     req->set_origin(origin);                                   // origin: origin
     req->set_keepalive(true);                                  // keepalive: true
     if (transmitted_data)
-        req->set_body(JS::NonnullGCPtr<Fetch::Infrastructure::Body> { *transmitted_data }); // body: transmittedData
-    req->set_mode(cors_mode);                                                               // mode: corsMode
-    req->set_credentials_mode(Fetch::Infrastructure::Request::CredentialsMode::Include);    // credentials mode: include
-    req->set_initiator_type(Fetch::Infrastructure::Request::InitiatorType::Beacon);         // initiator type: "beacon"
+        req->set_body(GC::Ref<Fetch::Infrastructure::Body> { *transmitted_data });       // body: transmittedData
+    req->set_mode(cors_mode);                                                            // mode: corsMode
+    req->set_credentials_mode(Fetch::Infrastructure::Request::CredentialsMode::Include); // credentials mode: include
+    req->set_initiator_type(Fetch::Infrastructure::Request::InitiatorType::Beacon);      // initiator type: "beacon"
 
     // 7.2 Fetch req.
     (void)Fetch::Fetching::fetch(realm, req, Fetch::Infrastructure::FetchAlgorithms::create(vm, {}));
diff --git a/Libraries/LibWeb/HTML/PageSwapEvent.idl b/Libraries/LibWeb/HTML/PageSwapEvent.idl
new file mode 100644
index 00000000000..125e49276ac
--- /dev/null
+++ b/Libraries/LibWeb/HTML/PageSwapEvent.idl
@@ -0,0 +1,11 @@
+[Exposed=Window]
+interface PageSwapEvent : Event {
+    constructor(DOMString type, optional PageSwapEventInit eventInitDict = {});
+    readonly attribute NavigationActivation? activation;
+    readonly attribute ViewTransition? viewTransition;
+};
+
+dictionary PageSwapEventInit : EventInit {
+    NavigationActivation? activation = null;
+    ViewTransition? viewTransition = null;
+};
diff --git a/Libraries/LibWeb/HTML/PageTransitionEvent.cpp b/Libraries/LibWeb/HTML/PageTransitionEvent.cpp
index b2dc94c0a16..dcc31e266c3 100644
--- a/Libraries/LibWeb/HTML/PageTransitionEvent.cpp
+++ b/Libraries/LibWeb/HTML/PageTransitionEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(PageTransitionEvent);
+GC_DEFINE_ALLOCATOR(PageTransitionEvent);
 
-JS::NonnullGCPtr<PageTransitionEvent> PageTransitionEvent::create(JS::Realm& realm, FlyString const& event_name, PageTransitionEventInit const& event_init)
+GC::Ref<PageTransitionEvent> PageTransitionEvent::create(JS::Realm& realm, FlyString const& event_name, PageTransitionEventInit const& event_init)
 {
     return realm.create<PageTransitionEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PageTransitionEvent>> PageTransitionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PageTransitionEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<PageTransitionEvent>> PageTransitionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PageTransitionEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/PageTransitionEvent.h b/Libraries/LibWeb/HTML/PageTransitionEvent.h
index effacb7c2a1..f1797bd9bad 100644
--- a/Libraries/LibWeb/HTML/PageTransitionEvent.h
+++ b/Libraries/LibWeb/HTML/PageTransitionEvent.h
@@ -17,11 +17,11 @@ struct PageTransitionEventInit : public DOM::EventInit {
 
 class PageTransitionEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(PageTransitionEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(PageTransitionEvent);
+    GC_DECLARE_ALLOCATOR(PageTransitionEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<PageTransitionEvent> create(JS::Realm&, FlyString const& event_name, PageTransitionEventInit const&);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PageTransitionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, PageTransitionEventInit const&);
+    [[nodiscard]] static GC::Ref<PageTransitionEvent> create(JS::Realm&, FlyString const& event_name, PageTransitionEventInit const&);
+    static WebIDL::ExceptionOr<GC::Ref<PageTransitionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, PageTransitionEventInit const&);
 
     PageTransitionEvent(JS::Realm&, FlyString const& event_name, PageTransitionEventInit const& event_init);
 
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.cpp b/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.cpp
index b7bdd694c58..67568045b6d 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.cpp
+++ b/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.cpp
@@ -95,7 +95,7 @@ Optional<StringView> extract_character_encoding_from_meta_element(ByteString con
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#concept-get-attributes-when-sniffing
-JS::GCPtr<DOM::Attr> prescan_get_attribute(DOM::Document& document, ByteBuffer const& input, size_t& position)
+GC::Ptr<DOM::Attr> prescan_get_attribute(DOM::Document& document, ByteBuffer const& input, size_t& position)
 {
     // 1. If the byte at position is one of 0x09 (HT), 0x0A (LF), 0x0C (FF), 0x0D (CR), 0x20 (SP), or 0x2F (/) then advance position to the next byte and redo this step.
     if (!prescan_skip_whitespace_and_slashes(input, position))
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.h b/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.h
index e54ec048e38..94f19d7043d 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.h
+++ b/Libraries/LibWeb/HTML/Parser/HTMLEncodingDetection.h
@@ -8,7 +8,7 @@
 
 #include <AK/ByteString.h>
 #include <AK/Optional.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
@@ -17,7 +17,7 @@ bool prescan_should_abort(ByteBuffer const& input, size_t const& position);
 bool prescan_is_whitespace_or_slash(u8 const& byte);
 bool prescan_skip_whitespace_and_slashes(ByteBuffer const& input, size_t& position);
 Optional<StringView> extract_character_encoding_from_meta_element(ByteString const&);
-JS::GCPtr<DOM::Attr> prescan_get_attribute(DOM::Document&, ByteBuffer const& input, size_t& position);
+GC::Ptr<DOM::Attr> prescan_get_attribute(DOM::Document&, ByteBuffer const& input, size_t& position);
 Optional<ByteString> run_prescan_byte_stream_algorithm(DOM::Document&, ByteBuffer const& input);
 Optional<ByteString> run_bom_sniff(ByteBuffer const& input);
 ByteString run_encoding_sniffing_algorithm(DOM::Document&, ByteBuffer const& input, Optional<MimeSniff::MimeType> maybe_mime_type = {});
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp b/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
index 6c74bd4679b..c14add5ef36 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
+++ b/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp
@@ -48,7 +48,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(HTMLParser);
+GC_DEFINE_ALLOCATOR(HTMLParser);
 
 static inline void log_parse_error(SourceLocation const& location = SourceLocation::current())
 {
@@ -246,7 +246,7 @@ void HTMLParser::run(const URL::URL& url, HTMLTokenizer::StopAtInsertionPoint st
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-end
-void HTMLParser::the_end(JS::NonnullGCPtr<DOM::Document> document, JS::GCPtr<HTMLParser> parser)
+void HTMLParser::the_end(GC::Ref<DOM::Document> document, GC::Ptr<HTMLParser> parser)
 {
     auto& heap = document->heap();
 
@@ -300,7 +300,7 @@ void HTMLParser::the_end(JS::NonnullGCPtr<DOM::Document> document, JS::GCPtr<HTM
     while (!document->scripts_to_execute_when_parsing_has_finished().is_empty()) {
         // 1. Spin the event loop until the first script in the list of scripts that will execute when the document has finished parsing
         //    has its "ready to be parser-executed" flag set and the parser's Document has no style sheet that is blocking scripts.
-        main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+        main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
             return document->scripts_to_execute_when_parsing_has_finished().first()->is_ready_to_be_parser_executed()
                 && !document->has_a_style_sheet_that_is_blocking_scripts();
         }));
@@ -313,7 +313,7 @@ void HTMLParser::the_end(JS::NonnullGCPtr<DOM::Document> document, JS::GCPtr<HTM
     }
 
     // 6. Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following substeps:
-    queue_global_task(HTML::Task::Source::DOMManipulation, *document, JS::create_heap_function(heap, [document = document] {
+    queue_global_task(HTML::Task::Source::DOMManipulation, *document, GC::create_function(heap, [document = document] {
         // 1. Set the Document's load timing info's DOM content loaded event start time to the current high resolution time given the Document's relevant global object.
         document->load_timing_info().dom_content_loaded_event_start_time = HighResolutionTime::current_high_resolution_time(relevant_global_object(*document));
 
@@ -331,17 +331,17 @@ void HTMLParser::the_end(JS::NonnullGCPtr<DOM::Document> document, JS::GCPtr<HTM
     }));
 
     // 7. Spin the event loop until the set of scripts that will execute as soon as possible and the list of scripts that will execute in order as soon as possible are empty.
-    main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+    main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
         return document->scripts_to_execute_as_soon_as_possible().is_empty();
     }));
 
     // 8. Spin the event loop until there is nothing that delays the load event in the Document.
-    main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+    main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
         return !document->anything_is_delaying_the_load_event();
     }));
 
     // 9. Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following steps:
-    queue_global_task(HTML::Task::Source::DOMManipulation, *document, JS::create_heap_function(document->heap(), [document = document] {
+    queue_global_task(HTML::Task::Source::DOMManipulation, *document, GC::create_function(document->heap(), [document = document] {
         // 1. Update the current document readiness to "complete".
         document->update_readiness(HTML::DocumentReadyState::Complete);
 
@@ -610,7 +610,7 @@ AnythingElse:
     return;
 }
 
-JS::GCPtr<DOM::Element> HTMLParser::current_node()
+GC::Ptr<DOM::Element> HTMLParser::current_node()
 {
     if (m_stack_of_open_elements.is_empty())
         return nullptr;
@@ -618,7 +618,7 @@ JS::GCPtr<DOM::Element> HTMLParser::current_node()
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#adjusted-current-node
-JS::GCPtr<DOM::Element> HTMLParser::adjusted_current_node()
+GC::Ptr<DOM::Element> HTMLParser::adjusted_current_node()
 {
     // The adjusted current node is the context element if the parser was created as part of the
     // HTML fragment parsing algorithm and the stack of open elements has only one element in it
@@ -630,7 +630,7 @@ JS::GCPtr<DOM::Element> HTMLParser::adjusted_current_node()
     return current_node();
 }
 
-JS::GCPtr<DOM::Element> HTMLParser::node_before_current_node()
+GC::Ptr<DOM::Element> HTMLParser::node_before_current_node()
 {
     if (m_stack_of_open_elements.elements().size() < 2)
         return nullptr;
@@ -638,7 +638,7 @@ JS::GCPtr<DOM::Element> HTMLParser::node_before_current_node()
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#appropriate-place-for-inserting-a-node
-HTMLParser::AdjustedInsertionLocation HTMLParser::find_appropriate_place_for_inserting_node(JS::GCPtr<DOM::Element> override_target)
+HTMLParser::AdjustedInsertionLocation HTMLParser::find_appropriate_place_for_inserting_node(GC::Ptr<DOM::Element> override_target)
 {
     // 1. If there was an override target specified, then let target be the override target.
     auto& target = override_target ? *override_target.ptr() : *current_node();
@@ -694,13 +694,13 @@ HTMLParser::AdjustedInsertionLocation HTMLParser::find_appropriate_place_for_ins
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#create-an-element-for-the-token
-JS::NonnullGCPtr<DOM::Element> HTMLParser::create_element_for(HTMLToken const& token, Optional<FlyString> const& namespace_, DOM::Node& intended_parent)
+GC::Ref<DOM::Element> HTMLParser::create_element_for(HTMLToken const& token, Optional<FlyString> const& namespace_, DOM::Node& intended_parent)
 {
     // FIXME: 1. If the active speculative HTML parser is not null, then return the result of creating a speculative mock element given given namespace, the tag name of the given token, and the attributes of the given token.
     // FIXME: 2. Otherwise, optionally create a speculative mock element given given namespace, the tag name of the given token, and the attributes of the given token.
 
     // 3. Let document be intended parent's node document.
-    JS::NonnullGCPtr<DOM::Document> document = intended_parent.document();
+    GC::Ref<DOM::Document> document = intended_parent.document();
 
     // 4. Let local name be the tag name of the token.
     auto const& local_name = token.tag_name();
@@ -784,7 +784,7 @@ JS::NonnullGCPtr<DOM::Element> HTMLParser::create_element_for(HTMLToken const& t
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#insert-a-foreign-element
-JS::NonnullGCPtr<DOM::Element> HTMLParser::insert_foreign_element(HTMLToken const& token, Optional<FlyString> const& namespace_, OnlyAddToElementStack only_add_to_element_stack)
+GC::Ref<DOM::Element> HTMLParser::insert_foreign_element(HTMLToken const& token, Optional<FlyString> const& namespace_, OnlyAddToElementStack only_add_to_element_stack)
 {
     // 1. Let the adjusted insertion location be the appropriate place for inserting a node.
     auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
@@ -805,7 +805,7 @@ JS::NonnullGCPtr<DOM::Element> HTMLParser::insert_foreign_element(HTMLToken cons
     return element;
 }
 
-JS::NonnullGCPtr<DOM::Element> HTMLParser::insert_html_element(HTMLToken const& token)
+GC::Ref<DOM::Element> HTMLParser::insert_html_element(HTMLToken const& token)
 {
     return insert_foreign_element(token, Namespace::HTML, OnlyAddToElementStack::No);
 }
@@ -1487,7 +1487,7 @@ HTMLParser::AdoptionAgencyAlgorithmOutcome HTMLParser::run_the_adoption_agency_a
 
         // 7. Let furthest block be the topmost node in the stack of open elements that is lower in the stack than formatting element,
         //    and is an element in the special category. There might not be one.
-        JS::GCPtr<DOM::Element> furthest_block = m_stack_of_open_elements.topmost_special_node_below(*formatting_element);
+        GC::Ptr<DOM::Element> furthest_block = m_stack_of_open_elements.topmost_special_node_below(*formatting_element);
 
         // 8. If there is no furthest block
         if (!furthest_block) {
@@ -2011,7 +2011,7 @@ void HTMLParser::handle_in_body(HTMLToken& token)
         // 2. Initialize node to be the current node (the bottommost node of the stack).
         // 3. Loop: If node is an li element, then run these substeps:
         for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
-            JS::GCPtr<DOM::Element> node = m_stack_of_open_elements.elements()[i].ptr();
+            GC::Ptr<DOM::Element> node = m_stack_of_open_elements.elements()[i].ptr();
             if (node->local_name() == HTML::TagNames::li) {
                 // 1. Generate implied end tags, except for li elements.
                 generate_implied_end_tags(HTML::TagNames::li);
@@ -2054,7 +2054,7 @@ void HTMLParser::handle_in_body(HTMLToken& token)
         // 4. If node is a dt element, then run these substeps:
         for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
             // 1. Generate implied end tags, except for dd elements.
-            JS::GCPtr<DOM::Element> node = m_stack_of_open_elements.elements()[i].ptr();
+            GC::Ptr<DOM::Element> node = m_stack_of_open_elements.elements()[i].ptr();
             if (node->local_name() == HTML::TagNames::dd) {
                 generate_implied_end_tags(HTML::TagNames::dd);
                 // 2. If the current node is not a dd element, then this is a parse error.
@@ -2707,7 +2707,7 @@ void HTMLParser::handle_in_body(HTMLToken& token)
     if (token.is_end_tag()) {
     AnyOtherEndTag:
         // 1. Initialize node to be the current node (the bottommost node of the stack).
-        JS::GCPtr<DOM::Element> node;
+        GC::Ptr<DOM::Element> node;
 
         // 2. Loop: If node is an HTML element with the same tag name as the token, then:
         for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
@@ -2943,7 +2943,7 @@ void HTMLParser::handle_text(HTMLToken& token)
             perform_a_microtask_checkpoint();
 
         // Let script be the current node (which will be a script element).
-        JS::NonnullGCPtr<HTMLScriptElement> script = verify_cast<HTMLScriptElement>(*current_node());
+        GC::Ref<HTMLScriptElement> script = verify_cast<HTMLScriptElement>(*current_node());
 
         // Pop the current node off the stack of open elements.
         (void)m_stack_of_open_elements.pop();
@@ -3005,7 +3005,7 @@ void HTMLParser::handle_text(HTMLToken& token)
                     if (m_document->has_a_style_sheet_that_is_blocking_scripts() || the_script->is_ready_to_be_parser_executed() == false) {
                         // spin the event loop until the parser's Document has no style sheet that is blocking scripts
                         // and the script's ready to be parser-executed becomes true.
-                        main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] {
+                        main_thread_event_loop().spin_until(GC::create_function(heap(), [&] {
                             return !m_document->has_a_style_sheet_that_is_blocking_scripts() && the_script->is_ready_to_be_parser_executed();
                         }));
                     }
@@ -4265,7 +4265,7 @@ void HTMLParser::process_using_the_rules_for_foreign_content(HTMLToken& token)
     // -> Any other end tag
     if (token.is_end_tag()) {
         // 1. Initialize node to be the current node (the bottommost node of the stack).
-        JS::GCPtr<DOM::Element> node = current_node();
+        GC::Ptr<DOM::Element> node = current_node();
 
         // 2. If node's tag name, converted to ASCII lowercase, is not the same as the tag name of the token, then this is a parse error.
         if (node->tag_name().equals_ignoring_ascii_case(token.tag_name()))
@@ -4309,7 +4309,7 @@ void HTMLParser::reset_the_insertion_mode_appropriately()
     for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
         bool last = i == 0;
         // NOTE: When parsing fragments, we substitute the context element for the root of the stack of open elements.
-        JS::GCPtr<DOM::Element> node;
+        GC::Ptr<DOM::Element> node;
         if (last && m_parsing_fragment) {
             node = m_context_element.ptr();
         } else {
@@ -4423,7 +4423,7 @@ DOM::Document& HTMLParser::document()
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
-Vector<JS::Handle<DOM::Node>> HTMLParser::parse_html_fragment(DOM::Element& context_element, StringView markup, AllowDeclarativeShadowRoots allow_declarative_shadow_roots)
+Vector<GC::Root<DOM::Node>> HTMLParser::parse_html_fragment(DOM::Element& context_element, StringView markup, AllowDeclarativeShadowRoots allow_declarative_shadow_roots)
 {
     // 1. Create a new Document node, and mark it as being an HTML document.
     auto temp_document = DOM::Document::create_for_fragment_parsing(context_element.realm());
@@ -4515,21 +4515,21 @@ Vector<JS::Handle<DOM::Node>> HTMLParser::parse_html_fragment(DOM::Element& cont
     parser->run(context_element.document().url());
 
     // 15. Return the child nodes of root, in tree order.
-    Vector<JS::Handle<DOM::Node>> children;
-    while (JS::GCPtr<DOM::Node> child = root->first_child()) {
+    Vector<GC::Root<DOM::Node>> children;
+    while (GC::Ptr<DOM::Node> child = root->first_child()) {
         MUST(root->remove_child(*child));
         context_element.document().adopt_node(*child);
-        children.append(JS::make_handle(*child));
+        children.append(GC::make_root(*child));
     }
     return children;
 }
 
-JS::NonnullGCPtr<HTMLParser> HTMLParser::create_for_scripting(DOM::Document& document)
+GC::Ref<HTMLParser> HTMLParser::create_for_scripting(DOM::Document& document)
 {
     return document.heap().allocate<HTMLParser>(document);
 }
 
-JS::NonnullGCPtr<HTMLParser> HTMLParser::create_with_uncertain_encoding(DOM::Document& document, ByteBuffer const& input, Optional<MimeSniff::MimeType> maybe_mime_type)
+GC::Ref<HTMLParser> HTMLParser::create_with_uncertain_encoding(DOM::Document& document, ByteBuffer const& input, Optional<MimeSniff::MimeType> maybe_mime_type)
 {
     if (document.has_encoding())
         return document.heap().allocate<HTMLParser>(document, input, document.encoding().value().to_byte_string());
@@ -4538,7 +4538,7 @@ JS::NonnullGCPtr<HTMLParser> HTMLParser::create_with_uncertain_encoding(DOM::Doc
     return document.heap().allocate<HTMLParser>(document, input, encoding);
 }
 
-JS::NonnullGCPtr<HTMLParser> HTMLParser::create(DOM::Document& document, StringView input, StringView encoding)
+GC::Ref<HTMLParser> HTMLParser::create(DOM::Document& document, StringView input, StringView encoding)
 {
     return document.heap().allocate<HTMLParser>(document, input, encoding);
 }
@@ -4574,7 +4574,7 @@ static String escape_string(StringView string, AttributeMode attribute_mode)
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#html-fragment-serialisation-algorithm
-String HTMLParser::serialize_html_fragment(DOM::Node const& node, SerializableShadowRoots serializable_shadow_roots, Vector<JS::Handle<DOM::ShadowRoot>> const& shadow_roots, DOM::FragmentSerializationMode fragment_serialization_mode)
+String HTMLParser::serialize_html_fragment(DOM::Node const& node, SerializableShadowRoots serializable_shadow_roots, Vector<GC::Root<DOM::ShadowRoot>> const& shadow_roots, DOM::FragmentSerializationMode fragment_serialization_mode)
 {
     // NOTE: Steps in this function are jumbled a bit to accommodate the Element.outerHTML API.
     //       When called with FragmentSerializationMode::Outer, we will serialize the element itself,
@@ -4668,7 +4668,7 @@ String HTMLParser::serialize_html_fragment(DOM::Node const& node, SerializableSh
 
     // The algorithm takes as input a DOM Element, Document, or DocumentFragment referred to as the node.
     VERIFY(node.is_element() || node.is_document() || node.is_document_fragment());
-    JS::NonnullGCPtr<DOM::Node const> actual_node = node;
+    GC::Ref<DOM::Node const> actual_node = node;
 
     if (is<DOM::Element>(node)) {
         auto const& element = verify_cast<DOM::Element>(node);
@@ -5092,7 +5092,7 @@ void HTMLParser::abort()
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#insert-an-element-at-the-adjusted-insertion-location
-void HTMLParser::insert_an_element_at_the_adjusted_insertion_location(JS::NonnullGCPtr<DOM::Element> element)
+void HTMLParser::insert_an_element_at_the_adjusted_insertion_location(GC::Ref<DOM::Element> element)
 {
     // 1. Let the adjusted insertion location be the appropriate place for inserting a node.
     auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLParser.h b/Libraries/LibWeb/HTML/Parser/HTMLParser.h
index 270aae63e3f..387f800af4c 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLParser.h
+++ b/Libraries/LibWeb/HTML/Parser/HTMLParser.h
@@ -42,34 +42,34 @@ namespace Web::HTML {
     __ENUMERATE_INSERTION_MODE(AfterAfterFrameset)
 
 class HTMLParser final : public JS::Cell {
-    JS_CELL(HTMLParser, JS::Cell);
-    JS_DECLARE_ALLOCATOR(HTMLParser);
+    GC_CELL(HTMLParser, JS::Cell);
+    GC_DECLARE_ALLOCATOR(HTMLParser);
 
     friend class HTMLTokenizer;
 
 public:
     ~HTMLParser();
 
-    static JS::NonnullGCPtr<HTMLParser> create_for_scripting(DOM::Document&);
-    static JS::NonnullGCPtr<HTMLParser> create_with_uncertain_encoding(DOM::Document&, ByteBuffer const& input, Optional<MimeSniff::MimeType> maybe_mime_type = {});
-    static JS::NonnullGCPtr<HTMLParser> create(DOM::Document&, StringView input, StringView encoding);
+    static GC::Ref<HTMLParser> create_for_scripting(DOM::Document&);
+    static GC::Ref<HTMLParser> create_with_uncertain_encoding(DOM::Document&, ByteBuffer const& input, Optional<MimeSniff::MimeType> maybe_mime_type = {});
+    static GC::Ref<HTMLParser> create(DOM::Document&, StringView input, StringView encoding);
 
     void run(HTMLTokenizer::StopAtInsertionPoint = HTMLTokenizer::StopAtInsertionPoint::No);
     void run(const URL::URL&, HTMLTokenizer::StopAtInsertionPoint = HTMLTokenizer::StopAtInsertionPoint::No);
 
-    static void the_end(JS::NonnullGCPtr<DOM::Document>, JS::GCPtr<HTMLParser> = nullptr);
+    static void the_end(GC::Ref<DOM::Document>, GC::Ptr<HTMLParser> = nullptr);
 
     DOM::Document& document();
     enum class AllowDeclarativeShadowRoots {
         No,
         Yes,
     };
-    static Vector<JS::Handle<DOM::Node>> parse_html_fragment(DOM::Element& context_element, StringView, AllowDeclarativeShadowRoots = AllowDeclarativeShadowRoots::No);
+    static Vector<GC::Root<DOM::Node>> parse_html_fragment(DOM::Element& context_element, StringView, AllowDeclarativeShadowRoots = AllowDeclarativeShadowRoots::No);
     enum class SerializableShadowRoots {
         No,
         Yes,
     };
-    static String serialize_html_fragment(DOM::Node const&, SerializableShadowRoots, Vector<JS::Handle<DOM::ShadowRoot>> const&, DOM::FragmentSerializationMode = DOM::FragmentSerializationMode::Inner);
+    static String serialize_html_fragment(DOM::Node const&, SerializableShadowRoots, Vector<GC::Root<DOM::ShadowRoot>> const&, DOM::FragmentSerializationMode = DOM::FragmentSerializationMode::Inner);
 
     enum class InsertionMode {
 #define __ENUMERATE_INSERTION_MODE(mode) mode,
@@ -129,16 +129,16 @@ private:
 
     void generate_implied_end_tags(FlyString const& exception = {});
     void generate_all_implied_end_tags_thoroughly();
-    JS::NonnullGCPtr<DOM::Element> create_element_for(HTMLToken const&, Optional<FlyString> const& namespace_, DOM::Node& intended_parent);
+    GC::Ref<DOM::Element> create_element_for(HTMLToken const&, Optional<FlyString> const& namespace_, DOM::Node& intended_parent);
 
     struct AdjustedInsertionLocation {
-        JS::GCPtr<DOM::Node> parent;
-        JS::GCPtr<DOM::Node> insert_before_sibling;
+        GC::Ptr<DOM::Node> parent;
+        GC::Ptr<DOM::Node> insert_before_sibling;
     };
 
-    AdjustedInsertionLocation find_appropriate_place_for_inserting_node(JS::GCPtr<DOM::Element> override_target = nullptr);
+    AdjustedInsertionLocation find_appropriate_place_for_inserting_node(GC::Ptr<DOM::Element> override_target = nullptr);
 
-    void insert_an_element_at_the_adjusted_insertion_location(JS::NonnullGCPtr<DOM::Element>);
+    void insert_an_element_at_the_adjusted_insertion_location(GC::Ref<DOM::Element>);
 
     DOM::Text* find_character_insertion_node();
     void flush_character_insertions();
@@ -146,11 +146,11 @@ private:
         No,
         Yes,
     };
-    JS::NonnullGCPtr<DOM::Element> insert_foreign_element(HTMLToken const&, Optional<FlyString> const& namespace_, OnlyAddToElementStack);
-    JS::NonnullGCPtr<DOM::Element> insert_html_element(HTMLToken const&);
-    [[nodiscard]] JS::GCPtr<DOM::Element> current_node();
-    [[nodiscard]] JS::GCPtr<DOM::Element> adjusted_current_node();
-    [[nodiscard]] JS::GCPtr<DOM::Element> node_before_current_node();
+    GC::Ref<DOM::Element> insert_foreign_element(HTMLToken const&, Optional<FlyString> const& namespace_, OnlyAddToElementStack);
+    GC::Ref<DOM::Element> insert_html_element(HTMLToken const&);
+    [[nodiscard]] GC::Ptr<DOM::Element> current_node();
+    [[nodiscard]] GC::Ptr<DOM::Element> adjusted_current_node();
+    [[nodiscard]] GC::Ptr<DOM::Element> node_before_current_node();
     void insert_character(u32 data);
     void insert_comment(HTMLToken&);
     void reconstruct_the_active_formatting_elements();
@@ -203,14 +203,14 @@ private:
 
     JS::Realm& realm();
 
-    JS::GCPtr<DOM::Document> m_document;
-    JS::GCPtr<HTMLHeadElement> m_head_element;
-    JS::GCPtr<HTMLFormElement> m_form_element;
-    JS::GCPtr<DOM::Element> m_context_element;
+    GC::Ptr<DOM::Document> m_document;
+    GC::Ptr<HTMLHeadElement> m_head_element;
+    GC::Ptr<HTMLFormElement> m_form_element;
+    GC::Ptr<DOM::Element> m_context_element;
 
     Vector<HTMLToken> m_pending_table_character_tokens;
 
-    JS::GCPtr<DOM::Text> m_character_insertion_node;
+    GC::Ptr<DOM::Text> m_character_insertion_node;
     StringBuilder m_character_insertion_builder;
 };
 
diff --git a/Libraries/LibWeb/HTML/Parser/HTMLTokenizer.h b/Libraries/LibWeb/HTML/Parser/HTMLTokenizer.h
index 9ccb2315a7c..46bd97f1894 100644
--- a/Libraries/LibWeb/HTML/Parser/HTMLTokenizer.h
+++ b/Libraries/LibWeb/HTML/Parser/HTMLTokenizer.h
@@ -12,7 +12,7 @@
 #include <AK/StringView.h>
 #include <AK/Types.h>
 #include <AK/Utf8View.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/Parser/HTMLToken.h>
 
@@ -181,7 +181,7 @@ private:
     void restore_to(Utf8CodePointIterator const& new_iterator);
     HTMLToken::Position nth_last_position(size_t n = 0);
 
-    JS::GCPtr<HTMLParser> m_parser;
+    GC::Ptr<HTMLParser> m_parser;
 
     State m_state { State::Data };
     State m_return_state { State::Data };
diff --git a/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.cpp b/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.cpp
index 90c24ad6440..342467a59c8 100644
--- a/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.cpp
+++ b/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.cpp
@@ -78,7 +78,7 @@ void ListOfActiveFormattingElements::replace(DOM::Element& to_remove, DOM::Eleme
 {
     for (size_t i = 0; i < m_entries.size(); i++) {
         if (m_entries[i].element.ptr() == &to_remove)
-            m_entries[i].element = JS::make_handle(to_add);
+            m_entries[i].element = GC::make_root(to_add);
     }
 }
 
diff --git a/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.h b/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.h
index 9f99a711776..5dd56af00dd 100644
--- a/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.h
+++ b/Libraries/LibWeb/HTML/Parser/ListOfActiveFormattingElements.h
@@ -19,7 +19,7 @@ public:
     struct Entry {
         bool is_marker() const { return !element; }
 
-        JS::GCPtr<DOM::Element> element;
+        GC::Ptr<DOM::Element> element;
     };
 
     bool is_empty() const { return m_entries.is_empty(); }
diff --git a/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.cpp b/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.cpp
index d2ee6958a65..c01022081a3 100644
--- a/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.cpp
+++ b/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.cpp
@@ -124,9 +124,9 @@ void StackOfOpenElements::pop_until_an_element_with_tag_name_has_been_popped(Fly
     (void)pop();
 }
 
-JS::GCPtr<DOM::Element> StackOfOpenElements::topmost_special_node_below(DOM::Element const& formatting_element)
+GC::Ptr<DOM::Element> StackOfOpenElements::topmost_special_node_below(DOM::Element const& formatting_element)
 {
-    JS::GCPtr<DOM::Element> found_element = nullptr;
+    GC::Ptr<DOM::Element> found_element = nullptr;
     for (auto& element : m_elements.in_reverse()) {
         if (element.ptr() == &formatting_element)
             break;
@@ -146,7 +146,7 @@ StackOfOpenElements::LastElementResult StackOfOpenElements::last_element_with_ta
     return { nullptr, -1 };
 }
 
-JS::GCPtr<DOM::Element> StackOfOpenElements::element_immediately_above(DOM::Element const& target)
+GC::Ptr<DOM::Element> StackOfOpenElements::element_immediately_above(DOM::Element const& target)
 {
     bool found_target = false;
     for (auto& element : m_elements.in_reverse()) {
@@ -165,7 +165,7 @@ void StackOfOpenElements::remove(DOM::Element const& element)
     });
 }
 
-void StackOfOpenElements::replace(DOM::Element const& to_remove, JS::NonnullGCPtr<DOM::Element> to_add)
+void StackOfOpenElements::replace(DOM::Element const& to_remove, GC::Ref<DOM::Element> to_add)
 {
     for (size_t i = 0; i < m_elements.size(); i++) {
         if (m_elements[i].ptr() == &to_remove) {
@@ -176,7 +176,7 @@ void StackOfOpenElements::replace(DOM::Element const& to_remove, JS::NonnullGCPt
     }
 }
 
-void StackOfOpenElements::insert_immediately_below(JS::NonnullGCPtr<DOM::Element> element_to_add, DOM::Element const& target)
+void StackOfOpenElements::insert_immediately_below(GC::Ref<DOM::Element> element_to_add, DOM::Element const& target)
 {
     for (size_t i = 0; i < m_elements.size(); i++) {
         if (m_elements[i].ptr() == &target) {
diff --git a/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.h b/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.h
index 7cf1fa1041d..540a6224e63 100644
--- a/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.h
+++ b/Libraries/LibWeb/HTML/Parser/StackOfOpenElements.h
@@ -26,11 +26,11 @@ public:
     DOM::Element& last() { return *m_elements.last(); }
 
     bool is_empty() const { return m_elements.is_empty(); }
-    void push(JS::NonnullGCPtr<DOM::Element> element) { m_elements.append(element); }
-    JS::NonnullGCPtr<DOM::Element> pop() { return *m_elements.take_last(); }
+    void push(GC::Ref<DOM::Element> element) { m_elements.append(element); }
+    GC::Ref<DOM::Element> pop() { return *m_elements.take_last(); }
     void remove(DOM::Element const& element);
-    void replace(DOM::Element const& to_remove, JS::NonnullGCPtr<DOM::Element> to_add);
-    void insert_immediately_below(JS::NonnullGCPtr<DOM::Element> element_to_add, DOM::Element const& target);
+    void replace(DOM::Element const& to_remove, GC::Ref<DOM::Element> to_add);
+    void insert_immediately_below(GC::Ref<DOM::Element> element_to_add, DOM::Element const& target);
 
     const DOM::Element& current_node() const { return *m_elements.last(); }
     DOM::Element& current_node() { return *m_elements.last(); }
@@ -51,14 +51,14 @@ public:
 
     void pop_until_an_element_with_tag_name_has_been_popped(FlyString const& local_name);
 
-    JS::GCPtr<DOM::Element> topmost_special_node_below(DOM::Element const&);
+    GC::Ptr<DOM::Element> topmost_special_node_below(DOM::Element const&);
 
     struct LastElementResult {
-        JS::GCPtr<DOM::Element> element;
+        GC::Ptr<DOM::Element> element;
         ssize_t index;
     };
     LastElementResult last_element_with_tag_name(FlyString const&);
-    JS::GCPtr<DOM::Element> element_immediately_above(DOM::Element const&);
+    GC::Ptr<DOM::Element> element_immediately_above(DOM::Element const&);
 
     void visit_edges(JS::Cell::Visitor&);
 
@@ -66,7 +66,7 @@ private:
     bool has_in_scope_impl(FlyString const& tag_name, Vector<FlyString> const&) const;
     bool has_in_scope_impl(const DOM::Element& target_node, Vector<FlyString> const&) const;
 
-    Vector<JS::NonnullGCPtr<DOM::Element>> m_elements;
+    Vector<GC::Ref<DOM::Element>> m_elements;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Path2D.cpp b/Libraries/LibWeb/HTML/Path2D.cpp
index 69e05631318..b5dab6fa1dd 100644
--- a/Libraries/LibWeb/HTML/Path2D.cpp
+++ b/Libraries/LibWeb/HTML/Path2D.cpp
@@ -15,15 +15,15 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Path2D);
+GC_DEFINE_ALLOCATOR(Path2D);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Path2D>> Path2D::construct_impl(JS::Realm& realm, Optional<Variant<JS::Handle<Path2D>, String>> const& path)
+WebIDL::ExceptionOr<GC::Ref<Path2D>> Path2D::construct_impl(JS::Realm& realm, Optional<Variant<GC::Root<Path2D>, String>> const& path)
 {
     return realm.create<Path2D>(realm, path);
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-path2d
-Path2D::Path2D(JS::Realm& realm, Optional<Variant<JS::Handle<Path2D>, String>> const& path)
+Path2D::Path2D(JS::Realm& realm, Optional<Variant<GC::Root<Path2D>, String>> const& path)
     : PlatformObject(realm)
     , CanvasPath(static_cast<Bindings::PlatformObject&>(*this))
 {
@@ -34,8 +34,8 @@ Path2D::Path2D(JS::Realm& realm, Optional<Variant<JS::Handle<Path2D>, String>> c
 
     // 3. If path is a Path2D object, then add all subpaths of path to output and return output.
     //    (In other words, it returns a copy of the argument.)
-    if (path->has<JS::Handle<Path2D>>()) {
-        this->path() = path->get<JS::Handle<Path2D>>()->path();
+    if (path->has<GC::Root<Path2D>>()) {
+        this->path() = path->get<GC::Root<Path2D>>()->path();
         return;
     }
 
@@ -66,7 +66,7 @@ void Path2D::initialize(JS::Realm& realm)
 }
 
 // https://html.spec.whatwg.org/multipage/canvas.html#dom-path2d-addpath
-WebIDL::ExceptionOr<void> Path2D::add_path(JS::NonnullGCPtr<Path2D> path, Geometry::DOMMatrix2DInit& transform)
+WebIDL::ExceptionOr<void> Path2D::add_path(GC::Ref<Path2D> path, Geometry::DOMMatrix2DInit& transform)
 {
     // The addPath(path, transform) method, when invoked on a Path2D object a, must run these steps:
 
diff --git a/Libraries/LibWeb/HTML/Path2D.h b/Libraries/LibWeb/HTML/Path2D.h
index b89865f7585..6b59e944354 100644
--- a/Libraries/LibWeb/HTML/Path2D.h
+++ b/Libraries/LibWeb/HTML/Path2D.h
@@ -20,17 +20,17 @@ class Path2D final
     , public CanvasPath {
 
     WEB_PLATFORM_OBJECT(Path2D, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Path2D);
+    GC_DECLARE_ALLOCATOR(Path2D);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Path2D>> construct_impl(JS::Realm&, Optional<Variant<JS::Handle<Path2D>, String>> const& path);
+    static WebIDL::ExceptionOr<GC::Ref<Path2D>> construct_impl(JS::Realm&, Optional<Variant<GC::Root<Path2D>, String>> const& path);
 
     virtual ~Path2D() override;
 
-    WebIDL::ExceptionOr<void> add_path(JS::NonnullGCPtr<Path2D> path, Geometry::DOMMatrix2DInit& transform);
+    WebIDL::ExceptionOr<void> add_path(GC::Ref<Path2D> path, Geometry::DOMMatrix2DInit& transform);
 
 private:
-    Path2D(JS::Realm&, Optional<Variant<JS::Handle<Path2D>, String>> const&);
+    Path2D(JS::Realm&, Optional<Variant<GC::Root<Path2D>, String>> const&);
 
     virtual void initialize(JS::Realm&) override;
 };
diff --git a/Libraries/LibWeb/HTML/Plugin.cpp b/Libraries/LibWeb/HTML/Plugin.cpp
index 458b9a8e6b6..93a64007761 100644
--- a/Libraries/LibWeb/HTML/Plugin.cpp
+++ b/Libraries/LibWeb/HTML/Plugin.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Plugin);
+GC_DEFINE_ALLOCATOR(Plugin);
 
 Plugin::Plugin(JS::Realm& realm, String name)
     : Bindings::PlatformObject(realm)
@@ -83,7 +83,7 @@ size_t Plugin::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-plugin-item
-JS::GCPtr<MimeType> Plugin::item(u32 index) const
+GC::Ptr<MimeType> Plugin::item(u32 index) const
 {
     // 1. Let mimeTypes be this's relevant global object's PDF viewer mime type objects.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
@@ -97,7 +97,7 @@ JS::GCPtr<MimeType> Plugin::item(u32 index) const
     return nullptr;
 }
 
-JS::GCPtr<MimeType> Plugin::named_item(FlyString const& name) const
+GC::Ptr<MimeType> Plugin::named_item(FlyString const& name) const
 {
     // 1. For each MimeType mimeType of this's relevant global object's PDF viewer mime type objects: if mimeType's type is name, then return mimeType.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
diff --git a/Libraries/LibWeb/HTML/Plugin.h b/Libraries/LibWeb/HTML/Plugin.h
index 3fc348c4d8a..bb10afe6cd8 100644
--- a/Libraries/LibWeb/HTML/Plugin.h
+++ b/Libraries/LibWeb/HTML/Plugin.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-plugin
 class Plugin : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Plugin, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Plugin);
+    GC_DECLARE_ALLOCATOR(Plugin);
 
 public:
     virtual ~Plugin() override;
@@ -22,8 +22,8 @@ public:
     String description() const;
     String filename() const;
     size_t length() const;
-    JS::GCPtr<MimeType> item(u32 index) const;
-    JS::GCPtr<MimeType> named_item(FlyString const& name) const;
+    GC::Ptr<MimeType> item(u32 index) const;
+    GC::Ptr<MimeType> named_item(FlyString const& name) const;
 
 private:
     Plugin(JS::Realm&, String name);
diff --git a/Libraries/LibWeb/HTML/PluginArray.cpp b/Libraries/LibWeb/HTML/PluginArray.cpp
index 7453d6e8e7c..133d2c69711 100644
--- a/Libraries/LibWeb/HTML/PluginArray.cpp
+++ b/Libraries/LibWeb/HTML/PluginArray.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(PluginArray);
+GC_DEFINE_ALLOCATOR(PluginArray);
 
 PluginArray::PluginArray(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -68,7 +68,7 @@ size_t PluginArray::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-pluginarray-item
-JS::GCPtr<Plugin> PluginArray::item(u32 index) const
+GC::Ptr<Plugin> PluginArray::item(u32 index) const
 {
     // 1. Let plugins be this's relevant global object's PDF viewer plugin objects.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
@@ -83,7 +83,7 @@ JS::GCPtr<Plugin> PluginArray::item(u32 index) const
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-pluginarray-nameditem
-JS::GCPtr<Plugin> PluginArray::named_item(FlyString const& name) const
+GC::Ptr<Plugin> PluginArray::named_item(FlyString const& name) const
 {
     // 1. For each Plugin plugin of this's relevant global object's PDF viewer plugin objects: if plugin's name is name, then return plugin.
     auto& window = verify_cast<HTML::Window>(HTML::relevant_global_object(*this));
diff --git a/Libraries/LibWeb/HTML/PluginArray.h b/Libraries/LibWeb/HTML/PluginArray.h
index dd5e37b1012..84bd5367e57 100644
--- a/Libraries/LibWeb/HTML/PluginArray.h
+++ b/Libraries/LibWeb/HTML/PluginArray.h
@@ -13,15 +13,15 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/system-state.html#pluginarray
 class PluginArray : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PluginArray, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PluginArray);
+    GC_DECLARE_ALLOCATOR(PluginArray);
 
 public:
     virtual ~PluginArray() override;
 
     void refresh() const;
     size_t length() const;
-    JS::GCPtr<Plugin> item(u32 index) const;
-    JS::GCPtr<Plugin> named_item(FlyString const& name) const;
+    GC::Ptr<Plugin> item(u32 index) const;
+    GC::Ptr<Plugin> named_item(FlyString const& name) const;
 
 private:
     PluginArray(JS::Realm&);
diff --git a/Libraries/LibWeb/HTML/PopStateEvent.cpp b/Libraries/LibWeb/HTML/PopStateEvent.cpp
index 0a29203bdc2..4d5ade2d067 100644
--- a/Libraries/LibWeb/HTML/PopStateEvent.cpp
+++ b/Libraries/LibWeb/HTML/PopStateEvent.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/PopStateEventPrototype.h>
@@ -12,14 +12,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(PopStateEvent);
+GC_DEFINE_ALLOCATOR(PopStateEvent);
 
-[[nodiscard]] JS::NonnullGCPtr<PopStateEvent> PopStateEvent::create(JS::Realm& realm, FlyString const& event_name, PopStateEventInit const& event_init)
+[[nodiscard]] GC::Ref<PopStateEvent> PopStateEvent::create(JS::Realm& realm, FlyString const& event_name, PopStateEventInit const& event_init)
 {
     return realm.create<PopStateEvent>(realm, event_name, event_init);
 }
 
-JS::NonnullGCPtr<PopStateEvent> PopStateEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PopStateEventInit const& event_init)
+GC::Ref<PopStateEvent> PopStateEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PopStateEventInit const& event_init)
 {
     return realm.create<PopStateEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/PopStateEvent.h b/Libraries/LibWeb/HTML/PopStateEvent.h
index 379c658331f..23b209e48c9 100644
--- a/Libraries/LibWeb/HTML/PopStateEvent.h
+++ b/Libraries/LibWeb/HTML/PopStateEvent.h
@@ -16,11 +16,11 @@ struct PopStateEventInit : public DOM::EventInit {
 
 class PopStateEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(PopStateEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(PopStateEvent);
+    GC_DECLARE_ALLOCATOR(PopStateEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<PopStateEvent> create(JS::Realm&, FlyString const& event_name, PopStateEventInit const&);
-    [[nodiscard]] static JS::NonnullGCPtr<PopStateEvent> construct_impl(JS::Realm&, FlyString const& event_name, PopStateEventInit const&);
+    [[nodiscard]] static GC::Ref<PopStateEvent> create(JS::Realm&, FlyString const& event_name, PopStateEventInit const&);
+    [[nodiscard]] static GC::Ref<PopStateEvent> construct_impl(JS::Realm&, FlyString const& event_name, PopStateEventInit const&);
 
     JS::Value const& state() const { return m_state; }
 
diff --git a/Libraries/LibWeb/HTML/PotentialCORSRequest.cpp b/Libraries/LibWeb/HTML/PotentialCORSRequest.cpp
index 7810b85a5cf..b00deb2e95a 100644
--- a/Libraries/LibWeb/HTML/PotentialCORSRequest.cpp
+++ b/Libraries/LibWeb/HTML/PotentialCORSRequest.cpp
@@ -10,7 +10,7 @@
 namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/urls-and-fetching.html#create-a-potential-cors-request
-JS::NonnullGCPtr<Fetch::Infrastructure::Request>
+GC::Ref<Fetch::Infrastructure::Request>
 create_potential_CORS_request(JS::VM& vm, URL::URL const& url, Optional<Fetch::Infrastructure::Request::Destination> destination, CORSSettingAttribute cors_attribute_state, SameOriginFallbackFlag same_origin_fallback_flag)
 {
     // 1. Let mode be "no-cors" if corsAttributeState is No CORS, and "cors" otherwise.
diff --git a/Libraries/LibWeb/HTML/PotentialCORSRequest.h b/Libraries/LibWeb/HTML/PotentialCORSRequest.h
index 20ec9197b88..14cd8f7e82f 100644
--- a/Libraries/LibWeb/HTML/PotentialCORSRequest.h
+++ b/Libraries/LibWeb/HTML/PotentialCORSRequest.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Fetch/Infrastructure/HTTP/Requests.h>
 #include <LibWeb/HTML/CORSSettingAttribute.h>
@@ -18,6 +18,6 @@ enum class SameOriginFallbackFlag {
     Yes,
 };
 
-[[nodiscard]] JS::NonnullGCPtr<Fetch::Infrastructure::Request> create_potential_CORS_request(JS::VM&, const URL::URL&, Optional<Fetch::Infrastructure::Request::Destination>, CORSSettingAttribute, SameOriginFallbackFlag = SameOriginFallbackFlag::No);
+[[nodiscard]] GC::Ref<Fetch::Infrastructure::Request> create_potential_CORS_request(JS::VM&, const URL::URL&, Optional<Fetch::Infrastructure::Request::Destination>, CORSSettingAttribute, SameOriginFallbackFlag = SameOriginFallbackFlag::No);
 
 }
diff --git a/Libraries/LibWeb/HTML/PromiseRejectionEvent.cpp b/Libraries/LibWeb/HTML/PromiseRejectionEvent.cpp
index c86ee4fc6a9..a50d1195345 100644
--- a/Libraries/LibWeb/HTML/PromiseRejectionEvent.cpp
+++ b/Libraries/LibWeb/HTML/PromiseRejectionEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(PromiseRejectionEvent);
+GC_DEFINE_ALLOCATOR(PromiseRejectionEvent);
 
-JS::NonnullGCPtr<PromiseRejectionEvent> PromiseRejectionEvent::create(JS::Realm& realm, FlyString const& event_name, PromiseRejectionEventInit const& event_init)
+GC::Ref<PromiseRejectionEvent> PromiseRejectionEvent::create(JS::Realm& realm, FlyString const& event_name, PromiseRejectionEventInit const& event_init)
 {
     return realm.create<PromiseRejectionEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PromiseRejectionEvent>> PromiseRejectionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PromiseRejectionEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<PromiseRejectionEvent>> PromiseRejectionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, PromiseRejectionEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/PromiseRejectionEvent.h b/Libraries/LibWeb/HTML/PromiseRejectionEvent.h
index b0c1ab856db..adc253b2d7f 100644
--- a/Libraries/LibWeb/HTML/PromiseRejectionEvent.h
+++ b/Libraries/LibWeb/HTML/PromiseRejectionEvent.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/FlyString.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibJS/Runtime/Promise.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWeb/DOM/Event.h>
@@ -16,17 +16,17 @@
 namespace Web::HTML {
 
 struct PromiseRejectionEventInit : public DOM::EventInit {
-    JS::Handle<JS::Object> promise;
+    GC::Root<JS::Object> promise;
     JS::Value reason;
 };
 
 class PromiseRejectionEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(PromiseRejectionEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(PromiseRejectionEvent);
+    GC_DECLARE_ALLOCATOR(PromiseRejectionEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<PromiseRejectionEvent> create(JS::Realm&, FlyString const& event_name, PromiseRejectionEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PromiseRejectionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, PromiseRejectionEventInit const&);
+    [[nodiscard]] static GC::Ref<PromiseRejectionEvent> create(JS::Realm&, FlyString const& event_name, PromiseRejectionEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<PromiseRejectionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, PromiseRejectionEventInit const&);
 
     virtual ~PromiseRejectionEvent() override;
 
@@ -40,7 +40,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<JS::Object> m_promise;
+    GC::Ref<JS::Object> m_promise;
     JS::Value m_reason;
 };
 
diff --git a/Libraries/LibWeb/HTML/RadioNodeList.cpp b/Libraries/LibWeb/HTML/RadioNodeList.cpp
index a8c97af6f32..4459cac6117 100644
--- a/Libraries/LibWeb/HTML/RadioNodeList.cpp
+++ b/Libraries/LibWeb/HTML/RadioNodeList.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(RadioNodeList);
+GC_DEFINE_ALLOCATOR(RadioNodeList);
 
-JS::NonnullGCPtr<RadioNodeList> RadioNodeList::create(JS::Realm& realm, DOM::Node const& root, Scope scope, Function<bool(DOM::Node const&)> filter)
+GC::Ref<RadioNodeList> RadioNodeList::create(JS::Realm& realm, DOM::Node const& root, Scope scope, Function<bool(DOM::Node const&)> filter)
 {
     return realm.create<RadioNodeList>(realm, root, scope, move(filter));
 }
diff --git a/Libraries/LibWeb/HTML/RadioNodeList.h b/Libraries/LibWeb/HTML/RadioNodeList.h
index c8e61ad8df9..bd05493fa16 100644
--- a/Libraries/LibWeb/HTML/RadioNodeList.h
+++ b/Libraries/LibWeb/HTML/RadioNodeList.h
@@ -13,10 +13,10 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#radionodelist
 class RadioNodeList : public DOM::LiveNodeList {
     WEB_PLATFORM_OBJECT(RadioNodeList, DOM::LiveNodeList);
-    JS_DECLARE_ALLOCATOR(RadioNodeList);
+    GC_DECLARE_ALLOCATOR(RadioNodeList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<RadioNodeList> create(JS::Realm& realm, DOM::Node const& root, Scope scope, ESCAPING Function<bool(DOM::Node const&)> filter);
+    [[nodiscard]] static GC::Ref<RadioNodeList> create(JS::Realm& realm, DOM::Node const& root, Scope scope, ESCAPING Function<bool(DOM::Node const&)> filter);
 
     virtual ~RadioNodeList() override;
 
diff --git a/Libraries/LibWeb/HTML/Scripting/ClassicScript.cpp b/Libraries/LibWeb/HTML/Scripting/ClassicScript.cpp
index 26e6c1458fc..b2d98712575 100644
--- a/Libraries/LibWeb/HTML/Scripting/ClassicScript.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/ClassicScript.cpp
@@ -16,11 +16,11 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ClassicScript);
+GC_DEFINE_ALLOCATOR(ClassicScript);
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#creating-a-classic-script
 // https://whatpr.org/html/9893/webappapis.html#creating-a-classic-script
-JS::NonnullGCPtr<ClassicScript> ClassicScript::create(ByteString filename, StringView source, JS::Realm& realm, URL::URL base_url, size_t source_line_number, MutedErrors muted_errors)
+GC::Ref<ClassicScript> ClassicScript::create(ByteString filename, StringView source, JS::Realm& realm, URL::URL base_url, size_t source_line_number, MutedErrors muted_errors)
 {
     auto& vm = realm.vm();
 
@@ -75,7 +75,7 @@ JS::NonnullGCPtr<ClassicScript> ClassicScript::create(ByteString filename, Strin
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#run-a-classic-script
 // https://whatpr.org/html/9893/webappapis.html#run-a-classic-script
-JS::Completion ClassicScript::run(RethrowErrors rethrow_errors, JS::GCPtr<JS::Environment> lexical_environment_override)
+JS::Completion ClassicScript::run(RethrowErrors rethrow_errors, GC::Ptr<JS::Environment> lexical_environment_override)
 {
     // 1. Let realm be the realm of script.
     auto& realm = this->realm();
diff --git a/Libraries/LibWeb/HTML/Scripting/ClassicScript.h b/Libraries/LibWeb/HTML/Scripting/ClassicScript.h
index f696e6906e6..04909b19e9c 100644
--- a/Libraries/LibWeb/HTML/Scripting/ClassicScript.h
+++ b/Libraries/LibWeb/HTML/Scripting/ClassicScript.h
@@ -14,8 +14,8 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#classic-script
 class ClassicScript final : public Script {
-    JS_CELL(ClassicScript, Script);
-    JS_DECLARE_ALLOCATOR(ClassicScript);
+    GC_CELL(ClassicScript, Script);
+    GC_DECLARE_ALLOCATOR(ClassicScript);
 
 public:
     virtual ~ClassicScript() override;
@@ -24,7 +24,7 @@ public:
         No,
         Yes,
     };
-    static JS::NonnullGCPtr<ClassicScript> create(ByteString filename, StringView source, JS::Realm&, URL::URL base_url, size_t source_line_number = 1, MutedErrors = MutedErrors::No);
+    static GC::Ref<ClassicScript> create(ByteString filename, StringView source, JS::Realm&, URL::URL base_url, size_t source_line_number = 1, MutedErrors = MutedErrors::No);
 
     JS::Script* script_record() { return m_script_record; }
     JS::Script const* script_record() const { return m_script_record; }
@@ -33,7 +33,7 @@ public:
         No,
         Yes,
     };
-    JS::Completion run(RethrowErrors = RethrowErrors::No, JS::GCPtr<JS::Environment> lexical_environment_override = {});
+    JS::Completion run(RethrowErrors = RethrowErrors::No, GC::Ptr<JS::Environment> lexical_environment_override = {});
 
     MutedErrors muted_errors() const { return m_muted_errors; }
 
@@ -42,7 +42,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<JS::Script> m_script_record;
+    GC::Ptr<JS::Script> m_script_record;
     MutedErrors m_muted_errors { MutedErrors::No };
 };
 
diff --git a/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.cpp b/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.cpp
index 9f6661014c8..7ea34b4b3cb 100644
--- a/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(EnvironmentSettingsSnapshot);
+GC_DEFINE_ALLOCATOR(EnvironmentSettingsSnapshot);
 
 EnvironmentSettingsSnapshot::EnvironmentSettingsSnapshot(NonnullOwnPtr<JS::ExecutionContext> execution_context, SerializedEnvironmentSettingsObject const& serialized_settings)
     : EnvironmentSettingsObject(move(execution_context))
diff --git a/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.h b/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.h
index f55c87cfd5a..628b7f4957b 100644
--- a/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.h
+++ b/Libraries/LibWeb/HTML/Scripting/EnvironmentSettingsSnapshot.h
@@ -14,15 +14,15 @@ namespace Web::HTML {
 
 class EnvironmentSettingsSnapshot final
     : public EnvironmentSettingsObject {
-    JS_CELL(EnvironmentSettingsSnapshot, EnvironmentSettingsObject);
-    JS_DECLARE_ALLOCATOR(EnvironmentSettingsSnapshot);
+    GC_CELL(EnvironmentSettingsSnapshot, EnvironmentSettingsObject);
+    GC_DECLARE_ALLOCATOR(EnvironmentSettingsSnapshot);
 
 public:
     EnvironmentSettingsSnapshot(NonnullOwnPtr<JS::ExecutionContext>, SerializedEnvironmentSettingsObject const&);
 
     virtual ~EnvironmentSettingsSnapshot() override;
 
-    JS::GCPtr<DOM::Document> responsible_document() override { return nullptr; }
+    GC::Ptr<DOM::Document> responsible_document() override { return nullptr; }
     String api_url_character_encoding() override { return m_api_url_character_encoding; }
     URL::URL api_base_url() override { return m_url; }
     URL::Origin origin() override { return m_origin; }
diff --git a/Libraries/LibWeb/HTML/Scripting/Environments.cpp b/Libraries/LibWeb/HTML/Scripting/Environments.cpp
index fcd8f0ab5d6..cbb0f689b9d 100644
--- a/Libraries/LibWeb/HTML/Scripting/Environments.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/Environments.cpp
@@ -517,7 +517,7 @@ SerializedEnvironmentSettingsObject EnvironmentSettingsObject::serialize()
     return object;
 }
 
-JS::NonnullGCPtr<StorageAPI::StorageManager> EnvironmentSettingsObject::storage_manager()
+GC::Ref<StorageAPI::StorageManager> EnvironmentSettingsObject::storage_manager()
 {
     if (!m_storage_manager)
         m_storage_manager = realm().create<StorageAPI::StorageManager>(realm());
diff --git a/Libraries/LibWeb/HTML/Scripting/Environments.h b/Libraries/LibWeb/HTML/Scripting/Environments.h
index bf26223f3c2..6b8c130919c 100644
--- a/Libraries/LibWeb/HTML/Scripting/Environments.h
+++ b/Libraries/LibWeb/HTML/Scripting/Environments.h
@@ -20,7 +20,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#environment
 struct Environment : public JS::Cell {
-    JS_CELL(Environment, JS::Cell);
+    GC_CELL(Environment, JS::Cell);
 
 public:
     virtual ~Environment() override;
@@ -38,7 +38,7 @@ public:
     URL::Origin top_level_origin;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#concept-environment-target-browsing-context
-    JS::GCPtr<BrowsingContext> target_browsing_context;
+    GC::Ptr<BrowsingContext> target_browsing_context;
 
     // FIXME: An active service worker https://html.spec.whatwg.org/multipage/webappapis.html#concept-environment-active-service-worker
 
@@ -56,7 +56,7 @@ enum class RunScriptDecision {
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
 struct EnvironmentSettingsObject : public Environment {
-    JS_CELL(EnvironmentSettingsObject, Environment);
+    GC_CELL(EnvironmentSettingsObject, Environment);
 
 public:
     virtual ~EnvironmentSettingsObject() override;
@@ -70,7 +70,7 @@ public:
     ModuleMap& module_map();
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#responsible-document
-    virtual JS::GCPtr<DOM::Document> responsible_document() = 0;
+    virtual GC::Ptr<DOM::Document> responsible_document() = 0;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#api-url-character-encoding
     virtual String api_url_character_encoding() = 0;
@@ -94,11 +94,11 @@ public:
     EventLoop& responsible_event_loop();
 
     // https://fetch.spec.whatwg.org/#concept-fetch-group
-    Vector<JS::NonnullGCPtr<Fetch::Infrastructure::FetchRecord>>& fetch_group() { return m_fetch_group; }
+    Vector<GC::Ref<Fetch::Infrastructure::FetchRecord>>& fetch_group() { return m_fetch_group; }
 
     SerializedEnvironmentSettingsObject serialize();
 
-    JS::NonnullGCPtr<StorageAPI::StorageManager> storage_manager();
+    GC::Ref<StorageAPI::StorageManager> storage_manager();
 
     [[nodiscard]] bool discarded() const { return m_discarded; }
     void set_discarded(bool b) { m_discarded = b; }
@@ -110,17 +110,17 @@ protected:
 
 private:
     NonnullOwnPtr<JS::ExecutionContext> m_realm_execution_context;
-    JS::GCPtr<ModuleMap> m_module_map;
+    GC::Ptr<ModuleMap> m_module_map;
 
-    JS::GCPtr<EventLoop> m_responsible_event_loop;
+    GC::Ptr<EventLoop> m_responsible_event_loop;
 
     // https://fetch.spec.whatwg.org/#concept-fetch-record
     // A fetch group holds an ordered list of fetch records
-    Vector<JS::NonnullGCPtr<Fetch::Infrastructure::FetchRecord>> m_fetch_group;
+    Vector<GC::Ref<Fetch::Infrastructure::FetchRecord>> m_fetch_group;
 
     // https://storage.spec.whatwg.org/#api
     // Each environment settings object has an associated StorageManager object.
-    JS::GCPtr<StorageAPI::StorageManager> m_storage_manager;
+    GC::Ptr<StorageAPI::StorageManager> m_storage_manager;
 
     // https://w3c.github.io/ServiceWorker/#service-worker-client-discarded-flag
     // A service worker client has an associated discarded flag. It is initially unset.
diff --git a/Libraries/LibWeb/HTML/Scripting/Fetching.cpp b/Libraries/LibWeb/HTML/Scripting/Fetching.cpp
index 4d3ad3a661b..007aca09f73 100644
--- a/Libraries/LibWeb/HTML/Scripting/Fetching.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/Fetching.cpp
@@ -6,7 +6,7 @@
  */
 
 #include <LibCore/EventLoop.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/ModuleRequest.h>
 #include <LibTextCodec/Decoder.h>
 #include <LibWeb/DOM/Document.h>
@@ -30,16 +30,16 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(FetchContext);
+GC_DEFINE_ALLOCATOR(FetchContext);
 
-OnFetchScriptComplete create_on_fetch_script_complete(JS::Heap& heap, Function<void(JS::GCPtr<Script>)> function)
+OnFetchScriptComplete create_on_fetch_script_complete(GC::Heap& heap, Function<void(GC::Ptr<Script>)> function)
 {
-    return JS::create_heap_function(heap, move(function));
+    return GC::create_function(heap, move(function));
 }
 
-PerformTheFetchHook create_perform_the_fetch_hook(JS::Heap& heap, Function<WebIDL::ExceptionOr<void>(JS::NonnullGCPtr<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)> function)
+PerformTheFetchHook create_perform_the_fetch_hook(GC::Heap& heap, Function<WebIDL::ExceptionOr<void>(GC::Ref<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)> function)
 {
-    return JS::create_heap_function(heap, move(function));
+    return GC::create_function(heap, move(function));
 }
 
 ScriptFetchOptions default_script_fetch_options()
@@ -319,7 +319,7 @@ WebIDL::ExceptionOr<String> resolve_a_module_integrity_metadata(const URL::URL&
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-classic-script
-WebIDL::ExceptionOr<void> fetch_classic_script(JS::NonnullGCPtr<HTMLScriptElement> element, URL::URL const& url, EnvironmentSettingsObject& settings_object, ScriptFetchOptions options, CORSSettingAttribute cors_setting, String character_encoding, OnFetchScriptComplete on_complete)
+WebIDL::ExceptionOr<void> fetch_classic_script(GC::Ref<HTMLScriptElement> element, URL::URL const& url, EnvironmentSettingsObject& settings_object, ScriptFetchOptions options, CORSSettingAttribute cors_setting, String character_encoding, OnFetchScriptComplete on_complete)
 {
     auto& realm = element->realm();
     auto& vm = realm.vm();
@@ -464,13 +464,13 @@ WebIDL::ExceptionOr<void> fetch_classic_worker_script(URL::URL const& url, Envir
 }
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-classic-worker-imported-script
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ClassicScript>> fetch_a_classic_worker_imported_script(URL::URL const& url, HTML::EnvironmentSettingsObject& settings_object, PerformTheFetchHook perform_fetch)
+WebIDL::ExceptionOr<GC::Ref<ClassicScript>> fetch_a_classic_worker_imported_script(URL::URL const& url, HTML::EnvironmentSettingsObject& settings_object, PerformTheFetchHook perform_fetch)
 {
     auto& realm = settings_object.realm();
     auto& vm = realm.vm();
 
     // 1. Let response be null.
-    JS::GCPtr<Fetch::Infrastructure::Response> response = nullptr;
+    GC::Ptr<Fetch::Infrastructure::Response> response = nullptr;
 
     // 2. Let bodyBytes be null.
     Fetch::Infrastructure::FetchAlgorithms::BodyBytes body_bytes;
@@ -485,7 +485,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ClassicScript>> fetch_a_classic_worker_impo
     request->set_parser_metadata(Fetch::Infrastructure::Request::ParserMetadata::NotParserInserted);
     request->set_use_url_credentials(true);
 
-    auto process_response_consume_body = [&response, &body_bytes](JS::NonnullGCPtr<Fetch::Infrastructure::Response> res, Fetch::Infrastructure::FetchAlgorithms::BodyBytes bb) {
+    auto process_response_consume_body = [&response, &body_bytes](GC::Ref<Fetch::Infrastructure::Response> res, Fetch::Infrastructure::FetchAlgorithms::BodyBytes bb) {
         // 1. Set bodyBytes to bb.
         body_bytes = move(bb);
 
@@ -506,7 +506,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ClassicScript>> fetch_a_classic_worker_impo
 
     // 5. Pause until response is not null.
     auto& event_loop = settings_object.responsible_event_loop();
-    event_loop.spin_until(JS::create_heap_function(vm.heap(), [&]() -> bool {
+    event_loop.spin_until(GC::create_function(vm.heap(), [&]() -> bool {
         return response;
     }));
 
@@ -759,7 +759,7 @@ void fetch_single_module_script(JS::Realm& realm,
     //    then queue a task on the networking task source to proceed with running the following steps.
     if (module_map.is_fetching(url, module_type)) {
         module_map.wait_for_change(realm.heap(), url, module_type, [on_complete, &realm](auto entry) -> void {
-            HTML::queue_global_task(HTML::Task::Source::Networking, realm.global_object(), JS::create_heap_function(realm.heap(), [on_complete, entry] {
+            HTML::queue_global_task(HTML::Task::Source::Networking, realm.global_object(), GC::create_function(realm.heap(), [on_complete, entry] {
                 // FIXME: This should run other steps, for now we just assume the script loaded.
                 VERIFY(entry.type == ModuleMap::EntryType::ModuleScript || entry.type == ModuleMap::EntryType::Failed);
 
@@ -803,7 +803,7 @@ void fetch_single_module_script(JS::Realm& realm,
     // 13. If performFetch was given, run performFetch with request, isTopLevel, and with processResponseConsumeBody as defined below.
     //     Otherwise, fetch request with processResponseConsumeBody set to processResponseConsumeBody as defined below.
     //     In both cases, let processResponseConsumeBody given response response and null, failure, or a byte sequence bodyBytes be the following algorithm:
-    auto process_response_consume_body = [&module_map, url, module_type, &module_map_realm, on_complete](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response, Fetch::Infrastructure::FetchAlgorithms::BodyBytes body_bytes) {
+    auto process_response_consume_body = [&module_map, url, module_type, &module_map_realm, on_complete](GC::Ref<Fetch::Infrastructure::Response> response, Fetch::Infrastructure::FetchAlgorithms::BodyBytes body_bytes) {
         // 1. If either of the following conditions are met:
         //    - bodyBytes is null or failure; or
         //    - response's status is not an ok status,
@@ -823,7 +823,7 @@ void fetch_single_module_script(JS::Realm& realm,
         auto mime_type = response->header_list()->extract_mime_type();
 
         // 4. Let moduleScript be null.
-        JS::GCPtr<JavaScriptModuleScript> module_script;
+        GC::Ptr<JavaScriptModuleScript> module_script;
 
         // FIXME: 5. Let referrerPolicy be the result of parsing the `Referrer-Policy` header given response. [REFERRERPOLICY]
         // FIXME: 6. If referrerPolicy is not the empty string, set options's referrer policy to referrerPolicy.
@@ -968,7 +968,7 @@ void fetch_descendants_of_and_link_a_module_script(JS::Realm& realm,
     auto& loading_promise = record->load_requested_modules(state);
 
     // 6. Upon fulfillment of loadingPromise, run the following steps:
-    WebIDL::upon_fulfillment(loading_promise, JS::create_heap_function(realm.heap(), [&realm, record, &module_script, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(loading_promise, GC::create_function(realm.heap(), [&realm, record, &module_script, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform record.Link().
         auto linking_result = record->link(realm.vm());
 
@@ -983,7 +983,7 @@ void fetch_descendants_of_and_link_a_module_script(JS::Realm& realm,
     }));
 
     // 7. Upon rejection of loadingPromise, run the following steps:
-    WebIDL::upon_rejection(loading_promise, JS::create_heap_function(realm.heap(), [state, &module_script, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(loading_promise, GC::create_function(realm.heap(), [state, &module_script, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. If state.[[ParseError]] is not null, set moduleScript's error to rethrow to state.[[ParseError]] and run
         //    onComplete given moduleScript.
         if (!state->parse_error.is_null()) {
diff --git a/Libraries/LibWeb/HTML/Scripting/Fetching.h b/Libraries/LibWeb/HTML/Scripting/Fetching.h
index 48b71c44bf6..bb225f57737 100644
--- a/Libraries/LibWeb/HTML/Scripting/Fetching.h
+++ b/Libraries/LibWeb/HTML/Scripting/Fetching.h
@@ -21,11 +21,11 @@ enum class TopLevelModule {
     No
 };
 
-using OnFetchScriptComplete = JS::NonnullGCPtr<JS::HeapFunction<void(JS::GCPtr<Script>)>>;
-using PerformTheFetchHook = JS::GCPtr<JS::HeapFunction<WebIDL::ExceptionOr<void>(JS::NonnullGCPtr<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)>>;
+using OnFetchScriptComplete = GC::Ref<GC::Function<void(GC::Ptr<Script>)>>;
+using PerformTheFetchHook = GC::Ptr<GC::Function<WebIDL::ExceptionOr<void>(GC::Ref<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)>>;
 
-OnFetchScriptComplete create_on_fetch_script_complete(JS::Heap& heap, Function<void(JS::GCPtr<Script>)> function);
-PerformTheFetchHook create_perform_the_fetch_hook(JS::Heap& heap, Function<WebIDL::ExceptionOr<void>(JS::NonnullGCPtr<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)> function);
+OnFetchScriptComplete create_on_fetch_script_complete(GC::Heap& heap, Function<void(GC::Ptr<Script>)> function);
+PerformTheFetchHook create_perform_the_fetch_hook(GC::Heap& heap, Function<WebIDL::ExceptionOr<void>(GC::Ref<Fetch::Infrastructure::Request>, TopLevelModule, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction)> function);
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#script-fetch-options
 struct ScriptFetchOptions {
@@ -55,14 +55,14 @@ struct ScriptFetchOptions {
 ScriptFetchOptions default_script_fetch_options();
 
 class FetchContext : public JS::GraphLoadingState::HostDefined {
-    JS_CELL(FetchContext, JS::GraphLoadingState::HostDefined);
-    JS_DECLARE_ALLOCATOR(FetchContext);
+    GC_CELL(FetchContext, JS::GraphLoadingState::HostDefined);
+    GC_DECLARE_ALLOCATOR(FetchContext);
 
 public:
-    JS::Value parse_error;                                    // [[ParseError]]
-    Fetch::Infrastructure::Request::Destination destination;  // [[Destination]]
-    PerformTheFetchHook perform_fetch;                        // [[PerformFetch]]
-    JS::NonnullGCPtr<EnvironmentSettingsObject> fetch_client; // [[FetchClient]]
+    JS::Value parse_error;                                   // [[ParseError]]
+    Fetch::Infrastructure::Request::Destination destination; // [[Destination]]
+    PerformTheFetchHook perform_fetch;                       // [[PerformFetch]]
+    GC::Ref<EnvironmentSettingsObject> fetch_client;         // [[FetchClient]]
 
 private:
     FetchContext(JS::Value parse_error, Fetch::Infrastructure::Request::Destination destination, PerformTheFetchHook perform_fetch, EnvironmentSettingsObject& fetch_client)
@@ -88,9 +88,9 @@ WebIDL::ExceptionOr<Optional<URL::URL>> resolve_imports_match(ByteString const&
 Optional<URL::URL> resolve_url_like_module_specifier(ByteString const& specifier, URL::URL const& base_url);
 WebIDL::ExceptionOr<ScriptFetchOptions> get_descendant_script_fetch_options(ScriptFetchOptions const& original_options, URL::URL const& url, EnvironmentSettingsObject& settings_object);
 WebIDL::ExceptionOr<String> resolve_a_module_integrity_metadata(URL::URL const& url, EnvironmentSettingsObject& settings_object);
-WebIDL::ExceptionOr<void> fetch_classic_script(JS::NonnullGCPtr<HTMLScriptElement>, URL::URL const&, EnvironmentSettingsObject& settings_object, ScriptFetchOptions options, CORSSettingAttribute cors_setting, String character_encoding, OnFetchScriptComplete on_complete);
+WebIDL::ExceptionOr<void> fetch_classic_script(GC::Ref<HTMLScriptElement>, URL::URL const&, EnvironmentSettingsObject& settings_object, ScriptFetchOptions options, CORSSettingAttribute cors_setting, String character_encoding, OnFetchScriptComplete on_complete);
 WebIDL::ExceptionOr<void> fetch_classic_worker_script(URL::URL const&, EnvironmentSettingsObject& fetch_client, Fetch::Infrastructure::Request::Destination, EnvironmentSettingsObject& settings_object, PerformTheFetchHook, OnFetchScriptComplete);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ClassicScript>> fetch_a_classic_worker_imported_script(URL::URL const&, HTML::EnvironmentSettingsObject&, PerformTheFetchHook = nullptr);
+WebIDL::ExceptionOr<GC::Ref<ClassicScript>> fetch_a_classic_worker_imported_script(URL::URL const&, HTML::EnvironmentSettingsObject&, PerformTheFetchHook = nullptr);
 WebIDL::ExceptionOr<void> fetch_module_worker_script_graph(URL::URL const&, EnvironmentSettingsObject& fetch_client, Fetch::Infrastructure::Request::Destination, EnvironmentSettingsObject& settings_object, PerformTheFetchHook, OnFetchScriptComplete);
 WebIDL::ExceptionOr<void> fetch_worklet_module_worker_script_graph(URL::URL const&, EnvironmentSettingsObject& fetch_client, Fetch::Infrastructure::Request::Destination, EnvironmentSettingsObject& settings_object, PerformTheFetchHook, OnFetchScriptComplete);
 void fetch_internal_module_script_graph(JS::Realm&, JS::ModuleRequest const& module_request, EnvironmentSettingsObject& fetch_client_settings_object, Fetch::Infrastructure::Request::Destination, ScriptFetchOptions const&, Script& referring_script, HashTable<ModuleLocationTuple> const& visited_set, PerformTheFetchHook, OnFetchScriptComplete on_complete);
diff --git a/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.cpp b/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.cpp
index 7914c70b86f..c58afdbab02 100644
--- a/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.cpp
@@ -13,14 +13,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ImportMapParseResult);
+GC_DEFINE_ALLOCATOR(ImportMapParseResult);
 
 ImportMapParseResult::ImportMapParseResult() = default;
 
 ImportMapParseResult::~ImportMapParseResult() = default;
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#create-an-import-map-parse-result
-JS::NonnullGCPtr<ImportMapParseResult> ImportMapParseResult::create(JS::Realm& realm, ByteString const& input, URL::URL base_url)
+GC::Ref<ImportMapParseResult> ImportMapParseResult::create(JS::Realm& realm, ByteString const& input, URL::URL base_url)
 {
     // 1. Let result be an import map parse result whose import map is null and whose error to rethrow is null.
     auto result = realm.create<ImportMapParseResult>();
@@ -53,7 +53,7 @@ void ImportMapParseResult::visit_edges(Visitor& visitor)
             [&](WebIDL::SimpleException const&) {
                 // ignore
             },
-            [&](JS::NonnullGCPtr<WebIDL::DOMException> exception) {
+            [&](GC::Ref<WebIDL::DOMException> exception) {
                 visitor.visit(exception);
             },
             [&](JS::Completion const& completion) {
diff --git a/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.h b/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.h
index bd4e64b5566..33cea3b469b 100644
--- a/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.h
+++ b/Libraries/LibWeb/HTML/Scripting/ImportMapParseResult.h
@@ -19,13 +19,13 @@ namespace Web::HTML {
 class ImportMapParseResult
     : public JS::Cell
     , public JS::Script::HostDefined {
-    JS_CELL(ImportMapParseResult, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ImportMapParseResult);
+    GC_CELL(ImportMapParseResult, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ImportMapParseResult);
 
 public:
     virtual ~ImportMapParseResult() override;
 
-    static JS::NonnullGCPtr<ImportMapParseResult> create(JS::Realm& realm, ByteString const& input, URL::URL base_url);
+    static GC::Ref<ImportMapParseResult> create(JS::Realm& realm, ByteString const& input, URL::URL base_url);
 
     [[nodiscard]] Optional<ImportMap> const& import_map() const { return m_import_map; }
     void set_import_map(ImportMap const& value) { m_import_map = value; }
diff --git a/Libraries/LibWeb/HTML/Scripting/ModuleMap.cpp b/Libraries/LibWeb/HTML/Scripting/ModuleMap.cpp
index 1869170e47a..511a3b09217 100644
--- a/Libraries/LibWeb/HTML/Scripting/ModuleMap.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/ModuleMap.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ModuleMap);
+GC_DEFINE_ALLOCATOR(ModuleMap);
 
 void ModuleMap::visit_edges(Visitor& visitor)
 {
@@ -62,9 +62,9 @@ AK::HashSetResult ModuleMap::set(URL::URL const& url, ByteString const& type, En
     return value;
 }
 
-void ModuleMap::wait_for_change(JS::Heap& heap, URL::URL const& url, ByteString const& type, Function<void(Entry)> callback)
+void ModuleMap::wait_for_change(GC::Heap& heap, URL::URL const& url, ByteString const& type, Function<void(Entry)> callback)
 {
-    m_callbacks.ensure({ url, type }).append(JS::create_heap_function(heap, move(callback)));
+    m_callbacks.ensure({ url, type }).append(GC::create_function(heap, move(callback)));
 }
 
 }
diff --git a/Libraries/LibWeb/HTML/Scripting/ModuleMap.h b/Libraries/LibWeb/HTML/Scripting/ModuleMap.h
index a6c805605e3..c7f40435499 100644
--- a/Libraries/LibWeb/HTML/Scripting/ModuleMap.h
+++ b/Libraries/LibWeb/HTML/Scripting/ModuleMap.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Function.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibURL/URL.h>
 #include <LibWeb/HTML/Scripting/ModuleScript.h>
 
@@ -36,8 +36,8 @@ private:
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#module-map
 class ModuleMap final : public JS::Cell {
-    JS_CELL(ModuleMap, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ModuleMap);
+    GC_CELL(ModuleMap, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ModuleMap);
 
 public:
     ModuleMap() = default;
@@ -51,10 +51,10 @@ public:
 
     struct Entry {
         EntryType type;
-        JS::GCPtr<JavaScriptModuleScript> module_script;
+        GC::Ptr<JavaScriptModuleScript> module_script;
     };
 
-    using CallbackFunction = JS::NonnullGCPtr<JS::HeapFunction<void(Entry)>>;
+    using CallbackFunction = GC::Ref<GC::Function<void(Entry)>>;
 
     bool is_fetching(URL::URL const& url, ByteString const& type) const;
     bool is_failed(URL::URL const& url, ByteString const& type) const;
@@ -65,7 +65,7 @@ public:
 
     AK::HashSetResult set(URL::URL const& url, ByteString const& type, Entry);
 
-    void wait_for_change(JS::Heap&, URL::URL const& url, ByteString const& type, Function<void(Entry)> callback);
+    void wait_for_change(GC::Heap&, URL::URL const& url, ByteString const& type, Function<void(Entry)> callback);
 
 private:
     virtual void visit_edges(JS::Cell::Visitor&) override;
diff --git a/Libraries/LibWeb/HTML/Scripting/ModuleScript.cpp b/Libraries/LibWeb/HTML/Scripting/ModuleScript.cpp
index 32e997dd850..f0b2eccea5c 100644
--- a/Libraries/LibWeb/HTML/Scripting/ModuleScript.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/ModuleScript.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(JavaScriptModuleScript);
+GC_DEFINE_ALLOCATOR(JavaScriptModuleScript);
 
 ModuleScript::~ModuleScript() = default;
 
@@ -31,7 +31,7 @@ JavaScriptModuleScript::JavaScriptModuleScript(URL::URL base_url, ByteString fil
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#creating-a-javascript-module-script
 // https://whatpr.org/html/9893/webappapis.html#creating-a-javascript-module-script
-WebIDL::ExceptionOr<JS::GCPtr<JavaScriptModuleScript>> JavaScriptModuleScript::create(ByteString const& filename, StringView source, JS::Realm& realm, URL::URL base_url)
+WebIDL::ExceptionOr<GC::Ptr<JavaScriptModuleScript>> JavaScriptModuleScript::create(ByteString const& filename, StringView source, JS::Realm& realm, URL::URL base_url)
 {
     // 1. If scripting is disabled for realm, then set source to the empty string.
     if (HTML::is_scripting_disabled(realm))
@@ -146,7 +146,7 @@ JS::Promise* JavaScriptModuleScript::run(PreventErrorReporting)
         // NON-STANDARD: To ensure that LibJS can find the module on the stack, we push a new execution context.
         auto module_execution_context = JS::ExecutionContext::create();
         module_execution_context->realm = &realm;
-        module_execution_context->script_or_module = JS::NonnullGCPtr<JS::Module> { *record };
+        module_execution_context->script_or_module = GC::Ref<JS::Module> { *record };
         vm().push_execution_context(*module_execution_context);
 
         // 2. Set evaluationPromise to record.Evaluate().
diff --git a/Libraries/LibWeb/HTML/Scripting/ModuleScript.h b/Libraries/LibWeb/HTML/Scripting/ModuleScript.h
index ff5f003639b..7a3fc9ff0f9 100644
--- a/Libraries/LibWeb/HTML/Scripting/ModuleScript.h
+++ b/Libraries/LibWeb/HTML/Scripting/ModuleScript.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#module-script
 class ModuleScript : public Script {
-    JS_CELL(ModuleScript, Script);
+    GC_CELL(ModuleScript, Script);
 
 public:
     virtual ~ModuleScript() override;
@@ -23,13 +23,13 @@ protected:
 };
 
 class JavaScriptModuleScript final : public ModuleScript {
-    JS_CELL(JavaScriptModuleScript, ModuleScript);
-    JS_DECLARE_ALLOCATOR(JavaScriptModuleScript);
+    GC_CELL(JavaScriptModuleScript, ModuleScript);
+    GC_DECLARE_ALLOCATOR(JavaScriptModuleScript);
 
 public:
     virtual ~JavaScriptModuleScript() override;
 
-    static WebIDL::ExceptionOr<JS::GCPtr<JavaScriptModuleScript>> create(ByteString const& filename, StringView source, JS::Realm&, URL::URL base_url);
+    static WebIDL::ExceptionOr<GC::Ptr<JavaScriptModuleScript>> create(ByteString const& filename, StringView source, JS::Realm&, URL::URL base_url);
 
     enum class PreventErrorReporting {
         Yes,
@@ -47,7 +47,7 @@ protected:
 private:
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::GCPtr<JS::SourceTextModule> m_record;
+    GC::Ptr<JS::SourceTextModule> m_record;
 
     size_t m_fetch_internal_request_count { 0 };
     size_t m_completed_fetch_internal_request_count { 0 };
diff --git a/Libraries/LibWeb/HTML/Scripting/Script.cpp b/Libraries/LibWeb/HTML/Scripting/Script.cpp
index b7b2eafa617..673f1757e84 100644
--- a/Libraries/LibWeb/HTML/Scripting/Script.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/Script.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Script);
+GC_DEFINE_ALLOCATOR(Script);
 
 Script::Script(URL::URL base_url, ByteString filename, JS::Realm& realm)
     : m_base_url(move(base_url))
diff --git a/Libraries/LibWeb/HTML/Scripting/Script.h b/Libraries/LibWeb/HTML/Scripting/Script.h
index c9264affbcf..9f5a5f93ee2 100644
--- a/Libraries/LibWeb/HTML/Scripting/Script.h
+++ b/Libraries/LibWeb/HTML/Scripting/Script.h
@@ -18,8 +18,8 @@ namespace Web::HTML {
 class Script
     : public JS::Cell
     , public JS::Script::HostDefined {
-    JS_CELL(Script, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Script);
+    GC_CELL(Script, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Script);
 
 public:
     virtual ~Script() override;
@@ -46,7 +46,7 @@ private:
 
     URL::URL m_base_url;
     ByteString m_filename;
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    GC::Ref<JS::Realm> m_realm;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#concept-script-parse-error
     JS::Value m_parse_error;
diff --git a/Libraries/LibWeb/HTML/Scripting/SyntheticRealmSettings.h b/Libraries/LibWeb/HTML/Scripting/SyntheticRealmSettings.h
index eb59931f032..8bbcb7a4f40 100644
--- a/Libraries/LibWeb/HTML/Scripting/SyntheticRealmSettings.h
+++ b/Libraries/LibWeb/HTML/Scripting/SyntheticRealmSettings.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
@@ -21,15 +21,15 @@ struct SyntheticRealmSettings {
 
     // A principal realm
     // The principal realm which this synthetic realm exists within.
-    JS::NonnullGCPtr<JS::Realm> principal_realm;
+    GC::Ref<JS::Realm> principal_realm;
 
     // An underlying realm
     // The synthetic realm which this settings object represents.
-    JS::NonnullGCPtr<JS::Realm> underlying_realm;
+    GC::Ref<JS::Realm> underlying_realm;
 
     // A module map
     // A module map that is used when importing JavaScript modules.
-    JS::NonnullGCPtr<ModuleMap> module_map;
+    GC::Ref<ModuleMap> module_map;
 
     void visit_edges(JS::Cell::Visitor&);
 };
diff --git a/Libraries/LibWeb/HTML/Scripting/TemporaryExecutionContext.h b/Libraries/LibWeb/HTML/Scripting/TemporaryExecutionContext.h
index de2612cc46b..445267114dd 100644
--- a/Libraries/LibWeb/HTML/Scripting/TemporaryExecutionContext.h
+++ b/Libraries/LibWeb/HTML/Scripting/TemporaryExecutionContext.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
@@ -25,7 +25,7 @@ public:
     ~TemporaryExecutionContext();
 
 private:
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    GC::Ref<JS::Realm> m_realm;
     CallbacksEnabled m_callbacks_enabled { CallbacksEnabled::No };
 };
 
diff --git a/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.cpp b/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.cpp
index 92dd0ba9f2d..0b2234f40fe 100644
--- a/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WindowEnvironmentSettingsObject);
+GC_DEFINE_ALLOCATOR(WindowEnvironmentSettingsObject);
 
 WindowEnvironmentSettingsObject::WindowEnvironmentSettingsObject(Window& window, NonnullOwnPtr<JS::ExecutionContext> execution_context)
     : EnvironmentSettingsObject(move(execution_context))
@@ -29,7 +29,7 @@ void WindowEnvironmentSettingsObject::visit_edges(JS::Cell::Visitor& visitor)
 }
 
 // https://html.spec.whatwg.org/multipage/window-object.html#set-up-a-window-environment-settings-object
-void WindowEnvironmentSettingsObject::setup(Page& page, URL::URL const& creation_url, NonnullOwnPtr<JS::ExecutionContext> execution_context, JS::GCPtr<Environment> reserved_environment, URL::URL top_level_creation_url, URL::Origin top_level_origin)
+void WindowEnvironmentSettingsObject::setup(Page& page, URL::URL const& creation_url, NonnullOwnPtr<JS::ExecutionContext> execution_context, GC::Ptr<Environment> reserved_environment, URL::URL top_level_creation_url, URL::Origin top_level_origin)
 {
     // 1. Let realm be the value of execution context's Realm component.
     auto realm = execution_context->realm;
@@ -83,7 +83,7 @@ void WindowEnvironmentSettingsObject::setup(Page& page, URL::URL const& creation
 }
 
 // https://html.spec.whatwg.org/multipage/window-object.html#script-settings-for-window-objects:responsible-document
-JS::GCPtr<DOM::Document> WindowEnvironmentSettingsObject::responsible_document()
+GC::Ptr<DOM::Document> WindowEnvironmentSettingsObject::responsible_document()
 {
     // Return window's associated Document.
     return m_window->associated_document();
diff --git a/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h b/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h
index fee0c15559d..d6ec73b5466 100644
--- a/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h
+++ b/Libraries/LibWeb/HTML/Scripting/WindowEnvironmentSettingsObject.h
@@ -12,15 +12,15 @@
 namespace Web::HTML {
 
 class WindowEnvironmentSettingsObject final : public EnvironmentSettingsObject {
-    JS_CELL(WindowEnvironmentSettingsObject, EnvironmentSettingsObject);
-    JS_DECLARE_ALLOCATOR(WindowEnvironmentSettingsObject);
+    GC_CELL(WindowEnvironmentSettingsObject, EnvironmentSettingsObject);
+    GC_DECLARE_ALLOCATOR(WindowEnvironmentSettingsObject);
 
 public:
-    static void setup(Page&, URL::URL const& creation_url, NonnullOwnPtr<JS::ExecutionContext>, JS::GCPtr<Environment>, URL::URL top_level_creation_url, URL::Origin top_level_origin);
+    static void setup(Page&, URL::URL const& creation_url, NonnullOwnPtr<JS::ExecutionContext>, GC::Ptr<Environment>, URL::URL top_level_creation_url, URL::Origin top_level_origin);
 
     virtual ~WindowEnvironmentSettingsObject() override;
 
-    virtual JS::GCPtr<DOM::Document> responsible_document() override;
+    virtual GC::Ptr<DOM::Document> responsible_document() override;
     virtual String api_url_character_encoding() override;
     virtual URL::URL api_base_url() override;
     virtual URL::Origin origin() override;
@@ -32,7 +32,7 @@ private:
 
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::GCPtr<Window> m_window;
+    GC::Ptr<Window> m_window;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.cpp b/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.cpp
index 04b7db168b6..8bbd5dc7a8d 100644
--- a/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.cpp
+++ b/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.cpp
@@ -13,10 +13,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerEnvironmentSettingsObject);
+GC_DEFINE_ALLOCATOR(WorkerEnvironmentSettingsObject);
 
 // https://html.spec.whatwg.org/multipage/workers.html#set-up-a-worker-environment-settings-object
-JS::NonnullGCPtr<WorkerEnvironmentSettingsObject> WorkerEnvironmentSettingsObject::setup(JS::NonnullGCPtr<Page> page, NonnullOwnPtr<JS::ExecutionContext> execution_context, SerializedEnvironmentSettingsObject const& outside_settings, HighResolutionTime::DOMHighResTimeStamp unsafe_worker_creation_time)
+GC::Ref<WorkerEnvironmentSettingsObject> WorkerEnvironmentSettingsObject::setup(GC::Ref<Page> page, NonnullOwnPtr<JS::ExecutionContext> execution_context, SerializedEnvironmentSettingsObject const& outside_settings, HighResolutionTime::DOMHighResTimeStamp unsafe_worker_creation_time)
 {
     (void)unsafe_worker_creation_time;
 
diff --git a/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.h b/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.h
index 989859cd055..3dbfbd84f59 100644
--- a/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.h
+++ b/Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.h
@@ -14,21 +14,21 @@ namespace Web::HTML {
 
 class WorkerEnvironmentSettingsObject final
     : public EnvironmentSettingsObject {
-    JS_CELL(WorkerEnvironmentSettingsObject, EnvironmentSettingsObject);
-    JS_DECLARE_ALLOCATOR(WorkerEnvironmentSettingsObject);
+    GC_CELL(WorkerEnvironmentSettingsObject, EnvironmentSettingsObject);
+    GC_DECLARE_ALLOCATOR(WorkerEnvironmentSettingsObject);
 
 public:
-    WorkerEnvironmentSettingsObject(NonnullOwnPtr<JS::ExecutionContext> execution_context, JS::NonnullGCPtr<WorkerGlobalScope> global_scope)
+    WorkerEnvironmentSettingsObject(NonnullOwnPtr<JS::ExecutionContext> execution_context, GC::Ref<WorkerGlobalScope> global_scope)
         : EnvironmentSettingsObject(move(execution_context))
         , m_global_scope(global_scope)
     {
     }
 
-    static JS::NonnullGCPtr<WorkerEnvironmentSettingsObject> setup(JS::NonnullGCPtr<Page> page, NonnullOwnPtr<JS::ExecutionContext> execution_context, SerializedEnvironmentSettingsObject const& outside_settings, HighResolutionTime::DOMHighResTimeStamp unsafe_worker_creation_time);
+    static GC::Ref<WorkerEnvironmentSettingsObject> setup(GC::Ref<Page> page, NonnullOwnPtr<JS::ExecutionContext> execution_context, SerializedEnvironmentSettingsObject const& outside_settings, HighResolutionTime::DOMHighResTimeStamp unsafe_worker_creation_time);
 
     virtual ~WorkerEnvironmentSettingsObject() override = default;
 
-    JS::GCPtr<DOM::Document> responsible_document() override { return nullptr; }
+    GC::Ptr<DOM::Document> responsible_document() override { return nullptr; }
     String api_url_character_encoding() override { return m_api_url_character_encoding; }
     URL::URL api_base_url() override;
     URL::Origin origin() override;
@@ -41,7 +41,7 @@ private:
     String m_api_url_character_encoding;
     URL::Origin m_origin;
 
-    JS::NonnullGCPtr<WorkerGlobalScope> m_global_scope;
+    GC::Ref<WorkerGlobalScope> m_global_scope;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/SelectItem.h b/Libraries/LibWeb/HTML/SelectItem.h
index 41c652747b6..4ecf849839d 100644
--- a/Libraries/LibWeb/HTML/SelectItem.h
+++ b/Libraries/LibWeb/HTML/SelectItem.h
@@ -16,7 +16,7 @@ struct SelectItemOption {
     u32 id { 0 };
     bool selected { false };
     bool disabled { false };
-    JS::GCPtr<HTMLOptionElement> option_element {};
+    GC::Ptr<HTMLOptionElement> option_element {};
     String label {};
     String value {};
 };
diff --git a/Libraries/LibWeb/HTML/ServiceWorker.cpp b/Libraries/LibWeb/HTML/ServiceWorker.cpp
index ed4e93c3421..9af4e8dd2c7 100644
--- a/Libraries/LibWeb/HTML/ServiceWorker.cpp
+++ b/Libraries/LibWeb/HTML/ServiceWorker.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/HTML/EventNames.h>
@@ -20,7 +20,7 @@ ServiceWorker::ServiceWorker(JS::Realm& realm, String script_url)
 
 ServiceWorker::~ServiceWorker() = default;
 
-JS::NonnullGCPtr<ServiceWorker> ServiceWorker::create(JS::Realm& realm)
+GC::Ref<ServiceWorker> ServiceWorker::create(JS::Realm& realm)
 {
     return realm.create<ServiceWorker>(realm, ""_string);
 }
diff --git a/Libraries/LibWeb/HTML/ServiceWorker.h b/Libraries/LibWeb/HTML/ServiceWorker.h
index 9c8ed7f2bea..89cc547ba6b 100644
--- a/Libraries/LibWeb/HTML/ServiceWorker.h
+++ b/Libraries/LibWeb/HTML/ServiceWorker.h
@@ -19,7 +19,7 @@ class ServiceWorker : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(ServiceWorker, DOM::EventTarget);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ServiceWorker> create(JS::Realm& realm);
+    [[nodiscard]] static GC::Ref<ServiceWorker> create(JS::Realm& realm);
 
     virtual ~ServiceWorker() override;
 
diff --git a/Libraries/LibWeb/HTML/ServiceWorkerContainer.cpp b/Libraries/LibWeb/HTML/ServiceWorkerContainer.cpp
index f4b79db84b2..32fe8b56e65 100644
--- a/Libraries/LibWeb/HTML/ServiceWorkerContainer.cpp
+++ b/Libraries/LibWeb/HTML/ServiceWorkerContainer.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ServiceWorkerContainer);
+GC_DEFINE_ALLOCATOR(ServiceWorkerContainer);
 
 ServiceWorkerContainer::ServiceWorkerContainer(JS::Realm& realm)
     : DOM::EventTarget(realm)
@@ -38,13 +38,13 @@ void ServiceWorkerContainer::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_service_worker_client);
 }
 
-JS::NonnullGCPtr<ServiceWorkerContainer> ServiceWorkerContainer::create(JS::Realm& realm)
+GC::Ref<ServiceWorkerContainer> ServiceWorkerContainer::create(JS::Realm& realm)
 {
     return realm.create<ServiceWorkerContainer>(realm);
 }
 
 // https://w3c.github.io/ServiceWorker/#navigator-service-worker-register
-JS::NonnullGCPtr<WebIDL::Promise> ServiceWorkerContainer::register_(String script_url, RegistrationOptions const& options)
+GC::Ref<WebIDL::Promise> ServiceWorkerContainer::register_(String script_url, RegistrationOptions const& options)
 {
     auto& realm = this->realm();
     // Note: The register(scriptURL, options) method creates or updates a service worker registration for the given scope url.
@@ -80,7 +80,7 @@ JS::NonnullGCPtr<WebIDL::Promise> ServiceWorkerContainer::register_(String scrip
 }
 
 // https://w3c.github.io/ServiceWorker/#start-register-algorithm
-void ServiceWorkerContainer::start_register(Optional<URL::URL> scope_url, URL::URL script_url, JS::NonnullGCPtr<WebIDL::Promise> promise, EnvironmentSettingsObject& client, URL::URL referrer, Bindings::WorkerType worker_type, Bindings::ServiceWorkerUpdateViaCache update_via_cache)
+void ServiceWorkerContainer::start_register(Optional<URL::URL> scope_url, URL::URL script_url, GC::Ref<WebIDL::Promise> promise, EnvironmentSettingsObject& client, URL::URL referrer, Bindings::WorkerType worker_type, Bindings::ServiceWorkerUpdateViaCache update_via_cache)
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
diff --git a/Libraries/LibWeb/HTML/ServiceWorkerContainer.h b/Libraries/LibWeb/HTML/ServiceWorkerContainer.h
index 707a9db1979..e640ee2ef8d 100644
--- a/Libraries/LibWeb/HTML/ServiceWorkerContainer.h
+++ b/Libraries/LibWeb/HTML/ServiceWorkerContainer.h
@@ -28,13 +28,13 @@ struct RegistrationOptions {
 
 class ServiceWorkerContainer : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(ServiceWorkerContainer, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(ServiceWorkerContainer);
+    GC_DECLARE_ALLOCATOR(ServiceWorkerContainer);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ServiceWorkerContainer> create(JS::Realm& realm);
+    [[nodiscard]] static GC::Ref<ServiceWorkerContainer> create(JS::Realm& realm);
     virtual ~ServiceWorkerContainer() override;
 
-    JS::NonnullGCPtr<WebIDL::Promise> register_(String script_url, RegistrationOptions const& options);
+    GC::Ref<WebIDL::Promise> register_(String script_url, RegistrationOptions const& options);
 
 #undef __ENUMERATE
 #define __ENUMERATE(attribute_name, event_name)       \
@@ -49,9 +49,9 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    void start_register(Optional<URL::URL> scope_url, URL::URL script_url, JS::NonnullGCPtr<WebIDL::Promise>, EnvironmentSettingsObject&, URL::URL referrer, Bindings::WorkerType, Bindings::ServiceWorkerUpdateViaCache);
+    void start_register(Optional<URL::URL> scope_url, URL::URL script_url, GC::Ref<WebIDL::Promise>, EnvironmentSettingsObject&, URL::URL referrer, Bindings::WorkerType, Bindings::ServiceWorkerUpdateViaCache);
 
-    JS::NonnullGCPtr<EnvironmentSettingsObject> m_service_worker_client;
+    GC::Ref<EnvironmentSettingsObject> m_service_worker_client;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/ServiceWorkerRegistration.cpp b/Libraries/LibWeb/HTML/ServiceWorkerRegistration.cpp
index 15bc0cb2a7d..d7e50e81c78 100644
--- a/Libraries/LibWeb/HTML/ServiceWorkerRegistration.cpp
+++ b/Libraries/LibWeb/HTML/ServiceWorkerRegistration.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ServiceWorkerRegistration);
+GC_DEFINE_ALLOCATOR(ServiceWorkerRegistration);
 
 ServiceWorkerRegistration::ServiceWorkerRegistration(JS::Realm& realm)
     : DOM::EventTarget(realm)
@@ -24,7 +24,7 @@ void ServiceWorkerRegistration::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(ServiceWorkerRegistration);
 }
 
-JS::NonnullGCPtr<ServiceWorkerRegistration> ServiceWorkerRegistration::create(JS::Realm& realm)
+GC::Ref<ServiceWorkerRegistration> ServiceWorkerRegistration::create(JS::Realm& realm)
 {
     return realm.create<ServiceWorkerRegistration>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/ServiceWorkerRegistration.h b/Libraries/LibWeb/HTML/ServiceWorkerRegistration.h
index fb21d896529..12286782a56 100644
--- a/Libraries/LibWeb/HTML/ServiceWorkerRegistration.h
+++ b/Libraries/LibWeb/HTML/ServiceWorkerRegistration.h
@@ -12,10 +12,10 @@ namespace Web::HTML {
 
 class ServiceWorkerRegistration : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(ServiceWorkerRegistration, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(ServiceWorkerRegistration);
+    GC_DECLARE_ALLOCATOR(ServiceWorkerRegistration);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ServiceWorkerRegistration> create(JS::Realm& realm);
+    [[nodiscard]] static GC::Ref<ServiceWorkerRegistration> create(JS::Realm& realm);
 
     explicit ServiceWorkerRegistration(JS::Realm&);
     virtual ~ServiceWorkerRegistration() override = default;
diff --git a/Libraries/LibWeb/HTML/SessionHistoryEntry.cpp b/Libraries/LibWeb/HTML/SessionHistoryEntry.cpp
index df6360a5b14..b85863618c9 100644
--- a/Libraries/LibWeb/HTML/SessionHistoryEntry.cpp
+++ b/Libraries/LibWeb/HTML/SessionHistoryEntry.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(SessionHistoryEntry);
+GC_DEFINE_ALLOCATOR(SessionHistoryEntry);
 
 void SessionHistoryEntry::visit_edges(Cell::Visitor& visitor)
 {
@@ -28,9 +28,9 @@ SessionHistoryEntry::SessionHistoryEntry()
 {
 }
 
-JS::NonnullGCPtr<SessionHistoryEntry> SessionHistoryEntry::clone() const
+GC::Ref<SessionHistoryEntry> SessionHistoryEntry::clone() const
 {
-    JS::NonnullGCPtr<SessionHistoryEntry> entry = *heap().allocate<SessionHistoryEntry>();
+    GC::Ref<SessionHistoryEntry> entry = *heap().allocate<SessionHistoryEntry>();
     entry->m_step = m_step;
     entry->m_url = m_url;
     entry->m_document_state = m_document_state->clone();
@@ -46,7 +46,7 @@ JS::NonnullGCPtr<SessionHistoryEntry> SessionHistoryEntry::clone() const
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#she-document
-JS::GCPtr<DOM::Document> SessionHistoryEntry::document() const
+GC::Ptr<DOM::Document> SessionHistoryEntry::document() const
 {
     // To get a session history entry's document, return its document state's document.
     if (!m_document_state)
diff --git a/Libraries/LibWeb/HTML/SessionHistoryEntry.h b/Libraries/LibWeb/HTML/SessionHistoryEntry.h
index 899a927ab3e..f2863a39ad0 100644
--- a/Libraries/LibWeb/HTML/SessionHistoryEntry.h
+++ b/Libraries/LibWeb/HTML/SessionHistoryEntry.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/WeakPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/PolicyContainers.h>
@@ -29,17 +29,17 @@ enum class ScrollRestorationMode {
 
 // https://html.spec.whatwg.org/multipage/history.html#session-history-entry
 class SessionHistoryEntry final : public JS::Cell {
-    JS_CELL(SessionHistoryEntry, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SessionHistoryEntry);
+    GC_CELL(SessionHistoryEntry, JS::Cell);
+    GC_DECLARE_ALLOCATOR(SessionHistoryEntry);
 
 public:
     SessionHistoryEntry();
 
-    JS::NonnullGCPtr<SessionHistoryEntry> clone() const;
+    GC::Ref<SessionHistoryEntry> clone() const;
 
     void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<DOM::Document> document() const;
+    GC::Ptr<DOM::Document> document() const;
 
     enum class Pending {
         Tag,
@@ -51,8 +51,8 @@ public:
     [[nodiscard]] URL::URL const& url() const { return m_url; }
     void set_url(URL::URL url) { m_url = move(url); }
 
-    [[nodiscard]] JS::GCPtr<HTML::DocumentState> document_state() const { return m_document_state; }
-    void set_document_state(JS::GCPtr<HTML::DocumentState> document_state) { m_document_state = document_state; }
+    [[nodiscard]] GC::Ptr<HTML::DocumentState> document_state() const { return m_document_state; }
+    void set_document_state(GC::Ptr<HTML::DocumentState> document_state) { m_document_state = document_state; }
 
     [[nodiscard]] SerializationRecord const& classic_history_api_state() const { return m_classic_history_api_state; }
     void set_classic_history_api_state(SerializationRecord classic_history_api_state) { m_classic_history_api_state = move(classic_history_api_state); }
@@ -75,8 +75,8 @@ public:
     [[nodiscard]] Optional<ByteString> const& browsing_context_name() const { return m_browsing_context_name; }
     void set_browsing_context_name(Optional<ByteString> browsing_context_name) { m_browsing_context_name = move(browsing_context_name); }
 
-    [[nodiscard]] JS::GCPtr<BrowsingContext> original_source_browsing_context() const { return m_original_source_browsing_context; }
-    void set_original_source_browsing_context(JS::GCPtr<BrowsingContext> original_source_browsing_context) { m_original_source_browsing_context = original_source_browsing_context; }
+    [[nodiscard]] GC::Ptr<BrowsingContext> original_source_browsing_context() const { return m_original_source_browsing_context; }
+    void set_original_source_browsing_context(GC::Ptr<BrowsingContext> original_source_browsing_context) { m_original_source_browsing_context = original_source_browsing_context; }
 
 private:
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#she-step
@@ -88,7 +88,7 @@ private:
     URL::URL m_url;
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#she-document-state
-    JS::GCPtr<HTML::DocumentState> m_document_state;
+    GC::Ptr<HTML::DocumentState> m_document_state;
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#she-classic-history-api-state
     // classic history API state, which is serialized state, initially StructuredSerializeForStorage(null).
@@ -123,7 +123,7 @@ private:
     // FIXME: persisted user state, which is implementation-defined, initially null
     // NOTE: This is where we could remember the state of form controls, for example.
 
-    JS::GCPtr<BrowsingContext> m_original_source_browsing_context;
+    GC::Ptr<BrowsingContext> m_original_source_browsing_context;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.cpp b/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.cpp
index 684cb624fa0..08be4579678 100644
--- a/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.cpp
+++ b/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.cpp
@@ -9,10 +9,10 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(SessionHistoryTraversalQueue);
-JS_DEFINE_ALLOCATOR(SessionHistoryTraversalQueueEntry);
+GC_DEFINE_ALLOCATOR(SessionHistoryTraversalQueue);
+GC_DEFINE_ALLOCATOR(SessionHistoryTraversalQueueEntry);
 
-JS::NonnullGCPtr<SessionHistoryTraversalQueueEntry> SessionHistoryTraversalQueueEntry::create(JS::VM& vm, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps, JS::GCPtr<HTML::Navigable> target_navigable)
+GC::Ref<SessionHistoryTraversalQueueEntry> SessionHistoryTraversalQueueEntry::create(JS::VM& vm, GC::Ref<GC::Function<void()>> steps, GC::Ptr<HTML::Navigable> target_navigable)
 {
     return vm.heap().allocate<SessionHistoryTraversalQueueEntry>(steps, target_navigable);
 }
@@ -46,7 +46,7 @@ void SessionHistoryTraversalQueue::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_queue);
 }
 
-void SessionHistoryTraversalQueue::append(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+void SessionHistoryTraversalQueue::append(GC::Ref<GC::Function<void()>> steps)
 {
     m_queue.append(SessionHistoryTraversalQueueEntry::create(vm(), steps, nullptr));
     if (!m_timer->is_active()) {
@@ -54,7 +54,7 @@ void SessionHistoryTraversalQueue::append(JS::NonnullGCPtr<JS::HeapFunction<void
     }
 }
 
-void SessionHistoryTraversalQueue::append_sync(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps, JS::GCPtr<Navigable> target_navigable)
+void SessionHistoryTraversalQueue::append_sync(GC::Ref<GC::Function<void()>> steps, GC::Ptr<Navigable> target_navigable)
 {
     m_queue.append(SessionHistoryTraversalQueueEntry::create(vm(), steps, target_navigable));
     if (!m_timer->is_active()) {
@@ -63,7 +63,7 @@ void SessionHistoryTraversalQueue::append_sync(JS::NonnullGCPtr<JS::HeapFunction
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#sync-navigations-jump-queue
-JS::GCPtr<SessionHistoryTraversalQueueEntry> SessionHistoryTraversalQueue::first_synchronous_navigation_steps_with_target_navigable_not_contained_in(HashTable<JS::NonnullGCPtr<Navigable>> const& set)
+GC::Ptr<SessionHistoryTraversalQueueEntry> SessionHistoryTraversalQueue::first_synchronous_navigation_steps_with_target_navigable_not_contained_in(HashTable<GC::Ref<Navigable>> const& set)
 {
     auto index = m_queue.find_first_index_if([&set](auto const& entry) -> bool {
         return (entry->target_navigable() != nullptr) && !set.contains(*entry->target_navigable());
diff --git a/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.h b/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.h
index c20f231cc89..0fb5eb5329f 100644
--- a/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.h
+++ b/Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.h
@@ -8,27 +8,27 @@
 
 #include <AK/Vector.h>
 #include <LibCore/Timer.h>
+#include <LibGC/CellAllocator.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
 
 struct SessionHistoryTraversalQueueEntry : public JS::Cell {
-    JS_CELL(SessionHistoryTraversalQueueEntry, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SessionHistoryTraversalQueueEntry);
+    GC_CELL(SessionHistoryTraversalQueueEntry, JS::Cell);
+    GC_DECLARE_ALLOCATOR(SessionHistoryTraversalQueueEntry);
 
 public:
-    static JS::NonnullGCPtr<SessionHistoryTraversalQueueEntry> create(JS::VM& vm, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps, JS::GCPtr<HTML::Navigable> target_navigable);
+    static GC::Ref<SessionHistoryTraversalQueueEntry> create(JS::VM& vm, GC::Ref<GC::Function<void()>> steps, GC::Ptr<HTML::Navigable> target_navigable);
 
-    JS::GCPtr<HTML::Navigable> target_navigable() const { return m_target_navigable; }
+    GC::Ptr<HTML::Navigable> target_navigable() const { return m_target_navigable; }
     void execute_steps() const { m_steps->function()(); }
 
 private:
-    SessionHistoryTraversalQueueEntry(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps, JS::GCPtr<HTML::Navigable> target_navigable)
+    SessionHistoryTraversalQueueEntry(GC::Ref<GC::Function<void()>> steps, GC::Ptr<HTML::Navigable> target_navigable)
         : m_steps(steps)
         , m_target_navigable(target_navigable)
     {
@@ -36,28 +36,28 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<JS::HeapFunction<void()>> m_steps;
-    JS::GCPtr<HTML::Navigable> m_target_navigable;
+    GC::Ref<GC::Function<void()>> m_steps;
+    GC::Ptr<HTML::Navigable> m_target_navigable;
 };
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#tn-session-history-traversal-queue
 class SessionHistoryTraversalQueue : public JS::Cell {
-    JS_CELL(SessionHistoryTraversalQueue, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SessionHistoryTraversalQueue);
+    GC_CELL(SessionHistoryTraversalQueue, JS::Cell);
+    GC_DECLARE_ALLOCATOR(SessionHistoryTraversalQueue);
 
 public:
     SessionHistoryTraversalQueue();
 
-    void append(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps);
-    void append_sync(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps, JS::GCPtr<Navigable> target_navigable);
+    void append(GC::Ref<GC::Function<void()>> steps);
+    void append_sync(GC::Ref<GC::Function<void()>> steps, GC::Ptr<Navigable> target_navigable);
 
     // https://html.spec.whatwg.org/multipage/browsing-the-web.html#sync-navigations-jump-queue
-    JS::GCPtr<SessionHistoryTraversalQueueEntry> first_synchronous_navigation_steps_with_target_navigable_not_contained_in(HashTable<JS::NonnullGCPtr<Navigable>> const&);
+    GC::Ptr<SessionHistoryTraversalQueueEntry> first_synchronous_navigation_steps_with_target_navigable_not_contained_in(HashTable<GC::Ref<Navigable>> const&);
 
 private:
     virtual void visit_edges(Cell::Visitor&) override;
 
-    Vector<JS::NonnullGCPtr<SessionHistoryTraversalQueueEntry>> m_queue;
+    Vector<GC::Ref<SessionHistoryTraversalQueueEntry>> m_queue;
     RefPtr<Core::Timer> m_timer;
     bool m_is_task_running { false };
 };
diff --git a/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.cpp b/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.cpp
index d26f006c48c..9f41f9281c8 100644
--- a/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.cpp
+++ b/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ShadowRealmGlobalScope);
+GC_DEFINE_ALLOCATOR(ShadowRealmGlobalScope);
 
 ShadowRealmGlobalScope::ShadowRealmGlobalScope(JS::Realm& realm)
     : DOM::EventTarget(realm)
@@ -19,7 +19,7 @@ ShadowRealmGlobalScope::ShadowRealmGlobalScope(JS::Realm& realm)
 
 ShadowRealmGlobalScope::~ShadowRealmGlobalScope() = default;
 
-JS::NonnullGCPtr<ShadowRealmGlobalScope> ShadowRealmGlobalScope::create(JS::Realm& realm)
+GC::Ref<ShadowRealmGlobalScope> ShadowRealmGlobalScope::create(JS::Realm& realm)
 {
     return realm.create<ShadowRealmGlobalScope>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.h b/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.h
index c18f1fc8d03..988da70cecb 100644
--- a/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.h
+++ b/Libraries/LibWeb/HTML/ShadowRealmGlobalScope.h
@@ -19,18 +19,18 @@ class ShadowRealmGlobalScope
     , public UniversalGlobalScopeMixin
     , public Bindings::ShadowRealmGlobalScopeGlobalMixin {
     WEB_PLATFORM_OBJECT(ShadowRealmGlobalScope, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(ShadowRealmGlobalScope);
+    GC_DECLARE_ALLOCATOR(ShadowRealmGlobalScope);
 
 public:
     virtual ~ShadowRealmGlobalScope() override;
 
-    static JS::NonnullGCPtr<ShadowRealmGlobalScope> create(JS::Realm&);
+    static GC::Ref<ShadowRealmGlobalScope> create(JS::Realm&);
 
     virtual Bindings::PlatformObject& this_impl() override { return *this; }
     virtual Bindings::PlatformObject const& this_impl() const override { return *this; }
 
     // https://whatpr.org/html/9893/webappapis.html#dom-shadowrealmglobalscope-self
-    JS::NonnullGCPtr<ShadowRealmGlobalScope> self()
+    GC::Ref<ShadowRealmGlobalScope> self()
     {
         // The self getter steps are to return this.
         return *this;
diff --git a/Libraries/LibWeb/HTML/SharedResourceRequest.cpp b/Libraries/LibWeb/HTML/SharedResourceRequest.cpp
index eb4425fb830..208c1396131 100644
--- a/Libraries/LibWeb/HTML/SharedResourceRequest.cpp
+++ b/Libraries/LibWeb/HTML/SharedResourceRequest.cpp
@@ -21,9 +21,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(SharedResourceRequest);
+GC_DEFINE_ALLOCATOR(SharedResourceRequest);
 
-JS::NonnullGCPtr<SharedResourceRequest> SharedResourceRequest::get_or_create(JS::Realm& realm, JS::NonnullGCPtr<Page> page, URL::URL const& url)
+GC::Ref<SharedResourceRequest> SharedResourceRequest::get_or_create(JS::Realm& realm, GC::Ref<Page> page, URL::URL const& url)
 {
     auto document = Bindings::principal_host_defined_environment_settings_object(realm).responsible_document();
     VERIFY(document);
@@ -35,7 +35,7 @@ JS::NonnullGCPtr<SharedResourceRequest> SharedResourceRequest::get_or_create(JS:
     return request;
 }
 
-SharedResourceRequest::SharedResourceRequest(JS::NonnullGCPtr<Page> page, URL::URL url, JS::NonnullGCPtr<DOM::Document> document)
+SharedResourceRequest::SharedResourceRequest(GC::Ref<Page> page, URL::URL url, GC::Ref<DOM::Document> document)
     : m_page(page)
     , m_url(move(url))
     , m_document(document)
@@ -64,35 +64,35 @@ void SharedResourceRequest::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_image_data);
 }
 
-JS::GCPtr<DecodedImageData> SharedResourceRequest::image_data() const
+GC::Ptr<DecodedImageData> SharedResourceRequest::image_data() const
 {
     return m_image_data;
 }
 
-JS::GCPtr<Fetch::Infrastructure::FetchController> SharedResourceRequest::fetch_controller()
+GC::Ptr<Fetch::Infrastructure::FetchController> SharedResourceRequest::fetch_controller()
 {
     return m_fetch_controller.ptr();
 }
 
-void SharedResourceRequest::set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller)
+void SharedResourceRequest::set_fetch_controller(GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller)
 {
     m_fetch_controller = move(fetch_controller);
 }
 
-void SharedResourceRequest::fetch_resource(JS::Realm& realm, JS::NonnullGCPtr<Fetch::Infrastructure::Request> request)
+void SharedResourceRequest::fetch_resource(JS::Realm& realm, GC::Ref<Fetch::Infrastructure::Request> request)
 {
     Fetch::Infrastructure::FetchAlgorithms::Input fetch_algorithms_input {};
-    fetch_algorithms_input.process_response = [this, &realm, request](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+    fetch_algorithms_input.process_response = [this, &realm, request](GC::Ref<Fetch::Infrastructure::Response> response) {
         // FIXME: If the response is CORS cross-origin, we must use its internal response to query any of its data. See:
         //        https://github.com/whatwg/html/issues/9355
         response = response->unsafe_response();
 
-        auto process_body = JS::create_heap_function(heap(), [this, request, response](ByteBuffer data) {
+        auto process_body = GC::create_function(heap(), [this, request, response](ByteBuffer data) {
             auto extracted_mime_type = response->header_list()->extract_mime_type();
             auto mime_type = extracted_mime_type.has_value() ? extracted_mime_type.value().essence().bytes_as_string_view() : StringView {};
             handle_successful_fetch(request->url(), mime_type, move(data));
         });
-        auto process_body_error = JS::create_heap_function(heap(), [this](JS::Value) {
+        auto process_body_error = GC::create_function(heap(), [this](JS::Value) {
             handle_failed_fetch();
         });
 
@@ -102,7 +102,7 @@ void SharedResourceRequest::fetch_resource(JS::Realm& realm, JS::NonnullGCPtr<Fe
             return;
         }
 
-        response->body()->fully_read(realm, process_body, process_body_error, JS::NonnullGCPtr { realm.global_object() });
+        response->body()->fully_read(realm, process_body, process_body_error, GC::Ref { realm.global_object() });
     };
 
     m_state = State::Fetching;
@@ -132,9 +132,9 @@ void SharedResourceRequest::add_callbacks(Function<void()> on_finish, Function<v
 
     Callbacks callbacks;
     if (on_finish)
-        callbacks.on_finish = JS::create_heap_function(vm().heap(), move(on_finish));
+        callbacks.on_finish = GC::create_function(vm().heap(), move(on_finish));
     if (on_fail)
-        callbacks.on_fail = JS::create_heap_function(vm().heap(), move(on_fail));
+        callbacks.on_fail = GC::create_function(vm().heap(), move(on_fail));
 
     m_callbacks.append(move(callbacks));
 }
@@ -157,7 +157,7 @@ void SharedResourceRequest::handle_successful_fetch(URL::URL const& url_string,
         return;
     }
 
-    auto handle_successful_bitmap_decode = [strong_this = JS::Handle(*this)](Web::Platform::DecodedImage& result) -> ErrorOr<void> {
+    auto handle_successful_bitmap_decode = [strong_this = GC::Root(*this)](Web::Platform::DecodedImage& result) -> ErrorOr<void> {
         Vector<AnimatedBitmapDecodedImageData::Frame> frames;
         for (auto& frame : result.frames) {
             frames.append(AnimatedBitmapDecodedImageData::Frame {
@@ -170,7 +170,7 @@ void SharedResourceRequest::handle_successful_fetch(URL::URL const& url_string,
         return {};
     };
 
-    auto handle_failed_decode = [strong_this = JS::Handle(*this)](Error&) -> void {
+    auto handle_failed_decode = [strong_this = GC::Root(*this)](Error&) -> void {
         strong_this->handle_failed_fetch();
     };
 
diff --git a/Libraries/LibWeb/HTML/SharedResourceRequest.h b/Libraries/LibWeb/HTML/SharedResourceRequest.h
index 62759b1f378..0fee5221eb9 100644
--- a/Libraries/LibWeb/HTML/SharedResourceRequest.h
+++ b/Libraries/LibWeb/HTML/SharedResourceRequest.h
@@ -8,31 +8,31 @@
 
 #include <AK/Error.h>
 #include <AK/OwnPtr.h>
+#include <LibGC/Function.h>
+#include <LibGC/Root.h>
 #include <LibGfx/Size.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
 
 class SharedResourceRequest final : public JS::Cell {
-    JS_CELL(SharedResourceRequest, JS::Cell);
-    JS_DECLARE_ALLOCATOR(SharedResourceRequest);
+    GC_CELL(SharedResourceRequest, JS::Cell);
+    GC_DECLARE_ALLOCATOR(SharedResourceRequest);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SharedResourceRequest> get_or_create(JS::Realm&, JS::NonnullGCPtr<Page>, URL::URL const&);
+    [[nodiscard]] static GC::Ref<SharedResourceRequest> get_or_create(JS::Realm&, GC::Ref<Page>, URL::URL const&);
 
     virtual ~SharedResourceRequest() override;
 
     URL::URL const& url() const { return m_url; }
 
-    [[nodiscard]] JS::GCPtr<DecodedImageData> image_data() const;
+    [[nodiscard]] GC::Ptr<DecodedImageData> image_data() const;
 
-    [[nodiscard]] JS::GCPtr<Fetch::Infrastructure::FetchController> fetch_controller();
-    void set_fetch_controller(JS::GCPtr<Fetch::Infrastructure::FetchController>);
+    [[nodiscard]] GC::Ptr<Fetch::Infrastructure::FetchController> fetch_controller();
+    void set_fetch_controller(GC::Ptr<Fetch::Infrastructure::FetchController>);
 
-    void fetch_resource(JS::Realm&, JS::NonnullGCPtr<Fetch::Infrastructure::Request>);
+    void fetch_resource(JS::Realm&, GC::Ref<Fetch::Infrastructure::Request>);
 
     void add_callbacks(Function<void()> on_finish, Function<void()> on_fail);
 
@@ -40,7 +40,7 @@ public:
     bool needs_fetching() const;
 
 private:
-    explicit SharedResourceRequest(JS::NonnullGCPtr<Page>, URL::URL, JS::NonnullGCPtr<DOM::Document>);
+    explicit SharedResourceRequest(GC::Ref<Page>, URL::URL, GC::Ref<DOM::Document>);
 
     virtual void finalize() override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
@@ -58,19 +58,19 @@ private:
 
     State m_state { State::New };
 
-    JS::NonnullGCPtr<Page> m_page;
+    GC::Ref<Page> m_page;
 
     struct Callbacks {
-        JS::GCPtr<JS::HeapFunction<void()>> on_finish;
-        JS::GCPtr<JS::HeapFunction<void()>> on_fail;
+        GC::Ptr<GC::Function<void()>> on_finish;
+        GC::Ptr<GC::Function<void()>> on_fail;
     };
     Vector<Callbacks> m_callbacks;
 
     URL::URL m_url;
-    JS::GCPtr<DecodedImageData> m_image_data;
-    JS::GCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ptr<DecodedImageData> m_image_data;
+    GC::Ptr<Fetch::Infrastructure::FetchController> m_fetch_controller;
 
-    JS::GCPtr<DOM::Document> m_document;
+    GC::Ptr<DOM::Document> m_document;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/SourceSnapshotParams.h b/Libraries/LibWeb/HTML/SourceSnapshotParams.h
index 52fbe887e8e..197257a8530 100644
--- a/Libraries/LibWeb/HTML/SourceSnapshotParams.h
+++ b/Libraries/LibWeb/HTML/SourceSnapshotParams.h
@@ -23,7 +23,7 @@ struct SourceSnapshotParams {
     bool allows_downloading;
 
     // an environment settings object, only to be used as a request client
-    JS::GCPtr<EnvironmentSettingsObject> fetch_client;
+    GC::Ptr<EnvironmentSettingsObject> fetch_client;
 
     // a policy container
     PolicyContainer source_policy_container;
diff --git a/Libraries/LibWeb/HTML/Storage.cpp b/Libraries/LibWeb/HTML/Storage.cpp
index 26a655d48f4..33f0f5ac75d 100644
--- a/Libraries/LibWeb/HTML/Storage.cpp
+++ b/Libraries/LibWeb/HTML/Storage.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Storage);
+GC_DEFINE_ALLOCATOR(Storage);
 
-JS::NonnullGCPtr<Storage> Storage::create(JS::Realm& realm)
+GC::Ref<Storage> Storage::create(JS::Realm& realm)
 {
     return realm.create<Storage>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/Storage.h b/Libraries/LibWeb/HTML/Storage.h
index fe505ba0e9c..33c115d52fb 100644
--- a/Libraries/LibWeb/HTML/Storage.h
+++ b/Libraries/LibWeb/HTML/Storage.h
@@ -15,10 +15,10 @@ namespace Web::HTML {
 
 class Storage : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Storage, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Storage);
+    GC_DECLARE_ALLOCATOR(Storage);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Storage> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Storage> create(JS::Realm&);
     ~Storage();
 
     size_t length() const;
diff --git a/Libraries/LibWeb/HTML/StructuredSerialize.cpp b/Libraries/LibWeb/HTML/StructuredSerialize.cpp
index caf683547b9..117cb63c17b 100644
--- a/Libraries/LibWeb/HTML/StructuredSerialize.cpp
+++ b/Libraries/LibWeb/HTML/StructuredSerialize.cpp
@@ -349,7 +349,7 @@ public:
         }
 
         // 25. Set memory[value] to serialized.
-        m_memory.set(make_handle(value), m_next_id++);
+        m_memory.set(make_root(value), m_next_id++);
 
         // 26. If deep is true, then:
         if (deep) {
@@ -797,7 +797,7 @@ public:
                 value = JS::DataView::create(*realm, &array_buffer, byte_length, byte_offset);
             } else {
                 u32 array_length = deserialize_primitive_type<u32>(m_serialized, m_position);
-                JS::GCPtr<JS::TypedArrayBase> typed_array_ptr;
+                GC::Ptr<JS::TypedArrayBase> typed_array_ptr;
 #define CREATE_TYPED_ARRAY(ClassName)       \
     if (constructor_name == #ClassName##sv) \
         typed_array_ptr = JS::ClassName::create(*realm, array_length, array_buffer);
@@ -974,10 +974,10 @@ public:
 private:
     JS::VM& m_vm;
     ReadonlySpan<u32> m_serialized;
-    JS::MarkedVector<JS::Value> m_memory; // Index -> JS value
+    GC::MarkedVector<JS::Value> m_memory; // Index -> JS value
     size_t m_position { 0 };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Bindings::PlatformObject>> create_serialized_type(StringView interface_name, JS::Realm& realm)
+    static WebIDL::ExceptionOr<GC::Ref<Bindings::PlatformObject>> create_serialized_type(StringView interface_name, JS::Realm& realm)
     {
         if (interface_name == "Blob"sv)
             return FileAPI::Blob::create(realm);
@@ -1024,37 +1024,37 @@ double deserialize_number_primitive(ReadonlySpan<u32> const& serialized, size_t&
     return deserialize_primitive_type<double>(serialized, position);
 }
 
-JS::NonnullGCPtr<JS::BooleanObject> deserialize_boolean_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+GC::Ref<JS::BooleanObject> deserialize_boolean_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto boolean_primitive = deserialize_boolean_primitive(serialized, position);
     return JS::BooleanObject::create(realm, boolean_primitive);
 }
 
-JS::NonnullGCPtr<JS::NumberObject> deserialize_number_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+GC::Ref<JS::NumberObject> deserialize_number_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto number_primitive = deserialize_number_primitive(serialized, position);
     return JS::NumberObject::create(realm, number_primitive);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::BigIntObject>> deserialize_big_int_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+WebIDL::ExceptionOr<GC::Ref<JS::BigIntObject>> deserialize_big_int_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto big_int_primitive = TRY(deserialize_big_int_primitive(realm.vm(), serialized, position));
     return JS::BigIntObject::create(realm, big_int_primitive);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::StringObject>> deserialize_string_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+WebIDL::ExceptionOr<GC::Ref<JS::StringObject>> deserialize_string_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto string_primitive = TRY(deserialize_string_primitive(realm.vm(), serialized, position));
     return JS::StringObject::create(realm, string_primitive, realm.intrinsics().string_prototype());
 }
 
-JS::NonnullGCPtr<JS::Date> deserialize_date_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+GC::Ref<JS::Date> deserialize_date_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto double_value = deserialize_primitive_type<double>(serialized, position);
     return JS::Date::create(realm, double_value);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::RegExpObject>> deserialize_reg_exp_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
+WebIDL::ExceptionOr<GC::Ref<JS::RegExpObject>> deserialize_reg_exp_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position)
 {
     auto pattern = TRY(deserialize_string_primitive(realm.vm(), serialized, position));
     auto flags = TRY(deserialize_string_primitive(realm.vm(), serialized, position));
@@ -1084,7 +1084,7 @@ WebIDL::ExceptionOr<String> deserialize_string(JS::VM& vm, ReadonlySpan<u32> vec
     return TRY_OR_THROW_OOM(vm, String::from_utf8(StringView { bytes }));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::PrimitiveString>> deserialize_string_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position)
+WebIDL::ExceptionOr<GC::Ref<JS::PrimitiveString>> deserialize_string_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position)
 {
     auto bytes = TRY(deserialize_bytes(vm, vector, position));
 
@@ -1093,7 +1093,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::PrimitiveString>> deserialize_string_pr
     }));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::BigInt>> deserialize_big_int_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position)
+WebIDL::ExceptionOr<GC::Ref<JS::BigInt>> deserialize_big_int_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position)
 {
     auto string = TRY(deserialize_string_primitive(vm, vector, position));
     auto string_view = TRY(Bindings::throw_dom_exception_if_needed(vm, [&string]() {
@@ -1104,7 +1104,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::BigInt>> deserialize_big_int_primitive(
 }
 
 // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializewithtransfer
-WebIDL::ExceptionOr<SerializedTransferRecord> structured_serialize_with_transfer(JS::VM& vm, JS::Value value, Vector<JS::Handle<JS::Object>> const& transfer_list)
+WebIDL::ExceptionOr<SerializedTransferRecord> structured_serialize_with_transfer(JS::VM& vm, JS::Value value, Vector<GC::Root<JS::Object>> const& transfer_list)
 {
     // 1. Let memory be an empty map.
     SerializationMemory memory = {};
@@ -1127,7 +1127,7 @@ WebIDL::ExceptionOr<SerializedTransferRecord> structured_serialize_with_transfer
         }
 
         // 4. Set memory[transferable] to { [[Type]]: an uninitialized value }.
-        memory.set(JS::make_handle(transferable_value), NumericLimits<u32>::max());
+        memory.set(GC::make_root(transferable_value), NumericLimits<u32>::max());
     }
 
     // 3. Let serialized be ? StructuredSerializeInternal(value, false, memory).
@@ -1198,7 +1198,7 @@ static bool is_interface_exposed_on_target_realm(u8 name, JS::Realm& realm)
     return false;
 }
 
-static WebIDL::ExceptionOr<JS::NonnullGCPtr<Bindings::PlatformObject>> create_transferred_value(TransferType name, JS::Realm& target_realm, TransferDataHolder& transfer_data_holder)
+static WebIDL::ExceptionOr<GC::Ref<Bindings::PlatformObject>> create_transferred_value(TransferType name, JS::Realm& target_realm, TransferDataHolder& transfer_data_holder)
 {
     switch (name) {
     case TransferType::MessagePort: {
@@ -1219,7 +1219,7 @@ WebIDL::ExceptionOr<DeserializedTransferRecord> structured_deserialize_with_tran
     auto memory = DeserializationMemory(vm.heap());
 
     // 2. Let transferredValues be a new empty List.
-    Vector<JS::Handle<JS::Object>> transferred_values;
+    Vector<GC::Root<JS::Object>> transferred_values;
 
     // 3. For each transferDataHolder of serializeWithTransferResult.[[TransferDataHolders]]:
     for (auto& transfer_data_holder : serialize_with_transfer_result.transfer_data_holders) {
@@ -1262,7 +1262,7 @@ WebIDL::ExceptionOr<DeserializedTransferRecord> structured_deserialize_with_tran
         memory.append(value);
 
         // 6. Append value to transferredValues.
-        transferred_values.append(JS::make_handle(value.as_object()));
+        transferred_values.append(GC::make_root(value.as_object()));
     }
 
     // 4. Let deserialized be ? StructuredDeserialize(serializeWithTransferResult.[[Serialized]], targetRealm, memory).
diff --git a/Libraries/LibWeb/HTML/StructuredSerialize.h b/Libraries/LibWeb/HTML/StructuredSerialize.h
index c68476a6f42..f38c0573672 100644
--- a/Libraries/LibWeb/HTML/StructuredSerialize.h
+++ b/Libraries/LibWeb/HTML/StructuredSerialize.h
@@ -23,8 +23,8 @@
 namespace Web::HTML {
 
 using SerializationRecord = Vector<u32>;
-using SerializationMemory = HashMap<JS::Handle<JS::Value>, u32>;
-using DeserializationMemory = JS::MarkedVector<JS::Value>;
+using SerializationMemory = HashMap<GC::Root<JS::Value>, u32>;
+using DeserializationMemory = GC::MarkedVector<JS::Value>;
 
 struct TransferDataHolder {
     Vector<u8> data;
@@ -38,7 +38,7 @@ struct SerializedTransferRecord {
 
 struct DeserializedTransferRecord {
     JS::Value deserialized;
-    Vector<JS::Handle<JS::Object>> transferred_values;
+    Vector<GC::Root<JS::Object>> transferred_values;
 };
 
 struct DeserializedRecord {
@@ -97,12 +97,12 @@ WebIDL::ExceptionOr<void> serialize_viewed_array_buffer(JS::VM& vm, Vector<u32>&
 
 bool deserialize_boolean_primitive(ReadonlySpan<u32> const& serialized, size_t& position);
 double deserialize_number_primitive(ReadonlySpan<u32> const& serialized, size_t& position);
-JS::NonnullGCPtr<JS::BooleanObject> deserialize_boolean_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
-JS::NonnullGCPtr<JS::NumberObject> deserialize_number_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::BigIntObject>> deserialize_big_int_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::StringObject>> deserialize_string_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
-JS::NonnullGCPtr<JS::Date> deserialize_date_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::RegExpObject>> deserialize_reg_exp_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+GC::Ref<JS::BooleanObject> deserialize_boolean_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+GC::Ref<JS::NumberObject> deserialize_number_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+WebIDL::ExceptionOr<GC::Ref<JS::BigIntObject>> deserialize_big_int_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+WebIDL::ExceptionOr<GC::Ref<JS::StringObject>> deserialize_string_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+GC::Ref<JS::Date> deserialize_date_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
+WebIDL::ExceptionOr<GC::Ref<JS::RegExpObject>> deserialize_reg_exp_object(JS::Realm& realm, ReadonlySpan<u32> const& serialized, size_t& position);
 
 template<typename T>
 requires(IsIntegral<T> || IsFloatingPoint<T> || IsEnum<T>)
@@ -119,10 +119,10 @@ T deserialize_primitive_type(ReadonlySpan<u32> const& serialized, size_t& positi
 
 WebIDL::ExceptionOr<ByteBuffer> deserialize_bytes(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
 WebIDL::ExceptionOr<String> deserialize_string(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::PrimitiveString>> deserialize_string_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::BigInt>> deserialize_big_int_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
+WebIDL::ExceptionOr<GC::Ref<JS::PrimitiveString>> deserialize_string_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
+WebIDL::ExceptionOr<GC::Ref<JS::BigInt>> deserialize_big_int_primitive(JS::VM& vm, ReadonlySpan<u32> vector, size_t& position);
 
-WebIDL::ExceptionOr<SerializedTransferRecord> structured_serialize_with_transfer(JS::VM& vm, JS::Value value, Vector<JS::Handle<JS::Object>> const& transfer_list);
+WebIDL::ExceptionOr<SerializedTransferRecord> structured_serialize_with_transfer(JS::VM& vm, JS::Value value, Vector<GC::Root<JS::Object>> const& transfer_list);
 WebIDL::ExceptionOr<DeserializedTransferRecord> structured_deserialize_with_transfer(JS::VM& vm, SerializedTransferRecord&);
 
 }
diff --git a/Libraries/LibWeb/HTML/StructuredSerializeOptions.h b/Libraries/LibWeb/HTML/StructuredSerializeOptions.h
index 7ea3b7db73f..b5ff8df1e1d 100644
--- a/Libraries/LibWeb/HTML/StructuredSerializeOptions.h
+++ b/Libraries/LibWeb/HTML/StructuredSerializeOptions.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#structuredserializeoptions
 struct StructuredSerializeOptions {
-    Vector<JS::Handle<JS::Object>> transfer;
+    Vector<GC::Root<JS::Object>> transfer;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/SubmitEvent.cpp b/Libraries/LibWeb/HTML/SubmitEvent.cpp
index 8e32ba57aee..097c38f6a94 100644
--- a/Libraries/LibWeb/HTML/SubmitEvent.cpp
+++ b/Libraries/LibWeb/HTML/SubmitEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(SubmitEvent);
+GC_DEFINE_ALLOCATOR(SubmitEvent);
 
-JS::NonnullGCPtr<SubmitEvent> SubmitEvent::create(JS::Realm& realm, FlyString const& event_name, SubmitEventInit const& event_init)
+GC::Ref<SubmitEvent> SubmitEvent::create(JS::Realm& realm, FlyString const& event_name, SubmitEventInit const& event_init)
 {
     return realm.create<SubmitEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<SubmitEvent>> SubmitEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, SubmitEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<SubmitEvent>> SubmitEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, SubmitEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/HTML/SubmitEvent.h b/Libraries/LibWeb/HTML/SubmitEvent.h
index ff4db0a5d09..2271f394772 100644
--- a/Libraries/LibWeb/HTML/SubmitEvent.h
+++ b/Libraries/LibWeb/HTML/SubmitEvent.h
@@ -12,20 +12,20 @@
 namespace Web::HTML {
 
 struct SubmitEventInit : public DOM::EventInit {
-    JS::GCPtr<HTMLElement> submitter;
+    GC::Ptr<HTMLElement> submitter;
 };
 
 class SubmitEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(SubmitEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(SubmitEvent);
+    GC_DECLARE_ALLOCATOR(SubmitEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SubmitEvent> create(JS::Realm&, FlyString const& event_name, SubmitEventInit const& event_init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<SubmitEvent>> construct_impl(JS::Realm&, FlyString const& event_name, SubmitEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<SubmitEvent> create(JS::Realm&, FlyString const& event_name, SubmitEventInit const& event_init);
+    static WebIDL::ExceptionOr<GC::Ref<SubmitEvent>> construct_impl(JS::Realm&, FlyString const& event_name, SubmitEventInit const& event_init);
 
     virtual ~SubmitEvent() override;
 
-    JS::GCPtr<HTMLElement> submitter() const { return m_submitter; }
+    GC::Ptr<HTMLElement> submitter() const { return m_submitter; }
 
 private:
     SubmitEvent(JS::Realm&, FlyString const& event_name, SubmitEventInit const& event_init);
@@ -33,7 +33,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<HTMLElement> m_submitter;
+    GC::Ptr<HTMLElement> m_submitter;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/TextMetrics.cpp b/Libraries/LibWeb/HTML/TextMetrics.cpp
index c12b21bacc8..135e37ef2d8 100644
--- a/Libraries/LibWeb/HTML/TextMetrics.cpp
+++ b/Libraries/LibWeb/HTML/TextMetrics.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TextMetrics);
+GC_DEFINE_ALLOCATOR(TextMetrics);
 
-JS::NonnullGCPtr<TextMetrics> TextMetrics::create(JS::Realm& realm)
+GC::Ref<TextMetrics> TextMetrics::create(JS::Realm& realm)
 {
     return realm.create<TextMetrics>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/TextMetrics.h b/Libraries/LibWeb/HTML/TextMetrics.h
index 4c392e701ac..7102a3f34ab 100644
--- a/Libraries/LibWeb/HTML/TextMetrics.h
+++ b/Libraries/LibWeb/HTML/TextMetrics.h
@@ -12,10 +12,10 @@ namespace Web::HTML {
 
 class TextMetrics : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TextMetrics, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TextMetrics);
+    GC_DECLARE_ALLOCATOR(TextMetrics);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<TextMetrics> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<TextMetrics> create(JS::Realm&);
 
     virtual ~TextMetrics() override;
 
diff --git a/Libraries/LibWeb/HTML/TextTrack.cpp b/Libraries/LibWeb/HTML/TextTrack.cpp
index ba6474cae48..eb7736c7a9d 100644
--- a/Libraries/LibWeb/HTML/TextTrack.cpp
+++ b/Libraries/LibWeb/HTML/TextTrack.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TextTrack);
+GC_DEFINE_ALLOCATOR(TextTrack);
 
-JS::NonnullGCPtr<TextTrack> TextTrack::create(JS::Realm& realm)
+GC::Ref<TextTrack> TextTrack::create(JS::Realm& realm)
 {
     return realm.create<TextTrack>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/TextTrack.h b/Libraries/LibWeb/HTML/TextTrack.h
index 6485d619b74..4b7f656f5d8 100644
--- a/Libraries/LibWeb/HTML/TextTrack.h
+++ b/Libraries/LibWeb/HTML/TextTrack.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/String.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/TextTrackPrototype.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/Forward.h>
@@ -18,7 +18,7 @@ namespace Web::HTML {
 
 class TextTrack final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(TextTrack, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(TextTrack);
+    GC_DECLARE_ALLOCATOR(TextTrack);
 
 public:
     // https://html.spec.whatwg.org/multipage/media.html#text-track-readiness-state
@@ -29,7 +29,7 @@ public:
         FailedToLoad,
     };
 
-    static JS::NonnullGCPtr<TextTrack> create(JS::Realm&);
+    static GC::Ref<TextTrack> create(JS::Realm&);
     virtual ~TextTrack() override;
 
     Bindings::TextTrackKind kind();
diff --git a/Libraries/LibWeb/HTML/TextTrackCue.cpp b/Libraries/LibWeb/HTML/TextTrackCue.cpp
index 5713c5e91f6..8b3c901a3f0 100644
--- a/Libraries/LibWeb/HTML/TextTrackCue.cpp
+++ b/Libraries/LibWeb/HTML/TextTrackCue.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TextTrackCue);
+GC_DEFINE_ALLOCATOR(TextTrackCue);
 
-TextTrackCue::TextTrackCue(JS::Realm& realm, JS::GCPtr<TextTrack> track)
+TextTrackCue::TextTrackCue(JS::Realm& realm, GC::Ptr<TextTrack> track)
     : DOM::EventTarget(realm)
     , m_track(track)
 {
diff --git a/Libraries/LibWeb/HTML/TextTrackCue.h b/Libraries/LibWeb/HTML/TextTrackCue.h
index 946e03f81f2..4f8ce6e5a99 100644
--- a/Libraries/LibWeb/HTML/TextTrackCue.h
+++ b/Libraries/LibWeb/HTML/TextTrackCue.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/TextTrack.h>
 
@@ -15,12 +15,12 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/media.html#texttrackcue
 class TextTrackCue : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(TextTrackCue, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(TextTrackCue);
+    GC_DECLARE_ALLOCATOR(TextTrackCue);
 
 public:
     virtual ~TextTrackCue() override;
 
-    JS::GCPtr<TextTrack> track() { return m_track; }
+    GC::Ptr<TextTrack> track() { return m_track; }
 
     String const& id() const { return m_identifier; }
     void set_id(String const& id) { m_identifier = id; }
@@ -41,12 +41,12 @@ public:
     void set_onexit(WebIDL::CallbackType*);
 
 protected:
-    TextTrackCue(JS::Realm&, JS::GCPtr<TextTrack>);
+    TextTrackCue(JS::Realm&, GC::Ptr<TextTrack>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor&) override;
 
-    JS::GCPtr<TextTrack> m_track;
+    GC::Ptr<TextTrack> m_track;
 
     // https://html.spec.whatwg.org/multipage/media.html#text-track-cue-identifier
     String m_identifier;
diff --git a/Libraries/LibWeb/HTML/TextTrackCueList.cpp b/Libraries/LibWeb/HTML/TextTrackCueList.cpp
index b39c63f2b5a..a1acea2b076 100644
--- a/Libraries/LibWeb/HTML/TextTrackCueList.cpp
+++ b/Libraries/LibWeb/HTML/TextTrackCueList.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TextTrackCueList);
+GC_DEFINE_ALLOCATOR(TextTrackCueList);
 
 TextTrackCueList::TextTrackCueList(JS::Realm& realm)
     : DOM::EventTarget(realm, MayInterfereWithIndexedPropertyAccess::Yes)
@@ -58,7 +58,7 @@ size_t TextTrackCueList::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-texttrackcuelist-getcuebyid
-JS::GCPtr<TextTrackCue> TextTrackCueList::get_cue_by_id(StringView id) const
+GC::Ptr<TextTrackCue> TextTrackCueList::get_cue_by_id(StringView id) const
 {
     // The getCueById(id) method, when called with an argument other than the empty string, must return the first text track cue in the list
     // represented by the TextTrackCueList object whose text track cue identifier is id, if any, or null otherwise. If the argument is the
diff --git a/Libraries/LibWeb/HTML/TextTrackCueList.h b/Libraries/LibWeb/HTML/TextTrackCueList.h
index 5ee286c59a4..4d33a0441df 100644
--- a/Libraries/LibWeb/HTML/TextTrackCueList.h
+++ b/Libraries/LibWeb/HTML/TextTrackCueList.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/TextTrackCue.h>
 
@@ -15,14 +15,14 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/media.html#texttrackcuelist
 class TextTrackCueList final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(TextTrackCueList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(TextTrackCueList);
+    GC_DECLARE_ALLOCATOR(TextTrackCueList);
 
 public:
     virtual ~TextTrackCueList() override;
 
     size_t length() const;
 
-    JS::GCPtr<TextTrackCue> get_cue_by_id(StringView id) const;
+    GC::Ptr<TextTrackCue> get_cue_by_id(StringView id) const;
 
 private:
     TextTrackCueList(JS::Realm&);
@@ -32,7 +32,7 @@ private:
 
     virtual JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> internal_get_own_property(JS::PropertyKey const& property_name) const override;
 
-    Vector<JS::NonnullGCPtr<TextTrackCue>> m_cues;
+    Vector<GC::Ref<TextTrackCue>> m_cues;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/TextTrackList.cpp b/Libraries/LibWeb/HTML/TextTrackList.cpp
index ad0d85f357a..b211e04370c 100644
--- a/Libraries/LibWeb/HTML/TextTrackList.cpp
+++ b/Libraries/LibWeb/HTML/TextTrackList.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TextTrackList);
+GC_DEFINE_ALLOCATOR(TextTrackList);
 
 TextTrackList::TextTrackList(JS::Realm& realm)
     : DOM::EventTarget(realm, MayInterfereWithIndexedPropertyAccess::Yes)
@@ -57,7 +57,7 @@ size_t TextTrackList::length() const
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-texttracklist-gettrackbyid
-JS::GCPtr<TextTrack> TextTrackList::get_track_by_id(StringView id) const
+GC::Ptr<TextTrack> TextTrackList::get_track_by_id(StringView id) const
 {
     // The getTrackById(id) method must return the first TextTrack in the TextTrackList object whose id
     // IDL attribute would return a value equal to the value of the id argument.
diff --git a/Libraries/LibWeb/HTML/TextTrackList.h b/Libraries/LibWeb/HTML/TextTrackList.h
index 5b63a578d9d..c1c820d12e8 100644
--- a/Libraries/LibWeb/HTML/TextTrackList.h
+++ b/Libraries/LibWeb/HTML/TextTrackList.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/TextTrack.h>
 
@@ -14,14 +14,14 @@ namespace Web::HTML {
 
 class TextTrackList final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(TextTrackList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(TextTrackList);
+    GC_DECLARE_ALLOCATOR(TextTrackList);
 
 public:
     virtual ~TextTrackList() override;
 
     size_t length() const;
 
-    JS::GCPtr<TextTrack> get_track_by_id(StringView id) const;
+    GC::Ptr<TextTrack> get_track_by_id(StringView id) const;
 
     void set_onchange(WebIDL::CallbackType*);
     WebIDL::CallbackType* onchange();
@@ -40,7 +40,7 @@ private:
 
     virtual JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> internal_get_own_property(JS::PropertyKey const& property_name) const override;
 
-    Vector<JS::NonnullGCPtr<TextTrack>> m_text_tracks;
+    Vector<GC::Ref<TextTrack>> m_text_tracks;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/TimeRanges.cpp b/Libraries/LibWeb/HTML/TimeRanges.cpp
index 0256fb2b0d7..c5d6c2fdd96 100644
--- a/Libraries/LibWeb/HTML/TimeRanges.cpp
+++ b/Libraries/LibWeb/HTML/TimeRanges.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TimeRanges);
+GC_DEFINE_ALLOCATOR(TimeRanges);
 
 TimeRanges::TimeRanges(JS::Realm& realm)
     : Base(realm)
diff --git a/Libraries/LibWeb/HTML/TimeRanges.h b/Libraries/LibWeb/HTML/TimeRanges.h
index bf4e3d4bbe6..e1d08b4cefa 100644
--- a/Libraries/LibWeb/HTML/TimeRanges.h
+++ b/Libraries/LibWeb/HTML/TimeRanges.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 
 class TimeRanges final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TimeRanges, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TimeRanges);
+    GC_DECLARE_ALLOCATOR(TimeRanges);
 
 public:
     size_t length() const;
diff --git a/Libraries/LibWeb/HTML/Timer.cpp b/Libraries/LibWeb/HTML/Timer.cpp
index cc2b48f107e..7023a00b81d 100644
--- a/Libraries/LibWeb/HTML/Timer.cpp
+++ b/Libraries/LibWeb/HTML/Timer.cpp
@@ -11,15 +11,15 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Timer);
+GC_DEFINE_ALLOCATOR(Timer);
 
-JS::NonnullGCPtr<Timer> Timer::create(JS::Object& window_or_worker_global_scope, i32 milliseconds, Function<void()> callback, i32 id)
+GC::Ref<Timer> Timer::create(JS::Object& window_or_worker_global_scope, i32 milliseconds, Function<void()> callback, i32 id)
 {
-    auto heap_function_callback = JS::create_heap_function(window_or_worker_global_scope.heap(), move(callback));
+    auto heap_function_callback = GC::create_function(window_or_worker_global_scope.heap(), move(callback));
     return window_or_worker_global_scope.heap().allocate<Timer>(window_or_worker_global_scope, milliseconds, heap_function_callback, id);
 }
 
-Timer::Timer(JS::Object& window_or_worker_global_scope, i32 milliseconds, JS::NonnullGCPtr<JS::HeapFunction<void()>> callback, i32 id)
+Timer::Timer(JS::Object& window_or_worker_global_scope, i32 milliseconds, GC::Ref<GC::Function<void()>> callback, i32 id)
     : m_window_or_worker_global_scope(window_or_worker_global_scope)
     , m_callback(move(callback))
     , m_id(id)
diff --git a/Libraries/LibWeb/HTML/Timer.h b/Libraries/LibWeb/HTML/Timer.h
index 57fac1ad3e6..c87aac0f680 100644
--- a/Libraries/LibWeb/HTML/Timer.h
+++ b/Libraries/LibWeb/HTML/Timer.h
@@ -10,32 +10,32 @@
 #include <AK/Function.h>
 #include <AK/WeakPtr.h>
 #include <LibCore/Forward.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::HTML {
 
 class Timer final : public JS::Cell {
-    JS_CELL(Timer, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Timer);
+    GC_CELL(Timer, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Timer);
 
 public:
-    static JS::NonnullGCPtr<Timer> create(JS::Object&, i32 milliseconds, Function<void()> callback, i32 id);
+    static GC::Ref<Timer> create(JS::Object&, i32 milliseconds, Function<void()> callback, i32 id);
     virtual ~Timer() override;
 
     void start();
     void stop();
 
 private:
-    Timer(JS::Object& window, i32 milliseconds, JS::NonnullGCPtr<JS::HeapFunction<void()>> callback, i32 id);
+    Timer(JS::Object& window, i32 milliseconds, GC::Ref<GC::Function<void()>> callback, i32 id);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
     RefPtr<Core::Timer> m_timer;
-    JS::NonnullGCPtr<JS::Object> m_window_or_worker_global_scope;
-    JS::NonnullGCPtr<JS::HeapFunction<void()>> m_callback;
+    GC::Ref<JS::Object> m_window_or_worker_global_scope;
+    GC::Ref<GC::Function<void()>> m_callback;
     i32 m_id { 0 };
 };
 
diff --git a/Libraries/LibWeb/HTML/ToggleEvent.cpp b/Libraries/LibWeb/HTML/ToggleEvent.cpp
index fe11f74636b..89ea363ae31 100644
--- a/Libraries/LibWeb/HTML/ToggleEvent.cpp
+++ b/Libraries/LibWeb/HTML/ToggleEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ToggleEvent);
+GC_DEFINE_ALLOCATOR(ToggleEvent);
 
-JS::NonnullGCPtr<ToggleEvent> ToggleEvent::create(JS::Realm& realm, FlyString const& event_name, ToggleEventInit event_init)
+GC::Ref<ToggleEvent> ToggleEvent::create(JS::Realm& realm, FlyString const& event_name, ToggleEventInit event_init)
 {
     return realm.create<ToggleEvent>(realm, event_name, move(event_init));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ToggleEvent>> ToggleEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ToggleEventInit event_init)
+WebIDL::ExceptionOr<GC::Ref<ToggleEvent>> ToggleEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ToggleEventInit event_init)
 {
     return create(realm, event_name, move(event_init));
 }
diff --git a/Libraries/LibWeb/HTML/ToggleEvent.h b/Libraries/LibWeb/HTML/ToggleEvent.h
index f70882e6a98..cadabcdb28e 100644
--- a/Libraries/LibWeb/HTML/ToggleEvent.h
+++ b/Libraries/LibWeb/HTML/ToggleEvent.h
@@ -19,11 +19,11 @@ struct ToggleEventInit : public DOM::EventInit {
 
 class ToggleEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(ToggleEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(ToggleEvent);
+    GC_DECLARE_ALLOCATOR(ToggleEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ToggleEvent> create(JS::Realm&, FlyString const& event_name, ToggleEventInit = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ToggleEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ToggleEventInit);
+    [[nodiscard]] static GC::Ref<ToggleEvent> create(JS::Realm&, FlyString const& event_name, ToggleEventInit = {});
+    static WebIDL::ExceptionOr<GC::Ref<ToggleEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ToggleEventInit);
 
     // https://html.spec.whatwg.org/multipage/interaction.html#dom-toggleevent-oldstate
     String const& old_state() const { return m_old_state; }
diff --git a/Libraries/LibWeb/HTML/TrackEvent.cpp b/Libraries/LibWeb/HTML/TrackEvent.cpp
index 736c8aea57b..fe3ba0462d1 100644
--- a/Libraries/LibWeb/HTML/TrackEvent.cpp
+++ b/Libraries/LibWeb/HTML/TrackEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TrackEvent);
+GC_DEFINE_ALLOCATOR(TrackEvent);
 
-JS::NonnullGCPtr<TrackEvent> TrackEvent::create(JS::Realm& realm, FlyString const& event_name, TrackEventInit event_init)
+GC::Ref<TrackEvent> TrackEvent::create(JS::Realm& realm, FlyString const& event_name, TrackEventInit event_init)
 {
     return realm.create<TrackEvent>(realm, event_name, move(event_init));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TrackEvent>> TrackEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, TrackEventInit event_init)
+WebIDL::ExceptionOr<GC::Ref<TrackEvent>> TrackEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, TrackEventInit event_init)
 {
     return create(realm, event_name, move(event_init));
 }
@@ -34,7 +34,7 @@ void TrackEvent::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(TrackEvent);
 }
 
-Variant<Empty, JS::Handle<VideoTrack>, JS::Handle<AudioTrack>, JS::Handle<TextTrack>> TrackEvent::track() const
+Variant<Empty, GC::Root<VideoTrack>, GC::Root<AudioTrack>, GC::Root<TextTrack>> TrackEvent::track() const
 {
     // FIXME: This is a bit awkward. When creating a nullable union, our IDL generator creates a type of
     //        Optional<Variant<...>>, using an empty Optional to represent null. But when retrieving the
diff --git a/Libraries/LibWeb/HTML/TrackEvent.h b/Libraries/LibWeb/HTML/TrackEvent.h
index 043c4b5d498..fe062afe851 100644
--- a/Libraries/LibWeb/HTML/TrackEvent.h
+++ b/Libraries/LibWeb/HTML/TrackEvent.h
@@ -9,26 +9,26 @@
 #include <AK/FlyString.h>
 #include <AK/Optional.h>
 #include <AK/Variant.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/Event.h>
 
 namespace Web::HTML {
 
 struct TrackEventInit : public DOM::EventInit {
-    using TrackType = Optional<Variant<JS::Handle<VideoTrack>, JS::Handle<AudioTrack>, JS::Handle<TextTrack>>>;
+    using TrackType = Optional<Variant<GC::Root<VideoTrack>, GC::Root<AudioTrack>, GC::Root<TextTrack>>>;
     TrackType track;
 };
 
 class TrackEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(TrackEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(TrackEvent);
+    GC_DECLARE_ALLOCATOR(TrackEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<TrackEvent> create(JS::Realm&, FlyString const& event_name, TrackEventInit = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TrackEvent>> construct_impl(JS::Realm&, FlyString const& event_name, TrackEventInit);
+    [[nodiscard]] static GC::Ref<TrackEvent> create(JS::Realm&, FlyString const& event_name, TrackEventInit = {});
+    static WebIDL::ExceptionOr<GC::Ref<TrackEvent>> construct_impl(JS::Realm&, FlyString const& event_name, TrackEventInit);
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-trackevent-track
-    Variant<Empty, JS::Handle<VideoTrack>, JS::Handle<AudioTrack>, JS::Handle<TextTrack>> track() const;
+    Variant<Empty, GC::Root<VideoTrack>, GC::Root<AudioTrack>, GC::Root<TextTrack>> track() const;
 
 private:
     TrackEvent(JS::Realm&, FlyString const& event_name, TrackEventInit event_init);
diff --git a/Libraries/LibWeb/HTML/TraversableNavigable.cpp b/Libraries/LibWeb/HTML/TraversableNavigable.cpp
index dd46f7c0e3a..bd3e2cb4e97 100644
--- a/Libraries/LibWeb/HTML/TraversableNavigable.cpp
+++ b/Libraries/LibWeb/HTML/TraversableNavigable.cpp
@@ -22,9 +22,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(TraversableNavigable);
+GC_DEFINE_ALLOCATOR(TraversableNavigable);
 
-TraversableNavigable::TraversableNavigable(JS::NonnullGCPtr<Page> page)
+TraversableNavigable::TraversableNavigable(GC::Ref<Page> page)
     : Navigable(page)
     , m_session_history_traversal_queue(vm().heap().allocate<SessionHistoryTraversalQueue>())
 {
@@ -66,7 +66,7 @@ static OrderedHashTable<TraversableNavigable*>& user_agent_top_level_traversable
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-browsing-context
-WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_context_and_document(JS::NonnullGCPtr<Page> page)
+WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_context_and_document(GC::Ref<Page> page)
 {
     // 1. Let group and document be the result of creating a new browsing context group and document.
     auto [group, document] = TRY(BrowsingContextGroup::create_a_new_browsing_context_group_and_document(page));
@@ -76,12 +76,12 @@ WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#creating-a-new-top-level-traversable
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable::create_a_new_top_level_traversable(JS::NonnullGCPtr<Page> page, JS::GCPtr<HTML::BrowsingContext> opener, String target_name)
+WebIDL::ExceptionOr<GC::Ref<TraversableNavigable>> TraversableNavigable::create_a_new_top_level_traversable(GC::Ref<Page> page, GC::Ptr<HTML::BrowsingContext> opener, String target_name)
 {
     auto& vm = Bindings::main_thread_vm();
 
     // 1. Let document be null.
-    JS::GCPtr<DOM::Document> document = nullptr;
+    GC::Ptr<DOM::Document> document = nullptr;
 
     // 2. If opener is null, then set document to the second return value of creating a new top-level browsing context and document.
     if (!opener) {
@@ -137,7 +137,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable
 }
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#create-a-fresh-top-level-traversable
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable::create_a_fresh_top_level_traversable(JS::NonnullGCPtr<Page> page, URL::URL const& initial_navigation_url, Variant<Empty, String, POSTResource> initial_navigation_post_resource)
+WebIDL::ExceptionOr<GC::Ref<TraversableNavigable>> TraversableNavigable::create_a_fresh_top_level_traversable(GC::Ref<Page> page, URL::URL const& initial_navigation_url, Variant<Empty, String, POSTResource> initial_navigation_post_resource)
 {
     // 1. Let traversable be the result of creating a new top-level traversable given null and the empty string.
     auto traversable = TRY(create_a_new_top_level_traversable(page, nullptr, {}));
@@ -147,7 +147,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> TraversableNavigable
     //         Skip the initial navigation as well. This matches the behavior of the window open steps.
 
     if (url_matches_about_blank(initial_navigation_url)) {
-        Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(traversable->heap(), [traversable, initial_navigation_url] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(traversable->heap(), [traversable, initial_navigation_url] {
             // FIXME: We do this other places too when creating a new about:blank document. Perhaps it's worth a spec issue?
             HTML::HTMLParser::the_end(*traversable->active_document());
 
@@ -184,7 +184,7 @@ Vector<int> TraversableNavigable::get_all_used_history_steps() const
     OrderedHashTable<int> steps;
 
     // 3. Let entryLists be the ordered set « traversable's session history entries ».
-    Vector<Vector<JS::NonnullGCPtr<SessionHistoryEntry>>> entry_lists { session_history_entries() };
+    Vector<Vector<GC::Ref<SessionHistoryEntry>>> entry_lists { session_history_entries() };
 
     // 4. For each entryList of entryLists:
     while (!entry_lists.is_empty()) {
@@ -249,13 +249,13 @@ int TraversableNavigable::get_the_used_step(int step) const
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#get-all-navigables-whose-current-session-history-entry-will-change-or-reload
-Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_whose_current_session_history_entry_will_change_or_reload(int target_step) const
+Vector<GC::Root<Navigable>> TraversableNavigable::get_all_navigables_whose_current_session_history_entry_will_change_or_reload(int target_step) const
 {
     // 1. Let results be an empty list.
-    Vector<JS::Handle<Navigable>> results;
+    Vector<GC::Root<Navigable>> results;
 
     // 2. Let navigablesToCheck be « traversable ».
-    Vector<JS::Handle<Navigable>> navigables_to_check;
+    Vector<GC::Root<Navigable>> navigables_to_check;
     navigables_to_check.append(const_cast<TraversableNavigable&>(*this));
 
     // 3. For each navigable of navigablesToCheck:
@@ -281,16 +281,16 @@ Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_whose_cur
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-navigables-that-only-need-history-object-length/index-update
-Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_that_only_need_history_object_length_index_update(int target_step) const
+Vector<GC::Root<Navigable>> TraversableNavigable::get_all_navigables_that_only_need_history_object_length_index_update(int target_step) const
 {
     // NOTE: Other navigables might not be impacted by the traversal. For example, if the response is a 204, the currently active document will remain.
     //       Additionally, going 'back' after a 204 will change the current session history entry, but the active session history entry will already be correct.
 
     // 1. Let results be an empty list.
-    Vector<JS::Handle<Navigable>> results;
+    Vector<GC::Root<Navigable>> results;
 
     // 2. Let navigablesToCheck be « traversable ».
-    Vector<JS::Handle<Navigable>> navigables_to_check;
+    Vector<GC::Root<Navigable>> navigables_to_check;
     navigables_to_check.append(const_cast<TraversableNavigable&>(*this));
 
     // 3. For each navigable of navigablesToCheck:
@@ -315,7 +315,7 @@ Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_that_only
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#getting-all-navigables-that-might-experience-a-cross-document-traversal
-Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_that_might_experience_a_cross_document_traversal(int target_step) const
+Vector<GC::Root<Navigable>> TraversableNavigable::get_all_navigables_that_might_experience_a_cross_document_traversal(int target_step) const
 {
     // NOTE: From traversable's session history traversal queue's perspective, these documents are candidates for going cross-document during the
     //       traversal described by targetStep. They will not experience a cross-document traversal if the status code for their target document is
@@ -324,10 +324,10 @@ Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_that_migh
     //       Those would end up unloaded, not traversed.
 
     // 1. Let results be an empty list.
-    Vector<JS::Handle<Navigable>> results;
+    Vector<GC::Root<Navigable>> results;
 
     // 2. Let navigablesToCheck be « traversable ».
-    Vector<JS::Handle<Navigable>> navigables_to_check;
+    Vector<GC::Root<Navigable>> navigables_to_check;
     navigables_to_check.append(const_cast<TraversableNavigable&>(*this));
 
     // 3. For each navigable of navigablesToCheck:
@@ -357,7 +357,7 @@ Vector<JS::Handle<Navigable>> TraversableNavigable::get_all_navigables_that_migh
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#deactivate-a-document-for-a-cross-document-navigation
-static void deactivate_a_document_for_cross_document_navigation(JS::NonnullGCPtr<DOM::Document> displayed_document, Optional<UserNavigationInvolvement>, JS::NonnullGCPtr<SessionHistoryEntry> target_entry, JS::NonnullGCPtr<JS::HeapFunction<void()>> after_potential_unloads)
+static void deactivate_a_document_for_cross_document_navigation(GC::Ref<DOM::Document> displayed_document, Optional<UserNavigationInvolvement>, GC::Ref<SessionHistoryEntry> target_entry, GC::Ref<GC::Function<void()>> after_potential_unloads)
 {
     // 1. Let navigable be displayedDocument's node navigable.
     auto navigable = displayed_document->navigable();
@@ -400,15 +400,15 @@ static void deactivate_a_document_for_cross_document_navigation(JS::NonnullGCPtr
 }
 
 struct ChangingNavigableContinuationState : public JS::Cell {
-    JS_CELL(ChangingNavigableContinuationState, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ChangingNavigableContinuationState);
+    GC_CELL(ChangingNavigableContinuationState, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ChangingNavigableContinuationState);
 
-    JS::GCPtr<DOM::Document> displayed_document;
-    JS::GCPtr<SessionHistoryEntry> target_entry;
-    JS::GCPtr<Navigable> navigable;
+    GC::Ptr<DOM::Document> displayed_document;
+    GC::Ptr<SessionHistoryEntry> target_entry;
+    GC::Ptr<Navigable> navigable;
     bool update_only = false;
 
-    JS::GCPtr<SessionHistoryEntry> populated_target_entry;
+    GC::Ptr<SessionHistoryEntry> populated_target_entry;
     bool populated_cloned_target_session_history_entry = false;
 
     virtual void visit_edges(Cell::Visitor& visitor) override
@@ -421,14 +421,14 @@ struct ChangingNavigableContinuationState : public JS::Cell {
     }
 };
 
-JS_DEFINE_ALLOCATOR(ChangingNavigableContinuationState);
+GC_DEFINE_ALLOCATOR(ChangingNavigableContinuationState);
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#apply-the-history-step
 TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_step(
     int step,
     bool check_for_cancelation,
     IGNORE_USE_IN_ESCAPING_LAMBDA Optional<SourceSnapshotParams> source_snapshot_params,
-    JS::GCPtr<Navigable> initiator_to_check,
+    GC::Ptr<Navigable> initiator_to_check,
     Optional<UserNavigationInvolvement> user_involvement_for_navigate_events,
     IGNORE_USE_IN_ESCAPING_LAMBDA Optional<Bindings::NavigationType> navigation_type,
     IGNORE_USE_IN_ESCAPING_LAMBDA SynchronousNavigation synchronous_navigation)
@@ -494,13 +494,13 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
 
     // 11. Let changingNavigableContinuations be an empty queue of changing navigable continuation states.
     // NOTE: This queue is used to split the operations on changingNavigables into two parts. Specifically, changingNavigableContinuations holds data for the second part.
-    IGNORE_USE_IN_ESCAPING_LAMBDA Queue<JS::Handle<ChangingNavigableContinuationState>> changing_navigable_continuations;
+    IGNORE_USE_IN_ESCAPING_LAMBDA Queue<GC::Root<ChangingNavigableContinuationState>> changing_navigable_continuations;
 
     // 12. For each navigable of changingNavigables, queue a global task on the navigation and traversal task source of navigable's active window to run the steps:
     for (auto& navigable : changing_navigables) {
         if (!navigable->active_window())
             continue;
-        queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), JS::create_heap_function(heap(), [&] {
+        queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), GC::create_function(heap(), [&] {
             // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
             if (navigable->has_been_destroyed()) {
                 completed_change_jobs++;
@@ -580,7 +580,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
                 navigation->fire_a_traverse_navigate_event(*target_entry, *user_involvement_for_navigate_events);
             }
 
-            auto after_document_populated = [old_origin, changing_navigable_continuation, &changing_navigable_continuations, &vm, &navigable](bool populated_cloned_target_she, JS::NonnullGCPtr<SessionHistoryEntry> target_entry) mutable {
+            auto after_document_populated = [old_origin, changing_navigable_continuation, &changing_navigable_continuations, &vm, &navigable](bool populated_cloned_target_she, GC::Ref<SessionHistoryEntry> target_entry) mutable {
                 changing_navigable_continuation->populated_target_entry = target_entry;
                 changing_navigable_continuation->populated_cloned_target_session_history_entry = populated_cloned_target_she;
 
@@ -643,10 +643,10 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
                 // 7. In parallel, attempt to populate the history entry's document for targetEntry, given navigable, potentiallyTargetSpecificSourceSnapshotParams,
                 //    targetSnapshotParams, with allowPOST set to allowPOST and completionSteps set to queue a global task on the navigation and traversal task source given
                 //    navigable's active window to run afterDocumentPopulated.
-                Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(this->heap(), [populated_target_entry, potentially_target_specific_source_snapshot_params, target_snapshot_params, this, allow_POST, navigable, after_document_populated = JS::create_heap_function(this->heap(), move(after_document_populated))] {
-                    navigable->populate_session_history_entry_document(populated_target_entry, *potentially_target_specific_source_snapshot_params, target_snapshot_params, {}, Empty {}, CSPNavigationType::Other, allow_POST, JS::create_heap_function(this->heap(), [this, after_document_populated, populated_target_entry]() mutable {
+                Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(this->heap(), [populated_target_entry, potentially_target_specific_source_snapshot_params, target_snapshot_params, this, allow_POST, navigable, after_document_populated = GC::create_function(this->heap(), move(after_document_populated))] {
+                    navigable->populate_session_history_entry_document(populated_target_entry, *potentially_target_specific_source_snapshot_params, target_snapshot_params, {}, Empty {}, CSPNavigationType::Other, allow_POST, GC::create_function(this->heap(), [this, after_document_populated, populated_target_entry]() mutable {
                                  VERIFY(active_window());
-                                 queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), JS::create_heap_function(this->heap(), [after_document_populated, populated_target_entry]() mutable {
+                                 queue_global_task(Task::Source::NavigationAndTraversal, *active_window(), GC::create_function(this->heap(), [after_document_populated, populated_target_entry]() mutable {
                                      after_document_populated->function()(true, populated_target_entry);
                                  }));
                              }))
@@ -660,7 +660,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
         }));
     }
 
-    auto check_if_document_population_tasks_completed = JS::create_heap_function(heap(), [&] {
+    auto check_if_document_population_tasks_completed = GC::create_function(heap(), [&] {
         return changing_navigable_continuations.size() + completed_change_jobs == total_change_jobs;
     });
 
@@ -673,7 +673,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
     }
 
     // 13. Let navigablesThatMustWaitBeforeHandlingSyncNavigation be an empty set.
-    HashTable<JS::NonnullGCPtr<Navigable>> navigables_that_must_wait_before_handling_sync_navigation;
+    HashTable<GC::Ref<Navigable>> navigables_that_must_wait_before_handling_sync_navigation;
 
     // 14. While completedChangeJobs does not equal totalChangeJobs:
     while (!changing_navigable_continuations.is_empty()) {
@@ -711,7 +711,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
         auto displayed_document = changing_navigable_continuation->displayed_document;
 
         // 5. Let targetEntry be changingNavigableContinuation's target entry.
-        JS::GCPtr<SessionHistoryEntry> const populated_target_entry = changing_navigable_continuation->populated_target_entry;
+        GC::Ptr<SessionHistoryEntry> const populated_target_entry = changing_navigable_continuation->populated_target_entry;
 
         // 6. Let navigable be changingNavigableContinuation's navigable.
         auto navigable = changing_navigable_continuation->navigable;
@@ -739,9 +739,9 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
 
         // 12. In both cases, let afterPotentialUnloads be the following steps:
         bool const update_only = changing_navigable_continuation->update_only;
-        JS::GCPtr<SessionHistoryEntry> const target_entry = changing_navigable_continuation->target_entry;
+        GC::Ptr<SessionHistoryEntry> const target_entry = changing_navigable_continuation->target_entry;
         bool const populated_cloned_target_session_history_entry = changing_navigable_continuation->populated_cloned_target_session_history_entry;
-        auto after_potential_unload = JS::create_heap_function(this->heap(), [navigable, update_only, target_entry, populated_target_entry, populated_cloned_target_session_history_entry, displayed_document, &completed_change_jobs, script_history_length, script_history_index, entries_for_navigation_api = move(entries_for_navigation_api), &heap = this->heap(), navigation_type] {
+        auto after_potential_unload = GC::create_function(this->heap(), [navigable, update_only, target_entry, populated_target_entry, populated_cloned_target_session_history_entry, displayed_document, &completed_change_jobs, script_history_length, script_history_index, entries_for_navigation_api = move(entries_for_navigation_api), &heap = this->heap(), navigation_type] {
             if (populated_cloned_target_session_history_entry) {
                 target_entry->set_document_state(populated_target_entry->document_state());
                 target_entry->set_url(populated_target_entry->url());
@@ -749,7 +749,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
             }
 
             // 1. Let previousEntry be navigable's active session history entry.
-            JS::GCPtr<SessionHistoryEntry> const previous_entry = navigable->active_session_history_entry();
+            GC::Ptr<SessionHistoryEntry> const previous_entry = navigable->active_session_history_entry();
 
             // 2. If changingNavigableContinuation's update-only is false, then activate history entry targetEntry for navigable.
             if (!update_only)
@@ -768,7 +768,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
             }
             // 5. Otherwise, queue a global task on the navigation and traversal task source given targetEntry's document's relevant global object to perform updateDocument
             else {
-                queue_global_task(Task::Source::NavigationAndTraversal, relevant_global_object(*target_entry->document()), JS::create_heap_function(heap, move(update_document)));
+                queue_global_task(Task::Source::NavigationAndTraversal, relevant_global_object(*target_entry->document()), GC::create_function(heap, move(update_document)));
             }
 
             // 6. Increment completedChangeJobs.
@@ -794,7 +794,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
         }
     }
 
-    main_thread_event_loop().spin_processing_tasks_with_source_until(Task::Source::NavigationAndTraversal, JS::create_heap_function(heap(), [&] {
+    main_thread_event_loop().spin_processing_tasks_with_source_until(Task::Source::NavigationAndTraversal, GC::create_function(heap(), [&] {
         return completed_change_jobs == total_change_jobs;
     }));
 
@@ -821,7 +821,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
         }
 
         VERIFY(navigable->active_window());
-        queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), JS::create_heap_function(heap(), [&] {
+        queue_global_task(Task::Source::NavigationAndTraversal, *navigable->active_window(), GC::create_function(heap(), [&] {
             // NOTE: This check is not in the spec but we should not continue navigation if navigable has been destroyed.
             if (navigable->has_been_destroyed()) {
                 ++completed_non_changing_jobs;
@@ -846,7 +846,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
     // AD-HOC: Since currently populate_session_history_entry_document does not run in parallel
     //         we call spin_until to interrupt execution of this function and let document population
     //         to complete.
-    main_thread_event_loop().spin_processing_tasks_with_source_until(Task::Source::NavigationAndTraversal, JS::create_heap_function(heap(), [&] {
+    main_thread_event_loop().spin_processing_tasks_with_source_until(Task::Source::NavigationAndTraversal, GC::create_function(heap(), [&] {
         return completed_non_changing_jobs == total_non_changing_jobs;
     }));
 
@@ -867,13 +867,13 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_history_
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#checking-if-unloading-is-canceled
 TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::check_if_unloading_is_canceled(
-    Vector<JS::Handle<Navigable>> navigables_that_need_before_unload,
-    JS::GCPtr<TraversableNavigable> traversable,
+    Vector<GC::Root<Navigable>> navigables_that_need_before_unload,
+    GC::Ptr<TraversableNavigable> traversable,
     Optional<int> target_step,
     Optional<UserNavigationInvolvement> user_involvement_for_navigate_events)
 {
     // 1. Let documentsToFireBeforeunload be the active document of each item in navigablesThatNeedBeforeUnload.
-    Vector<JS::Handle<DOM::Document>> documents_to_fire_beforeunload;
+    Vector<GC::Root<DOM::Document>> documents_to_fire_beforeunload;
     for (auto& navigable : navigables_that_need_before_unload)
         documents_to_fire_beforeunload.append(navigable->active_document());
 
@@ -901,7 +901,7 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
             auto events_fired = false;
 
             // 3. Let needsBeforeunload be true if navigablesThatNeedBeforeUnload contains traversable; otherwise false.
-            auto it = navigables_that_need_before_unload.find_if([&traversable](JS::Handle<Navigable> navigable) {
+            auto it = navigables_that_need_before_unload.find_if([&traversable](GC::Root<Navigable> navigable) {
                 return navigable.ptr() == traversable.ptr();
             });
             auto needs_beforeunload = it != navigables_that_need_before_unload.end();
@@ -915,7 +915,7 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
 
             // 5. Queue a global task on the navigation and traversal task source given traversable's active window to perform the following steps:
             VERIFY(traversable->active_window());
-            queue_global_task(Task::Source::NavigationAndTraversal, *traversable->active_window(), JS::create_heap_function(heap(), [&] {
+            queue_global_task(Task::Source::NavigationAndTraversal, *traversable->active_window(), GC::create_function(heap(), [&] {
                 // 1. if needsBeforeunload is true, then:
                 if (needs_beforeunload) {
                     // 1. Let (unloadPromptShownForThisDocument, unloadPromptCanceledByThisDocument) be the result of running the steps to fire beforeunload given traversable's active document and false.
@@ -951,7 +951,7 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
             }));
 
             // 6. Wait for eventsFired to be true.
-            main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] {
+            main_thread_event_loop().spin_until(GC::create_function(heap(), [&] {
                 return events_fired;
             }));
 
@@ -969,7 +969,7 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
 
     // 7. For each document of documents, queue a global task on the navigation and traversal task source given document's relevant global object to run the steps:
     for (auto& document : documents_to_fire_beforeunload) {
-        queue_global_task(Task::Source::NavigationAndTraversal, relevant_global_object(*document), JS::create_heap_function(heap(), [&] {
+        queue_global_task(Task::Source::NavigationAndTraversal, relevant_global_object(*document), GC::create_function(heap(), [&] {
             // 1. Let (unloadPromptShownForThisDocument, unloadPromptCanceledByThisDocument) be the result of running the steps to fire beforeunload given document and unloadPromptShown.
             auto [unload_prompt_shown_for_this_document, unload_prompt_canceled_by_this_document] = document->steps_to_fire_beforeunload(unload_prompt_shown);
 
@@ -987,7 +987,7 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
     }
 
     // 8. Wait for completedTasks to be totalTasks.
-    main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] {
+    main_thread_event_loop().spin_until(GC::create_function(heap(), [&] {
         return completed_tasks == total_tasks;
     }));
 
@@ -995,12 +995,12 @@ TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::che
     return final_status;
 }
 
-TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::check_if_unloading_is_canceled(Vector<JS::Handle<Navigable>> navigables_that_need_before_unload)
+TraversableNavigable::CheckIfUnloadingIsCanceledResult TraversableNavigable::check_if_unloading_is_canceled(Vector<GC::Root<Navigable>> navigables_that_need_before_unload)
 {
     return check_if_unloading_is_canceled(navigables_that_need_before_unload, {}, {}, {});
 }
 
-Vector<JS::NonnullGCPtr<SessionHistoryEntry>> TraversableNavigable::get_session_history_entries_for_the_navigation_api(JS::NonnullGCPtr<Navigable> navigable, int target_step)
+Vector<GC::Ref<SessionHistoryEntry>> TraversableNavigable::get_session_history_entries_for_the_navigation_api(GC::Ref<Navigable> navigable, int target_step)
 {
     // 1. Let rawEntries be the result of getting session history entries for navigable.
     auto raw_entries = navigable->get_session_history_entries();
@@ -1009,7 +1009,7 @@ Vector<JS::NonnullGCPtr<SessionHistoryEntry>> TraversableNavigable::get_session_
         return {};
 
     // 2. Let entriesForNavigationAPI be a new empty list.
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>> entries_for_navigation_api;
+    Vector<GC::Ref<SessionHistoryEntry>> entries_for_navigation_api;
 
     // 3. Let startingIndex be the index of the session history entry in rawEntries who has the greatest step less than or equal to targetStep.
     // FIXME: Use min/max_element algorithm or some such here
@@ -1080,7 +1080,7 @@ void TraversableNavigable::clear_the_forward_session_history()
     auto step = current_session_history_step();
 
     // 3. Let entryLists be the ordered set « navigable's session history entries ».
-    Vector<Vector<JS::NonnullGCPtr<SessionHistoryEntry>>&> entry_lists;
+    Vector<Vector<GC::Ref<SessionHistoryEntry>>&> entry_lists;
     entry_lists.append(session_history_entries());
 
     // 4. For each entryList of entryLists:
@@ -1106,7 +1106,7 @@ bool TraversableNavigable::can_go_forward() const
 {
     auto step = current_session_history_step();
 
-    Vector<Vector<JS::NonnullGCPtr<SessionHistoryEntry>> const&> entry_lists;
+    Vector<Vector<GC::Ref<SessionHistoryEntry>> const&> entry_lists;
     entry_lists.append(session_history_entries());
 
     while (!entry_lists.is_empty()) {
@@ -1129,7 +1129,7 @@ void TraversableNavigable::traverse_the_history_by_delta(int delta, Optional<DOM
 {
     // 1. Let sourceSnapshotParams and initiatorToCheck be null.
     Optional<SourceSnapshotParams> source_snapshot_params = {};
-    JS::GCPtr<Navigable> initiator_to_check = nullptr;
+    GC::Ptr<Navigable> initiator_to_check = nullptr;
 
     // 2. Let userInvolvement be "browser UI".
     UserNavigationInvolvement user_involvement = UserNavigationInvolvement::BrowserUI;
@@ -1147,7 +1147,7 @@ void TraversableNavigable::traverse_the_history_by_delta(int delta, Optional<DOM
     }
 
     // 4. Append the following session history traversal steps to traversable:
-    append_session_history_traversal_steps(JS::create_heap_function(heap(), [this, delta, source_snapshot_params = move(source_snapshot_params), initiator_to_check, user_involvement] {
+    append_session_history_traversal_steps(GC::create_function(heap(), [this, delta, source_snapshot_params = move(source_snapshot_params), initiator_to_check, user_involvement] {
         // 1. Let allSteps be the result of getting all used history steps for traversable.
         auto all_steps = get_all_used_history_steps();
 
@@ -1195,7 +1195,7 @@ TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_push_or_
     return apply_the_history_step(step, false, {}, {}, {}, navigation_type, synchronous_navigation);
 }
 
-TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_traverse_history_step(int step, Optional<SourceSnapshotParams> source_snapshot_params, JS::GCPtr<Navigable> initiator_to_check, UserNavigationInvolvement user_involvement)
+TraversableNavigable::HistoryStepResult TraversableNavigable::apply_the_traverse_history_step(int step, Optional<SourceSnapshotParams> source_snapshot_params, GC::Ptr<Navigable> initiator_to_check, UserNavigationInvolvement user_involvement)
 {
     // 1. Return the result of applying the history step step to traversable given true, sourceSnapshotParams, initiatorToCheck, userInvolvement, and "traverse".
     return apply_the_history_step(step, true, move(source_snapshot_params), initiator_to_check, user_involvement, Bindings::NavigationType::Traverse, SynchronousNavigation::No);
@@ -1225,9 +1225,9 @@ void TraversableNavigable::definitely_close_top_level_traversable()
         return;
 
     // 3. Append the following session history traversal steps to traversable:
-    append_session_history_traversal_steps(JS::create_heap_function(heap(), [this] {
+    append_session_history_traversal_steps(GC::create_function(heap(), [this] {
         // 1. Let afterAllUnloads be an algorithm step which destroys traversable.
-        auto after_all_unloads = JS::create_heap_function(heap(), [this] {
+        auto after_all_unloads = GC::create_function(heap(), [this] {
             destroy_top_level_traversable();
         });
 
@@ -1274,7 +1274,7 @@ void TraversableNavigable::destroy_top_level_traversable()
 }
 
 // https://html.spec.whatwg.org/multipage/browsing-the-web.html#finalize-a-same-document-navigation
-void finalize_a_same_document_navigation(JS::NonnullGCPtr<TraversableNavigable> traversable, JS::NonnullGCPtr<Navigable> target_navigable, JS::NonnullGCPtr<SessionHistoryEntry> target_entry, JS::GCPtr<SessionHistoryEntry> entry_to_replace, HistoryHandlingBehavior history_handling)
+void finalize_a_same_document_navigation(GC::Ref<TraversableNavigable> traversable, GC::Ref<Navigable> target_navigable, GC::Ref<SessionHistoryEntry> target_entry, GC::Ptr<SessionHistoryEntry> entry_to_replace, HistoryHandlingBehavior history_handling)
 {
     // NOTE: This is not in the spec but we should not navigate destroyed navigable.
     if (target_navigable->has_been_destroyed())
@@ -1296,7 +1296,7 @@ void finalize_a_same_document_navigation(JS::NonnullGCPtr<TraversableNavigable>
     // 5. If entryToReplace is null, then:
     // FIXME: Checking containment of entryToReplace should not be needed.
     //        For more details see https://github.com/whatwg/html/issues/10232#issuecomment-2037543137
-    if (!entry_to_replace || !target_entries.contains_slow(JS::NonnullGCPtr { *entry_to_replace })) {
+    if (!entry_to_replace || !target_entries.contains_slow(GC::Ref { *entry_to_replace })) {
         // 1. Clear the forward session history of traversable.
         traversable->clear_the_forward_session_history();
 
@@ -1344,14 +1344,14 @@ void TraversableNavigable::set_system_visibility_state(VisibilityState visibilit
 
         // 2. Queue a global task on the user interaction task source given document's relevant global object
         //    to update the visibility state of document with newState.
-        queue_global_task(Task::Source::UserInteraction, relevant_global_object(*document), JS::create_heap_function(heap(), [visibility_state, document] {
+        queue_global_task(Task::Source::UserInteraction, relevant_global_object(*document), GC::create_function(heap(), [visibility_state, document] {
             document->update_the_visibility_state(visibility_state);
         }));
     }
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#currently-focused-area-of-a-top-level-traversable
-JS::GCPtr<DOM::Node> TraversableNavigable::currently_focused_area()
+GC::Ptr<DOM::Node> TraversableNavigable::currently_focused_area()
 {
     // 1. If traversable does not have system focus, then return null.
     if (!is_focused())
diff --git a/Libraries/LibWeb/HTML/TraversableNavigable.h b/Libraries/LibWeb/HTML/TraversableNavigable.h
index 6e824b9c8a6..5df8ac385a9 100644
--- a/Libraries/LibWeb/HTML/TraversableNavigable.h
+++ b/Libraries/LibWeb/HTML/TraversableNavigable.h
@@ -27,20 +27,20 @@ namespace Web::HTML {
 
 // https://html.spec.whatwg.org/multipage/document-sequences.html#traversable-navigable
 class TraversableNavigable final : public Navigable {
-    JS_CELL(TraversableNavigable, Navigable);
-    JS_DECLARE_ALLOCATOR(TraversableNavigable);
+    GC_CELL(TraversableNavigable, Navigable);
+    GC_DECLARE_ALLOCATOR(TraversableNavigable);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> create_a_new_top_level_traversable(JS::NonnullGCPtr<Page>, JS::GCPtr<BrowsingContext> opener, String target_name);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TraversableNavigable>> create_a_fresh_top_level_traversable(JS::NonnullGCPtr<Page>, URL::URL const& initial_navigation_url, Variant<Empty, String, POSTResource> = Empty {});
+    static WebIDL::ExceptionOr<GC::Ref<TraversableNavigable>> create_a_new_top_level_traversable(GC::Ref<Page>, GC::Ptr<BrowsingContext> opener, String target_name);
+    static WebIDL::ExceptionOr<GC::Ref<TraversableNavigable>> create_a_fresh_top_level_traversable(GC::Ref<Page>, URL::URL const& initial_navigation_url, Variant<Empty, String, POSTResource> = Empty {});
 
     virtual ~TraversableNavigable() override;
 
     virtual bool is_top_level_traversable() const override;
 
     int current_session_history_step() const { return m_current_session_history_step; }
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>>& session_history_entries() { return m_session_history_entries; }
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>> const& session_history_entries() const { return m_session_history_entries; }
+    Vector<GC::Ref<SessionHistoryEntry>>& session_history_entries() { return m_session_history_entries; }
+    Vector<GC::Ref<SessionHistoryEntry>> const& session_history_entries() const { return m_session_history_entries; }
     bool running_nested_apply_history_step() const { return m_running_nested_apply_history_step; }
 
     VisibilityState system_visibility_state() const { return m_system_visibility_state; }
@@ -59,7 +59,7 @@ public:
         Applied,
     };
 
-    HistoryStepResult apply_the_traverse_history_step(int, Optional<SourceSnapshotParams>, JS::GCPtr<Navigable>, UserNavigationInvolvement);
+    HistoryStepResult apply_the_traverse_history_step(int, Optional<SourceSnapshotParams>, GC::Ptr<Navigable>, UserNavigationInvolvement);
     HistoryStepResult apply_the_reload_history_step();
     enum class SynchronousNavigation : bool {
         Yes,
@@ -69,9 +69,9 @@ public:
     HistoryStepResult update_for_navigable_creation_or_destruction();
 
     int get_the_used_step(int step) const;
-    Vector<JS::Handle<Navigable>> get_all_navigables_whose_current_session_history_entry_will_change_or_reload(int) const;
-    Vector<JS::Handle<Navigable>> get_all_navigables_that_only_need_history_object_length_index_update(int) const;
-    Vector<JS::Handle<Navigable>> get_all_navigables_that_might_experience_a_cross_document_traversal(int) const;
+    Vector<GC::Root<Navigable>> get_all_navigables_whose_current_session_history_entry_will_change_or_reload(int) const;
+    Vector<GC::Root<Navigable>> get_all_navigables_that_only_need_history_object_length_index_update(int) const;
+    Vector<GC::Root<Navigable>> get_all_navigables_that_might_experience_a_cross_document_traversal(int) const;
 
     Vector<int> get_all_used_history_steps() const;
     void clear_the_forward_session_history();
@@ -81,12 +81,12 @@ public:
     void definitely_close_top_level_traversable();
     void destroy_top_level_traversable();
 
-    void append_session_history_traversal_steps(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+    void append_session_history_traversal_steps(GC::Ref<GC::Function<void()>> steps)
     {
         m_session_history_traversal_queue->append(steps);
     }
 
-    void append_session_history_synchronous_navigation_steps(JS::NonnullGCPtr<Navigable> target_navigable, JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+    void append_session_history_synchronous_navigation_steps(GC::Ref<Navigable> target_navigable, GC::Ref<GC::Function<void()>> steps)
     {
         m_session_history_traversal_queue->append_sync(steps, target_navigable);
     }
@@ -94,7 +94,7 @@ public:
     String window_handle() const { return m_window_handle; }
     void set_window_handle(String window_handle) { m_window_handle = move(window_handle); }
 
-    [[nodiscard]] JS::GCPtr<DOM::Node> currently_focused_area();
+    [[nodiscard]] GC::Ptr<DOM::Node> currently_focused_area();
 
     void paint(Web::DevicePixelRect const&, Painting::BackingStore&, Web::PaintOptions);
 
@@ -103,12 +103,12 @@ public:
         CanceledByNavigate,
         Continue,
     };
-    CheckIfUnloadingIsCanceledResult check_if_unloading_is_canceled(Vector<JS::Handle<Navigable>> navigables_that_need_before_unload);
+    CheckIfUnloadingIsCanceledResult check_if_unloading_is_canceled(Vector<GC::Root<Navigable>> navigables_that_need_before_unload);
 
     RefPtr<Gfx::SkiaBackendContext> skia_backend_context() const { return m_skia_backend_context; }
 
 private:
-    TraversableNavigable(JS::NonnullGCPtr<Page>);
+    TraversableNavigable(GC::Ref<Page>);
 
     virtual void visit_edges(Cell::Visitor&) override;
 
@@ -117,14 +117,14 @@ private:
         int step,
         bool check_for_cancelation,
         Optional<SourceSnapshotParams>,
-        JS::GCPtr<Navigable> initiator_to_check,
+        GC::Ptr<Navigable> initiator_to_check,
         Optional<UserNavigationInvolvement> user_involvement_for_navigate_events,
         Optional<Bindings::NavigationType> navigation_type,
         SynchronousNavigation);
 
-    CheckIfUnloadingIsCanceledResult check_if_unloading_is_canceled(Vector<JS::Handle<Navigable>> navigables_that_need_before_unload, JS::GCPtr<TraversableNavigable> traversable, Optional<int> target_step, Optional<UserNavigationInvolvement> user_involvement_for_navigate_events);
+    CheckIfUnloadingIsCanceledResult check_if_unloading_is_canceled(Vector<GC::Root<Navigable>> navigables_that_need_before_unload, GC::Ptr<TraversableNavigable> traversable, Optional<int> target_step, Optional<UserNavigationInvolvement> user_involvement_for_navigate_events);
 
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>> get_session_history_entries_for_the_navigation_api(JS::NonnullGCPtr<Navigable>, int);
+    Vector<GC::Ref<SessionHistoryEntry>> get_session_history_entries_for_the_navigation_api(GC::Ref<Navigable>, int);
 
     [[nodiscard]] bool can_go_forward() const;
 
@@ -132,7 +132,7 @@ private:
     int m_current_session_history_step { 0 };
 
     // https://html.spec.whatwg.org/multipage/document-sequences.html#tn-session-history-entries
-    Vector<JS::NonnullGCPtr<SessionHistoryEntry>> m_session_history_entries;
+    Vector<GC::Ref<SessionHistoryEntry>> m_session_history_entries;
 
     // FIXME: https://html.spec.whatwg.org/multipage/document-sequences.html#tn-session-history-traversal-queue
 
@@ -142,7 +142,7 @@ private:
     // https://html.spec.whatwg.org/multipage/document-sequences.html#system-visibility-state
     VisibilityState m_system_visibility_state { VisibilityState::Hidden };
 
-    JS::NonnullGCPtr<SessionHistoryTraversalQueue> m_session_history_traversal_queue;
+    GC::Ref<SessionHistoryTraversalQueue> m_session_history_traversal_queue;
 
     String m_window_handle;
 
@@ -154,11 +154,11 @@ private:
 };
 
 struct BrowsingContextAndDocument {
-    JS::NonnullGCPtr<HTML::BrowsingContext> browsing_context;
-    JS::NonnullGCPtr<DOM::Document> document;
+    GC::Ref<HTML::BrowsingContext> browsing_context;
+    GC::Ref<DOM::Document> document;
 };
 
-WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_context_and_document(JS::NonnullGCPtr<Page> page);
-void finalize_a_same_document_navigation(JS::NonnullGCPtr<TraversableNavigable> traversable, JS::NonnullGCPtr<Navigable> target_navigable, JS::NonnullGCPtr<SessionHistoryEntry> target_entry, JS::GCPtr<SessionHistoryEntry> entry_to_replace, HistoryHandlingBehavior);
+WebIDL::ExceptionOr<BrowsingContextAndDocument> create_a_new_top_level_browsing_context_and_document(GC::Ref<Page> page);
+void finalize_a_same_document_navigation(GC::Ref<TraversableNavigable> traversable, GC::Ref<Navigable> target_navigable, GC::Ref<SessionHistoryEntry> target_entry, GC::Ptr<SessionHistoryEntry> entry_to_replace, HistoryHandlingBehavior);
 
 }
diff --git a/Libraries/LibWeb/HTML/UniversalGlobalScope.cpp b/Libraries/LibWeb/HTML/UniversalGlobalScope.cpp
index 786bc98c797..771410c6f52 100644
--- a/Libraries/LibWeb/HTML/UniversalGlobalScope.cpp
+++ b/Libraries/LibWeb/HTML/UniversalGlobalScope.cpp
@@ -11,7 +11,7 @@
 #include <AK/String.h>
 #include <AK/Utf8View.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibWeb/HTML/Scripting/ExceptionReporter.h>
 #include <LibWeb/HTML/StructuredSerialize.h>
 #include <LibWeb/HTML/StructuredSerializeOptions.h>
@@ -71,12 +71,12 @@ void UniversalGlobalScopeMixin::queue_microtask(WebIDL::CallbackType& callback)
     auto& vm = this_impl().vm();
     auto& realm = *vm.current_realm();
 
-    JS::GCPtr<DOM::Document> document;
+    GC::Ptr<DOM::Document> document;
     if (is<Window>(this_impl()))
         document = &static_cast<Window&>(this_impl()).associated_document();
 
     // The queueMicrotask(callback) method must queue a microtask to invoke callback, and if callback throws an exception, report the exception.
-    HTML::queue_a_microtask(document, JS::create_heap_function(realm.heap(), [&callback, &realm] {
+    HTML::queue_a_microtask(document, GC::create_function(realm.heap(), [&callback, &realm] {
         auto result = WebIDL::invoke_callback(callback, {});
         if (result.is_error())
             HTML::report_exception(result, realm);
diff --git a/Libraries/LibWeb/HTML/UserActivation.cpp b/Libraries/LibWeb/HTML/UserActivation.cpp
index c062aedd106..83cf2d87cbd 100644
--- a/Libraries/LibWeb/HTML/UserActivation.cpp
+++ b/Libraries/LibWeb/HTML/UserActivation.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(UserActivation);
+GC_DEFINE_ALLOCATOR(UserActivation);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<UserActivation>> UserActivation::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<UserActivation>> UserActivation::construct_impl(JS::Realm& realm)
 {
     return realm.create<UserActivation>(realm);
 }
diff --git a/Libraries/LibWeb/HTML/UserActivation.h b/Libraries/LibWeb/HTML/UserActivation.h
index 916d6e55ca2..14a42f88253 100644
--- a/Libraries/LibWeb/HTML/UserActivation.h
+++ b/Libraries/LibWeb/HTML/UserActivation.h
@@ -12,10 +12,10 @@ namespace Web::HTML {
 
 class UserActivation final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(UserActivation, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(UserActivation);
+    GC_DECLARE_ALLOCATOR(UserActivation);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<UserActivation>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<UserActivation>> construct_impl(JS::Realm&);
     virtual ~UserActivation() override = default;
 
     bool has_been_active() const;
diff --git a/Libraries/LibWeb/HTML/ValidityState.cpp b/Libraries/LibWeb/HTML/ValidityState.cpp
index 00a80c3a6af..d9065b894b3 100644
--- a/Libraries/LibWeb/HTML/ValidityState.cpp
+++ b/Libraries/LibWeb/HTML/ValidityState.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(ValidityState);
+GC_DEFINE_ALLOCATOR(ValidityState);
 
 ValidityState::ValidityState(JS::Realm& realm)
     : PlatformObject(realm)
diff --git a/Libraries/LibWeb/HTML/ValidityState.h b/Libraries/LibWeb/HTML/ValidityState.h
index 8914630e649..3e9ff4f56ed 100644
--- a/Libraries/LibWeb/HTML/ValidityState.h
+++ b/Libraries/LibWeb/HTML/ValidityState.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#validitystate
 class ValidityState final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ValidityState, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ValidityState);
+    GC_DECLARE_ALLOCATOR(ValidityState);
 
 public:
     virtual ~ValidityState() override = default;
diff --git a/Libraries/LibWeb/HTML/VideoTrack.cpp b/Libraries/LibWeb/HTML/VideoTrack.cpp
index dcee7b26b2d..dcea273efd3 100644
--- a/Libraries/LibWeb/HTML/VideoTrack.cpp
+++ b/Libraries/LibWeb/HTML/VideoTrack.cpp
@@ -22,11 +22,11 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(VideoTrack);
+GC_DEFINE_ALLOCATOR(VideoTrack);
 
 static IDAllocator s_video_track_id_allocator;
 
-VideoTrack::VideoTrack(JS::Realm& realm, JS::NonnullGCPtr<HTMLMediaElement> media_element, NonnullOwnPtr<Media::PlaybackManager> playback_manager)
+VideoTrack::VideoTrack(JS::Realm& realm, GC::Ref<HTMLMediaElement> media_element, NonnullOwnPtr<Media::PlaybackManager> playback_manager)
     : PlatformObject(realm)
     , m_media_element(media_element)
     , m_playback_manager(move(playback_manager))
diff --git a/Libraries/LibWeb/HTML/VideoTrack.h b/Libraries/LibWeb/HTML/VideoTrack.h
index 1ed8b3e45ef..e8fec73f8f9 100644
--- a/Libraries/LibWeb/HTML/VideoTrack.h
+++ b/Libraries/LibWeb/HTML/VideoTrack.h
@@ -16,12 +16,12 @@ namespace Web::HTML {
 
 class VideoTrack final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(VideoTrack, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(VideoTrack);
+    GC_DECLARE_ALLOCATOR(VideoTrack);
 
 public:
     virtual ~VideoTrack() override;
 
-    void set_video_track_list(Badge<VideoTrackList>, JS::GCPtr<VideoTrackList> video_track_list) { m_video_track_list = video_track_list; }
+    void set_video_track_list(Badge<VideoTrackList>, GC::Ptr<VideoTrackList> video_track_list) { m_video_track_list = video_track_list; }
 
     void play_video(Badge<HTMLVideoElement>);
     void pause_video(Badge<HTMLVideoElement>);
@@ -43,7 +43,7 @@ public:
     void set_selected(bool selected);
 
 private:
-    VideoTrack(JS::Realm&, JS::NonnullGCPtr<HTMLMediaElement>, NonnullOwnPtr<Media::PlaybackManager>);
+    VideoTrack(JS::Realm&, GC::Ref<HTMLMediaElement>, NonnullOwnPtr<Media::PlaybackManager>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -63,8 +63,8 @@ private:
     // https://html.spec.whatwg.org/multipage/media.html#dom-videotrack-selected
     bool m_selected { false };
 
-    JS::NonnullGCPtr<HTMLMediaElement> m_media_element;
-    JS::GCPtr<VideoTrackList> m_video_track_list;
+    GC::Ref<HTMLMediaElement> m_media_element;
+    GC::Ptr<VideoTrackList> m_video_track_list;
 
     NonnullOwnPtr<Media::PlaybackManager> m_playback_manager;
 };
diff --git a/Libraries/LibWeb/HTML/VideoTrackList.cpp b/Libraries/LibWeb/HTML/VideoTrackList.cpp
index 94a4db00e2e..e39b5f22dc2 100644
--- a/Libraries/LibWeb/HTML/VideoTrackList.cpp
+++ b/Libraries/LibWeb/HTML/VideoTrackList.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(VideoTrackList);
+GC_DEFINE_ALLOCATOR(VideoTrackList);
 
 VideoTrackList::VideoTrackList(JS::Realm& realm)
     : DOM::EventTarget(realm, MayInterfereWithIndexedPropertyAccess::Yes)
@@ -44,7 +44,7 @@ JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> VideoTrackList::internal
     return Base::internal_get_own_property(property_name);
 }
 
-void VideoTrackList::add_track(Badge<HTMLMediaElement>, JS::NonnullGCPtr<VideoTrack> video_track)
+void VideoTrackList::add_track(Badge<HTMLMediaElement>, GC::Ref<VideoTrack> video_track)
 {
     m_video_tracks.append(video_track);
     video_track->set_video_track_list({}, this);
@@ -56,7 +56,7 @@ void VideoTrackList::remove_all_tracks(Badge<HTMLMediaElement>)
 }
 
 // https://html.spec.whatwg.org/multipage/media.html#dom-videotracklist-gettrackbyid
-JS::GCPtr<VideoTrack> VideoTrackList::get_track_by_id(StringView id) const
+GC::Ptr<VideoTrack> VideoTrackList::get_track_by_id(StringView id) const
 {
     // The AudioTrackList getTrackById(id) and VideoTrackList getTrackById(id) methods must return the first AudioTrack
     // or VideoTrack object (respectively) in the AudioTrackList or VideoTrackList object (respectively) whose identifier
diff --git a/Libraries/LibWeb/HTML/VideoTrackList.h b/Libraries/LibWeb/HTML/VideoTrackList.h
index 26374fdea84..46481a1bbad 100644
--- a/Libraries/LibWeb/HTML/VideoTrackList.h
+++ b/Libraries/LibWeb/HTML/VideoTrackList.h
@@ -8,7 +8,7 @@
 
 #include <AK/Badge.h>
 #include <AK/String.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/VideoTrack.h>
 
@@ -16,18 +16,18 @@ namespace Web::HTML {
 
 class VideoTrackList final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(VideoTrackList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(VideoTrackList);
+    GC_DECLARE_ALLOCATOR(VideoTrackList);
 
 public:
-    void add_track(Badge<HTMLMediaElement>, JS::NonnullGCPtr<VideoTrack>);
+    void add_track(Badge<HTMLMediaElement>, GC::Ref<VideoTrack>);
     void remove_all_tracks(Badge<HTMLMediaElement>);
 
-    Span<JS::NonnullGCPtr<VideoTrack>> video_tracks() { return m_video_tracks; }
+    Span<GC::Ref<VideoTrack>> video_tracks() { return m_video_tracks; }
 
     // https://html.spec.whatwg.org/multipage/media.html#dom-videotracklist-length
     size_t length() const { return m_video_tracks.size(); }
 
-    JS::GCPtr<VideoTrack> get_track_by_id(StringView id) const;
+    GC::Ptr<VideoTrack> get_track_by_id(StringView id) const;
     i32 selected_index() const;
 
     void set_onchange(WebIDL::CallbackType*);
@@ -47,7 +47,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual JS::ThrowCompletionOr<Optional<JS::PropertyDescriptor>> internal_get_own_property(JS::PropertyKey const& property_name) const override;
 
-    Vector<JS::NonnullGCPtr<VideoTrack>> m_video_tracks;
+    Vector<GC::Ref<VideoTrack>> m_video_tracks;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Window.cpp b/Libraries/LibWeb/HTML/Window.cpp
index bf23bf85024..e2c0cf1e68c 100644
--- a/Libraries/LibWeb/HTML/Window.cpp
+++ b/Libraries/LibWeb/HTML/Window.cpp
@@ -71,7 +71,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Window);
+GC_DEFINE_ALLOCATOR(Window);
 
 // https://html.spec.whatwg.org/#run-the-animation-frame-callbacks
 void run_animation_frame_callbacks(DOM::Document& document, double now)
@@ -82,22 +82,22 @@ void run_animation_frame_callbacks(DOM::Document& document, double now)
 
 class IdleCallback : public RefCounted<IdleCallback> {
 public:
-    explicit IdleCallback(ESCAPING Function<JS::Completion(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline>)> handler, u32 handle)
+    explicit IdleCallback(ESCAPING Function<JS::Completion(GC::Ref<RequestIdleCallback::IdleDeadline>)> handler, u32 handle)
         : m_handler(move(handler))
         , m_handle(handle)
     {
     }
     ~IdleCallback() = default;
 
-    JS::Completion invoke(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline> deadline) { return m_handler(deadline); }
+    JS::Completion invoke(GC::Ref<RequestIdleCallback::IdleDeadline> deadline) { return m_handler(deadline); }
     u32 handle() const { return m_handle; }
 
 private:
-    Function<JS::Completion(JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline>)> m_handler;
+    Function<JS::Completion(GC::Ref<RequestIdleCallback::IdleDeadline>)> m_handler;
     u32 m_handle { 0 };
 };
 
-JS::NonnullGCPtr<Window> Window::create(JS::Realm& realm)
+GC::Ref<Window> Window::create(JS::Realm& realm)
 {
     return realm.create<Window>(realm);
 }
@@ -141,7 +141,7 @@ void Window::finalize()
 Window::~Window() = default;
 
 // https://html.spec.whatwg.org/multipage/window-object.html#window-open-steps
-WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> Window::window_open_steps(StringView url, StringView target, StringView features)
+WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> Window::window_open_steps(StringView url, StringView target, StringView features)
 {
     auto [target_navigable, no_opener, window_type] = TRY(window_open_steps_internal(url, target, features));
     if (target_navigable == nullptr)
@@ -433,25 +433,25 @@ void Window::fire_a_page_transition_event(FlyString const& event_name, bool pers
 }
 
 // https://html.spec.whatwg.org/multipage/webstorage.html#dom-localstorage
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> Window::local_storage()
+WebIDL::ExceptionOr<GC::Ref<Storage>> Window::local_storage()
 {
     // FIXME: Implement according to spec.
-    static HashMap<URL::Origin, JS::Handle<Storage>> local_storage_per_origin;
-    auto storage = local_storage_per_origin.ensure(associated_document().origin(), [this]() -> JS::Handle<Storage> {
+    static HashMap<URL::Origin, GC::Root<Storage>> local_storage_per_origin;
+    auto storage = local_storage_per_origin.ensure(associated_document().origin(), [this]() -> GC::Root<Storage> {
         return Storage::create(realm());
     });
-    return JS::NonnullGCPtr { *storage };
+    return GC::Ref { *storage };
 }
 
 // https://html.spec.whatwg.org/multipage/webstorage.html#dom-sessionstorage
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> Window::session_storage()
+WebIDL::ExceptionOr<GC::Ref<Storage>> Window::session_storage()
 {
     // FIXME: Implement according to spec.
-    static HashMap<URL::Origin, JS::Handle<Storage>> session_storage_per_origin;
-    auto storage = session_storage_per_origin.ensure(associated_document().origin(), [this]() -> JS::Handle<Storage> {
+    static HashMap<URL::Origin, GC::Root<Storage>> session_storage_per_origin;
+    auto storage = session_storage_per_origin.ensure(associated_document().origin(), [this]() -> GC::Root<Storage> {
         return Storage::create(realm());
     });
-    return JS::NonnullGCPtr { *storage };
+    return GC::Ref { *storage };
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#sticky-activation
@@ -514,7 +514,7 @@ void Window::consume_history_action_user_activation()
     auto navigables = top->active_document()->inclusive_descendant_navigables();
 
     // 4. Let windows be the list of Window objects constructed by taking the active window of each item in navigables.
-    JS::MarkedVector<JS::GCPtr<Window>> windows(heap());
+    GC::MarkedVector<GC::Ptr<Window>> windows(heap());
     for (auto& n : navigables)
         windows.append(n->active_window());
 
@@ -539,7 +539,7 @@ void Window::consume_user_activation()
     auto navigables = top->active_document()->inclusive_descendant_navigables();
 
     // 4. Let windows be the list of Window objects constructed by taking the active window of each item in navigables.
-    JS::MarkedVector<JS::GCPtr<Window>> windows(heap());
+    GC::MarkedVector<GC::Ptr<Window>> windows(heap());
     for (auto& n : navigables)
         windows.append(n->active_window());
 
@@ -569,7 +569,7 @@ void Window::start_an_idle_period()
 
     // 5. Queue a task on the queue associated with the idle-task task source,
     //    which performs the steps defined in the invoke idle callbacks algorithm with window and getDeadline as parameters.
-    queue_global_task(Task::Source::IdleTask, *this, JS::create_heap_function(heap(), [this] {
+    queue_global_task(Task::Source::IdleTask, *this, GC::create_function(heap(), [this] {
         invoke_idle_callbacks();
     }));
 }
@@ -593,7 +593,7 @@ void Window::invoke_idle_callbacks()
             report_exception(result, realm());
         // 4. If window's list of runnable idle callbacks is not empty, queue a task which performs the steps
         //    in the invoke idle callbacks algorithm with getDeadline and window as a parameters and return from this algorithm
-        queue_global_task(Task::Source::IdleTask, *this, JS::create_heap_function(heap(), [this] {
+        queue_global_task(Task::Source::IdleTask, *this, GC::create_function(heap(), [this] {
             invoke_idle_callbacks();
         }));
     }
@@ -620,14 +620,14 @@ BrowsingContext* Window::browsing_context()
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#window-navigable
-JS::GCPtr<Navigable> Window::navigable() const
+GC::Ptr<Navigable> Window::navigable() const
 {
     // A Window's navigable is the navigable whose active document is the Window's associated Document's, or null if there is no such navigable.
     return Navigable::navigable_with_active_document(*m_associated_document);
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-objects
-Vector<JS::NonnullGCPtr<Plugin>> Window::pdf_viewer_plugin_objects()
+Vector<GC::Ref<Plugin>> Window::pdf_viewer_plugin_objects()
 {
     // Each Window object has a PDF viewer plugin objects list. If the user agent's PDF viewer supported is false, then it is the empty list.
     // Otherwise, it is a list containing five Plugin objects, whose names are, respectively:
@@ -653,7 +653,7 @@ Vector<JS::NonnullGCPtr<Plugin>> Window::pdf_viewer_plugin_objects()
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-type-objects
-Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()
+Vector<GC::Ref<MimeType>> Window::pdf_viewer_mime_type_objects()
 {
     // Each Window object has a PDF viewer mime type objects list. If the user agent's PDF viewer supported is false, then it is the empty list.
     // Otherwise, it is a list containing two MimeType objects, whose types are, respectively:
@@ -672,7 +672,7 @@ Vector<JS::NonnullGCPtr<MimeType>> Window::pdf_viewer_mime_type_objects()
 }
 
 // https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
-JS::NonnullGCPtr<WebIDL::CallbackType> Window::count_queuing_strategy_size_function()
+GC::Ref<WebIDL::CallbackType> Window::count_queuing_strategy_size_function()
 {
     auto& realm = this->realm();
 
@@ -690,11 +690,11 @@ JS::NonnullGCPtr<WebIDL::CallbackType> Window::count_queuing_strategy_size_funct
         m_count_queuing_strategy_size_function = realm.create<WebIDL::CallbackType>(*function, relevant_settings_object(*this));
     }
 
-    return JS::NonnullGCPtr { *m_count_queuing_strategy_size_function };
+    return GC::Ref { *m_count_queuing_strategy_size_function };
 }
 
 // https://streams.spec.whatwg.org/#byte-length-queuing-strategy-size-function
-JS::NonnullGCPtr<WebIDL::CallbackType> Window::byte_length_queuing_strategy_size_function()
+GC::Ref<WebIDL::CallbackType> Window::byte_length_queuing_strategy_size_function()
 {
     auto& realm = this->realm();
 
@@ -714,7 +714,7 @@ JS::NonnullGCPtr<WebIDL::CallbackType> Window::byte_length_queuing_strategy_size
         m_byte_length_queuing_strategy_size_function = realm.create<WebIDL::CallbackType>(*function, relevant_settings_object(*this));
     }
 
-    return JS::NonnullGCPtr { *m_byte_length_queuing_strategy_size_function };
+    return GC::Ref { *m_byte_length_queuing_strategy_size_function };
 }
 
 static bool s_inspector_object_exposed = false;
@@ -756,21 +756,21 @@ JS::ThrowCompletionOr<bool> Window::internal_set_prototype_of(JS::Object* protot
 }
 
 // https://html.spec.whatwg.org/multipage/window-object.html#dom-window
-JS::NonnullGCPtr<WindowProxy> Window::window() const
+GC::Ref<WindowProxy> Window::window() const
 {
     // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
     return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
 }
 
 // https://html.spec.whatwg.org/multipage/window-object.html#dom-self
-JS::NonnullGCPtr<WindowProxy> Window::self() const
+GC::Ref<WindowProxy> Window::self() const
 {
     // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
     return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-document-2
-JS::NonnullGCPtr<DOM::Document const> Window::document() const
+GC::Ref<DOM::Document const> Window::document() const
 {
     // The document getter steps are to return this's associated Document.
     return associated_document();
@@ -843,7 +843,7 @@ void Window::close()
         traversable->set_closing(true);
 
         // 2. Queue a task on the DOM manipulation task source to definitely close thisTraversable.
-        HTML::queue_global_task(HTML::Task::Source::DOMManipulation, incumbent_global_object, JS::create_heap_function(heap(), [traversable] {
+        HTML::queue_global_task(HTML::Task::Source::DOMManipulation, incumbent_global_object, GC::create_function(heap(), [traversable] {
             verify_cast<TraversableNavigable>(*traversable).definitely_close_top_level_traversable();
         }));
     }
@@ -872,18 +872,18 @@ void Window::set_status(String const& status)
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-location
-JS::NonnullGCPtr<Location> Window::location()
+GC::Ref<Location> Window::location()
 {
     auto& realm = this->realm();
 
     // The Window object's location getter steps are to return this's Location object.
     if (!m_location)
         m_location = realm.create<Location>(realm);
-    return JS::NonnullGCPtr { *m_location };
+    return GC::Ref { *m_location };
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-history
-JS::NonnullGCPtr<History> Window::history() const
+GC::Ref<History> Window::history() const
 {
     // The history getter steps are to return this's associated Document's history object.
     return associated_document().history();
@@ -915,7 +915,7 @@ void Window::blur()
 }
 
 // https://html.spec.whatwg.org/multipage/window-object.html#dom-frames
-JS::NonnullGCPtr<WindowProxy> Window::frames() const
+GC::Ref<WindowProxy> Window::frames() const
 {
     // The window, frames, and self getter steps are to return this's relevant realm.[[GlobalEnv]].[[GlobalThisValue]].
     return verify_cast<WindowProxy>(relevant_realm(*this).global_environment().global_this_value());
@@ -929,7 +929,7 @@ u32 Window::length()
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-top
-JS::GCPtr<WindowProxy const> Window::top() const
+GC::Ptr<WindowProxy const> Window::top() const
 {
     // 1. If this's navigable is null, then return null.
     auto navigable = this->navigable();
@@ -941,7 +941,7 @@ JS::GCPtr<WindowProxy const> Window::top() const
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-opener
-JS::GCPtr<WindowProxy const> Window::opener() const
+GC::Ptr<WindowProxy const> Window::opener() const
 {
     // 1. Let current be this's browsing context.
     auto const* current = browsing_context();
@@ -976,7 +976,7 @@ WebIDL::ExceptionOr<void> Window::set_opener(JS::Value value)
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-parent
-JS::GCPtr<WindowProxy const> Window::parent() const
+GC::Ptr<WindowProxy const> Window::parent() const
 {
     // 1. Let navigable be this's navigable.
     auto navigable = this->navigable();
@@ -995,7 +995,7 @@ JS::GCPtr<WindowProxy const> Window::parent() const
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-frameelement
 // https://whatpr.org/html/9893/nav-history-apis.html#dom-frameelement
-JS::GCPtr<DOM::Element const> Window::frame_element() const
+GC::Ptr<DOM::Element const> Window::frame_element() const
 {
     // 1. Let current be this's node navigable.
     auto current = navigable();
@@ -1020,31 +1020,31 @@ JS::GCPtr<DOM::Element const> Window::frame_element() const
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-open
-WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> Window::open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features)
+WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> Window::open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features)
 {
     // The open(url, target, features) method steps are to run the window open steps with url, target, and features.
     return window_open_steps(*url, *target, *features);
 }
 
 // https://html.spec.whatwg.org/multipage/system-state.html#dom-navigator
-JS::NonnullGCPtr<Navigator> Window::navigator()
+GC::Ref<Navigator> Window::navigator()
 {
     auto& realm = this->realm();
 
     // The navigator and clientInformation getter steps are to return this's associated Navigator.
     if (!m_navigator)
         m_navigator = realm.create<Navigator>(realm);
-    return JS::NonnullGCPtr { *m_navigator };
+    return GC::Ref { *m_navigator };
 }
 
 // https://html.spec.whatwg.org/multipage/interaction.html#close-watcher-manager
-JS::NonnullGCPtr<CloseWatcherManager> Window::close_watcher_manager()
+GC::Ref<CloseWatcherManager> Window::close_watcher_manager()
 {
     auto& realm = this->realm();
 
     if (!m_close_watcher_manager)
         m_close_watcher_manager = realm.create<CloseWatcherManager>(realm);
-    return JS::NonnullGCPtr { *m_close_watcher_manager };
+    return GC::Ref { *m_close_watcher_manager };
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-alert
@@ -1109,7 +1109,7 @@ WebIDL::ExceptionOr<void> Window::window_post_message_steps(JS::Value message, W
     auto serialize_with_transfer_result = TRY(structured_serialize_with_transfer(target_realm.vm(), message, transfer));
 
     // 8. Queue a global task on the posted message task source given targetWindow to run the following steps:
-    queue_global_task(Task::Source::PostedMessage, *this, JS::create_heap_function(heap(), [this, serialize_with_transfer_result = move(serialize_with_transfer_result), target_origin = move(target_origin), &incumbent_settings, &target_realm]() mutable {
+    queue_global_task(Task::Source::PostedMessage, *this, GC::create_function(heap(), [this, serialize_with_transfer_result = move(serialize_with_transfer_result), target_origin = move(target_origin), &incumbent_settings, &target_realm]() mutable {
         // 1. If the targetOrigin argument is not a single literal U+002A ASTERISK character (*) and targetWindow's
         //    associated Document's origin is not same origin with targetOrigin, then return.
         // NOTE: Due to step 4 and 5 above, the only time it's not '*' is if target_origin contains an Origin.
@@ -1134,7 +1134,7 @@ WebIDL::ExceptionOr<void> Window::window_post_message_steps(JS::Value message, W
         if (deserialize_record_or_error.is_exception()) {
             MessageEventInit message_event_init {};
             message_event_init.origin = MUST(String::from_byte_string(origin));
-            message_event_init.source = JS::make_handle(source);
+            message_event_init.source = GC::make_root(source);
 
             auto message_error_event = MessageEvent::create(target_realm, EventNames::messageerror, message_event_init);
             dispatch_event(message_error_event);
@@ -1148,7 +1148,7 @@ WebIDL::ExceptionOr<void> Window::window_post_message_steps(JS::Value message, W
         // 6. Let newPorts be a new frozen array consisting of all MessagePort objects in deserializeRecord.[[TransferredValues]],
         //    if any, maintaining their relative order.
         // FIXME: Use a FrozenArray
-        Vector<JS::Handle<MessagePort>> new_ports;
+        Vector<GC::Root<MessagePort>> new_ports;
         for (auto const& object : deserialize_record.transferred_values) {
             if (is<HTML::MessagePort>(*object)) {
                 new_ports.append(verify_cast<MessagePort>(*object));
@@ -1160,7 +1160,7 @@ WebIDL::ExceptionOr<void> Window::window_post_message_steps(JS::Value message, W
         //    initialized to newPorts.
         MessageEventInit message_event_init {};
         message_event_init.origin = MUST(String::from_byte_string(origin));
-        message_event_init.source = JS::make_handle(source);
+        message_event_init.source = GC::make_root(source);
         message_event_init.data = message_clone;
         message_event_init.ports = move(new_ports);
 
@@ -1180,7 +1180,7 @@ WebIDL::ExceptionOr<void> Window::post_message(JS::Value message, WindowPostMess
 }
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#dom-window-postmessage
-WebIDL::ExceptionOr<void> Window::post_message(JS::Value message, String const& target_origin, Vector<JS::Handle<JS::Object>> const& transfer)
+WebIDL::ExceptionOr<void> Window::post_message(JS::Value message, String const& target_origin, Vector<GC::Root<JS::Object>> const& transfer)
 {
     // The Window interface's postMessage(message, targetOrigin, transfer) method steps are to run the window post message
     // steps given this, message, and «[ "targetOrigin" → targetOrigin, "transfer" → transfer ]».
@@ -1188,16 +1188,16 @@ WebIDL::ExceptionOr<void> Window::post_message(JS::Value message, String const&
 }
 
 // https://dom.spec.whatwg.org/#dom-window-event
-Variant<JS::Handle<DOM::Event>, JS::Value> Window::event() const
+Variant<GC::Root<DOM::Event>, JS::Value> Window::event() const
 {
     // The event getter steps are to return this’s current event.
     if (auto* current_event = this->current_event())
-        return make_handle(const_cast<DOM::Event&>(*current_event));
+        return make_root(const_cast<DOM::Event&>(*current_event));
     return JS::js_undefined();
 }
 
 // https://w3c.github.io/csswg-drafts/cssom/#dom-window-getcomputedstyle
-JS::NonnullGCPtr<CSS::CSSStyleDeclaration> Window::get_computed_style(DOM::Element& element, Optional<String> const& pseudo_element) const
+GC::Ref<CSS::CSSStyleDeclaration> Window::get_computed_style(DOM::Element& element, Optional<String> const& pseudo_element) const
 {
     // 1. Let doc be elt’s node document.
 
@@ -1247,7 +1247,7 @@ JS::NonnullGCPtr<CSS::CSSStyleDeclaration> Window::get_computed_style(DOM::Eleme
 }
 
 // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-matchmedia
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::MediaQueryList>> Window::match_media(String const& query)
+WebIDL::ExceptionOr<GC::Ref<CSS::MediaQueryList>> Window::match_media(String const& query)
 {
     // 1. Let parsed media query list be the result of parsing query.
     auto parsed_media_query_list = parse_media_query_list(CSS::Parser::ParsingContext(associated_document()), query);
@@ -1259,15 +1259,15 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::MediaQueryList>> Window::match_media(S
 }
 
 // https://w3c.github.io/csswg-drafts/cssom-view/#dom-window-screen
-JS::NonnullGCPtr<CSS::Screen> Window::screen()
+GC::Ref<CSS::Screen> Window::screen()
 {
     // The screen attribute must return the Screen object associated with the Window object.
     if (!m_screen)
         m_screen = realm().create<CSS::Screen>(*this);
-    return JS::NonnullGCPtr { *m_screen };
+    return GC::Ref { *m_screen };
 }
 
-JS::GCPtr<CSS::VisualViewport> Window::visual_viewport()
+GC::Ptr<CSS::VisualViewport> Window::visual_viewport()
 {
     // If the associated document is fully active, the visualViewport attribute must return
     // the VisualViewport object associated with the Window object’s associated document.
@@ -1543,10 +1543,10 @@ double Window::device_pixel_ratio() const
 }
 
 // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-animationframeprovider-requestanimationframe
-WebIDL::UnsignedLong Window::request_animation_frame(JS::NonnullGCPtr<WebIDL::CallbackType> callback)
+WebIDL::UnsignedLong Window::request_animation_frame(GC::Ref<WebIDL::CallbackType> callback)
 {
     // FIXME: Make this fully spec compliant. Currently implements a mix of 'requestAnimationFrame()' and 'run the animation frame callbacks'.
-    return animation_frame_callback_driver().add(JS::create_heap_function(heap(), [this, callback](double now) {
+    return animation_frame_callback_driver().add(GC::create_function(heap(), [this, callback](double now) {
         // 3. Invoke callback, passing now as the only argument, and if an exception is thrown, report the exception.
         auto result = WebIDL::invoke_callback(*callback, {}, JS::Value(now));
         if (result.is_error())
@@ -1591,7 +1591,7 @@ u32 Window::request_idle_callback(WebIDL::CallbackType& callback, RequestIdleCal
     auto handle = m_idle_callback_identifier;
 
     // 4. Push callback to the end of window's list of idle request callbacks, associated with handle.
-    auto handler = [callback = JS::make_handle(callback)](JS::NonnullGCPtr<RequestIdleCallback::IdleDeadline> deadline) -> JS::Completion {
+    auto handler = [callback = GC::make_root(callback)](GC::Ref<RequestIdleCallback::IdleDeadline> deadline) -> JS::Completion {
         return WebIDL::invoke_callback(*callback, {}, deadline.ptr());
     };
     m_idle_request_callbacks.append(adopt_ref(*new IdleCallback(move(handler), handle)));
@@ -1624,7 +1624,7 @@ void Window::cancel_idle_callback(u32 handle)
 }
 
 // https://w3c.github.io/selection-api/#dom-window-getselection
-JS::GCPtr<Selection::Selection> Window::get_selection() const
+GC::Ptr<Selection::Selection> Window::get_selection() const
 {
     // The method must invoke and return the result of getSelection() on this's Window.document attribute.
     return associated_document().get_selection();
@@ -1643,7 +1643,7 @@ void Window::release_events()
 }
 
 // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-navigation
-JS::NonnullGCPtr<Navigation> Window::navigation()
+GC::Ref<Navigation> Window::navigation()
 {
     // Upon creation of the Window object, its navigation API must be set
     // to a new Navigation object created in the Window object's relevant realm.
@@ -1657,18 +1657,18 @@ JS::NonnullGCPtr<Navigation> Window::navigation()
 }
 
 // https://html.spec.whatwg.org/multipage/custom-elements.html#dom-window-customelements
-JS::NonnullGCPtr<CustomElementRegistry> Window::custom_elements()
+GC::Ref<CustomElementRegistry> Window::custom_elements()
 {
     auto& realm = this->realm();
 
     // The customElements attribute of the Window interface must return the CustomElementRegistry object for that Window object.
     if (!m_custom_element_registry)
         m_custom_element_registry = realm.create<CustomElementRegistry>(realm);
-    return JS::NonnullGCPtr { *m_custom_element_registry };
+    return GC::Ref { *m_custom_element_registry };
 }
 
 // https://html.spec.whatwg.org/#document-tree-child-navigable-target-name-property-set
-OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> Window::document_tree_child_navigable_target_name_property_set()
+OrderedHashMap<FlyString, GC::Ref<Navigable>> Window::document_tree_child_navigable_target_name_property_set()
 {
     // The document-tree child navigable target name property set of a Window object window is the return value of running these steps:
 
@@ -1676,7 +1676,7 @@ OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> Window::document_tree_chi
     auto children = associated_document().document_tree_child_navigables();
 
     // 2. Let firstNamedChildren be an empty ordered set.
-    OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> first_named_children;
+    OrderedHashMap<FlyString, GC::Ref<Navigable>> first_named_children;
 
     // 3. For each navigable of children:
     for (auto const& navigable : children) {
@@ -1696,7 +1696,7 @@ OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> Window::document_tree_chi
     }
 
     // 4. Let names be an empty ordered set.
-    OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> names;
+    OrderedHashMap<FlyString, GC::Ref<Navigable>> names;
 
     // 5. For each navigable of firstNamedChildren:
     for (auto const& [name, navigable] : first_named_children) {
@@ -1758,11 +1758,11 @@ JS::Value Window::named_item_value(FlyString const& name) const
     // 2. If objects contains a navigable, then:
     if (!objects.navigables.is_empty()) {
         // 1. Let container be the first navigable container in window's associated Document's descendants whose content navigable is in objects.
-        JS::GCPtr<NavigableContainer> container = nullptr;
+        GC::Ptr<NavigableContainer> container = nullptr;
         mutable_this.associated_document().for_each_in_subtree_of_type<HTML::NavigableContainer>([&](HTML::NavigableContainer& navigable_container) {
             if (!navigable_container.content_navigable())
                 return TraversalDecision::Continue;
-            if (objects.navigables.contains_slow(JS::NonnullGCPtr { *navigable_container.content_navigable() })) {
+            if (objects.navigables.contains_slow(GC::Ref { *navigable_container.content_navigable() })) {
                 container = navigable_container;
                 return TraversalDecision::Break;
             }
diff --git a/Libraries/LibWeb/HTML/Window.h b/Libraries/LibWeb/HTML/Window.h
index 78bc9994452..5ef06b9cb09 100644
--- a/Libraries/LibWeb/HTML/Window.h
+++ b/Libraries/LibWeb/HTML/Window.h
@@ -10,7 +10,7 @@
 #include <AK/Badge.h>
 #include <AK/RefPtr.h>
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibURL/URL.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WindowGlobalMixin.h>
@@ -53,10 +53,10 @@ class Window final
     , public UniversalGlobalScopeMixin
     , public Bindings::WindowGlobalMixin {
     WEB_PLATFORM_OBJECT(Window, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Window);
+    GC_DECLARE_ALLOCATOR(Window);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Window> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<Window> create(JS::Realm&);
 
     ~Window();
 
@@ -94,7 +94,7 @@ public:
     BrowsingContext const* browsing_context() const;
     BrowsingContext* browsing_context();
 
-    JS::GCPtr<Navigable> navigable() const;
+    GC::Ptr<Navigable> navigable() const;
 
     ImportMap const& import_map() const { return m_import_map; }
     void set_import_map(ImportMap const& import_map) { m_import_map = import_map; }
@@ -102,10 +102,10 @@ public:
     bool import_maps_allowed() const { return m_import_maps_allowed; }
     void set_import_maps_allowed(bool import_maps_allowed) { m_import_maps_allowed = import_maps_allowed; }
 
-    WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> window_open_steps(StringView url, StringView target, StringView features);
+    WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> window_open_steps(StringView url, StringView target, StringView features);
 
     struct OpenedWindow {
-        JS::GCPtr<Navigable> navigable;
+        GC::Ptr<Navigable> navigable;
         TokenizedFeature::NoOpener no_opener { TokenizedFeature::NoOpener::No };
         Navigable::WindowType window_type { Navigable::WindowType::ExistingOrNone };
     };
@@ -119,8 +119,8 @@ public:
 
     void fire_a_page_transition_event(FlyString const& event_name, bool persisted);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> local_storage();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<Storage>> session_storage();
+    WebIDL::ExceptionOr<GC::Ref<Storage>> local_storage();
+    WebIDL::ExceptionOr<GC::Ref<Storage>> session_storage();
 
     void start_an_idle_period();
 
@@ -135,57 +135,57 @@ public:
 
     WebIDL::ExceptionOr<void> initialize_web_interfaces(Badge<WindowEnvironmentSettingsObject>);
 
-    Vector<JS::NonnullGCPtr<Plugin>> pdf_viewer_plugin_objects();
-    Vector<JS::NonnullGCPtr<MimeType>> pdf_viewer_mime_type_objects();
+    Vector<GC::Ref<Plugin>> pdf_viewer_plugin_objects();
+    Vector<GC::Ref<MimeType>> pdf_viewer_mime_type_objects();
 
     CrossOriginPropertyDescriptorMap const& cross_origin_property_descriptor_map() const { return m_cross_origin_property_descriptor_map; }
     CrossOriginPropertyDescriptorMap& cross_origin_property_descriptor_map() { return m_cross_origin_property_descriptor_map; }
 
-    JS::NonnullGCPtr<WebIDL::CallbackType> count_queuing_strategy_size_function();
-    JS::NonnullGCPtr<WebIDL::CallbackType> byte_length_queuing_strategy_size_function();
+    GC::Ref<WebIDL::CallbackType> count_queuing_strategy_size_function();
+    GC::Ref<WebIDL::CallbackType> byte_length_queuing_strategy_size_function();
 
     // JS API functions
-    JS::NonnullGCPtr<WindowProxy> window() const;
-    JS::NonnullGCPtr<WindowProxy> self() const;
-    JS::NonnullGCPtr<DOM::Document const> document() const;
+    GC::Ref<WindowProxy> window() const;
+    GC::Ref<WindowProxy> self() const;
+    GC::Ref<DOM::Document const> document() const;
     String name() const;
     void set_name(String const&);
     String status() const;
     void close();
     bool closed() const;
     void set_status(String const&);
-    [[nodiscard]] JS::NonnullGCPtr<Location> location();
-    JS::NonnullGCPtr<History> history() const;
-    JS::NonnullGCPtr<Navigation> navigation();
+    [[nodiscard]] GC::Ref<Location> location();
+    GC::Ref<History> history() const;
+    GC::Ref<Navigation> navigation();
     void focus();
     void blur();
 
-    JS::NonnullGCPtr<WindowProxy> frames() const;
+    GC::Ref<WindowProxy> frames() const;
     u32 length();
-    JS::GCPtr<WindowProxy const> top() const;
-    JS::GCPtr<WindowProxy const> opener() const;
+    GC::Ptr<WindowProxy const> top() const;
+    GC::Ptr<WindowProxy const> opener() const;
     WebIDL::ExceptionOr<void> set_opener(JS::Value);
-    JS::GCPtr<WindowProxy const> parent() const;
-    JS::GCPtr<DOM::Element const> frame_element() const;
-    WebIDL::ExceptionOr<JS::GCPtr<WindowProxy>> open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features);
+    GC::Ptr<WindowProxy const> parent() const;
+    GC::Ptr<DOM::Element const> frame_element() const;
+    WebIDL::ExceptionOr<GC::Ptr<WindowProxy>> open(Optional<String> const& url, Optional<String> const& target, Optional<String> const& features);
 
-    [[nodiscard]] JS::NonnullGCPtr<Navigator> navigator();
-    [[nodiscard]] JS::NonnullGCPtr<CloseWatcherManager> close_watcher_manager();
+    [[nodiscard]] GC::Ref<Navigator> navigator();
+    [[nodiscard]] GC::Ref<CloseWatcherManager> close_watcher_manager();
 
     void alert(String const& message = {});
     bool confirm(Optional<String> const& message);
     Optional<String> prompt(Optional<String> const& message, Optional<String> const& default_);
 
-    WebIDL::ExceptionOr<void> post_message(JS::Value message, String const&, Vector<JS::Handle<JS::Object>> const&);
+    WebIDL::ExceptionOr<void> post_message(JS::Value message, String const&, Vector<GC::Root<JS::Object>> const&);
     WebIDL::ExceptionOr<void> post_message(JS::Value message, WindowPostMessageOptions const&);
 
-    Variant<JS::Handle<DOM::Event>, JS::Value> event() const;
+    Variant<GC::Root<DOM::Event>, JS::Value> event() const;
 
-    [[nodiscard]] JS::NonnullGCPtr<CSS::CSSStyleDeclaration> get_computed_style(DOM::Element&, Optional<String> const& pseudo_element) const;
+    [[nodiscard]] GC::Ref<CSS::CSSStyleDeclaration> get_computed_style(DOM::Element&, Optional<String> const& pseudo_element) const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<CSS::MediaQueryList>> match_media(String const& query);
-    [[nodiscard]] JS::NonnullGCPtr<CSS::Screen> screen();
-    [[nodiscard]] JS::GCPtr<CSS::VisualViewport> visual_viewport();
+    WebIDL::ExceptionOr<GC::Ref<CSS::MediaQueryList>> match_media(String const& query);
+    [[nodiscard]] GC::Ref<CSS::Screen> screen();
+    [[nodiscard]] GC::Ptr<CSS::VisualViewport> visual_viewport();
 
     i32 inner_width() const;
     i32 inner_height() const;
@@ -211,18 +211,18 @@ public:
     AnimationFrameCallbackDriver& animation_frame_callback_driver();
     bool has_animation_frame_callbacks();
 
-    WebIDL::UnsignedLong request_animation_frame(JS::NonnullGCPtr<WebIDL::CallbackType>);
+    WebIDL::UnsignedLong request_animation_frame(GC::Ref<WebIDL::CallbackType>);
     void cancel_animation_frame(WebIDL::UnsignedLong handle);
 
     u32 request_idle_callback(WebIDL::CallbackType&, RequestIdleCallback::IdleRequestOptions const&);
     void cancel_idle_callback(u32 handle);
 
-    JS::GCPtr<Selection::Selection> get_selection() const;
+    GC::Ptr<Selection::Selection> get_selection() const;
 
     void capture_events();
     void release_events();
 
-    [[nodiscard]] JS::NonnullGCPtr<CustomElementRegistry> custom_elements();
+    [[nodiscard]] GC::Ref<CustomElementRegistry> custom_elements();
 
     HighResolutionTime::DOMHighResTimeStamp last_activation_timestamp() const { return m_last_activation_timestamp; }
     void set_last_activation_timestamp(HighResolutionTime::DOMHighResTimeStamp timestamp) { m_last_activation_timestamp = timestamp; }
@@ -237,7 +237,7 @@ public:
     static void set_inspector_object_exposed(bool);
     static void set_internals_object_exposed(bool);
 
-    [[nodiscard]] OrderedHashMap<FlyString, JS::NonnullGCPtr<Navigable>> document_tree_child_navigable_target_name_property_set();
+    [[nodiscard]] OrderedHashMap<FlyString, GC::Ref<Navigable>> document_tree_child_navigable_target_name_property_set();
 
     [[nodiscard]] Vector<FlyString> supported_property_names() const override;
     [[nodiscard]] JS::Value named_item_value(FlyString const&) const override;
@@ -251,25 +251,25 @@ private:
     virtual void finalize() override;
 
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
 
     // ^HTML::WindowEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> window_event_handlers_to_event_target() override { return *this; }
+    virtual GC::Ptr<DOM::EventTarget> window_event_handlers_to_event_target() override { return *this; }
 
     void invoke_idle_callbacks();
 
     struct [[nodiscard]] NamedObjects {
-        Vector<JS::NonnullGCPtr<Navigable>> navigables;
-        Vector<JS::NonnullGCPtr<DOM::Element>> elements;
+        Vector<GC::Ref<Navigable>> navigables;
+        Vector<GC::Ref<DOM::Element>> elements;
     };
     NamedObjects named_objects(StringView name);
 
     WebIDL::ExceptionOr<void> window_post_message_steps(JS::Value, WindowPostMessageOptions const&);
 
     // https://html.spec.whatwg.org/multipage/window-object.html#concept-document-window
-    JS::GCPtr<DOM::Document> m_associated_document;
+    GC::Ptr<DOM::Document> m_associated_document;
 
-    JS::GCPtr<DOM::Event> m_current_event;
+    GC::Ptr<DOM::Event> m_current_event;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#concept-window-import-map
     ImportMap m_import_map;
@@ -277,19 +277,19 @@ private:
     // https://html.spec.whatwg.org/multipage/webappapis.html#import-maps-allowed
     bool m_import_maps_allowed { true };
 
-    JS::GCPtr<CSS::Screen> m_screen;
-    JS::GCPtr<Navigator> m_navigator;
-    JS::GCPtr<Location> m_location;
-    JS::GCPtr<CloseWatcherManager> m_close_watcher_manager;
+    GC::Ptr<CSS::Screen> m_screen;
+    GC::Ptr<Navigator> m_navigator;
+    GC::Ptr<Location> m_location;
+    GC::Ptr<CloseWatcherManager> m_close_watcher_manager;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#window-navigation-api
-    JS::GCPtr<Navigation> m_navigation;
+    GC::Ptr<Navigation> m_navigation;
 
     // https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements-api
     // Each Window object is associated with a unique instance of a CustomElementRegistry object, allocated when the Window object is created.
-    JS::GCPtr<CustomElementRegistry> m_custom_element_registry;
+    GC::Ptr<CustomElementRegistry> m_custom_element_registry;
 
-    JS::GCPtr<AnimationFrameCallbackDriver> m_animation_frame_callback_driver;
+    GC::Ptr<AnimationFrameCallbackDriver> m_animation_frame_callback_driver;
 
     // https://w3c.github.io/requestidlecallback/#dfn-list-of-idle-request-callbacks
     Vector<NonnullRefPtr<IdleCallback>> m_idle_request_callbacks;
@@ -299,10 +299,10 @@ private:
     u32 m_idle_callback_identifier = 0;
 
     // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-plugin-objects
-    Vector<JS::NonnullGCPtr<Plugin>> m_pdf_viewer_plugin_objects;
+    Vector<GC::Ref<Plugin>> m_pdf_viewer_plugin_objects;
 
     // https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-mime-type-objects
-    Vector<JS::NonnullGCPtr<MimeType>> m_pdf_viewer_mime_type_objects;
+    Vector<GC::Ref<MimeType>> m_pdf_viewer_mime_type_objects;
 
     // [[CrossOriginPropertyDescriptorMap]], https://html.spec.whatwg.org/multipage/browsers.html#crossoriginpropertydescriptormap
     CrossOriginPropertyDescriptorMap m_cross_origin_property_descriptor_map;
@@ -314,10 +314,10 @@ private:
     HighResolutionTime::DOMHighResTimeStamp m_last_history_action_activation_timestamp { AK::Infinity<double> };
 
     // https://streams.spec.whatwg.org/#count-queuing-strategy-size-function
-    JS::GCPtr<WebIDL::CallbackType> m_count_queuing_strategy_size_function;
+    GC::Ptr<WebIDL::CallbackType> m_count_queuing_strategy_size_function;
 
     // https://streams.spec.whatwg.org/#byte-length-queuing-strategy-size-function
-    JS::GCPtr<WebIDL::CallbackType> m_byte_length_queuing_strategy_size_function;
+    GC::Ptr<WebIDL::CallbackType> m_byte_length_queuing_strategy_size_function;
 
     // https://html.spec.whatwg.org/multipage/nav-history-apis.html#dom-window-status
     // When the Window object is created, the attribute must be set to the empty string. It does not do anything else.
diff --git a/Libraries/LibWeb/HTML/WindowEventHandlers.h b/Libraries/LibWeb/HTML/WindowEventHandlers.h
index 226c7d8794b..3985cd08b0e 100644
--- a/Libraries/LibWeb/HTML/WindowEventHandlers.h
+++ b/Libraries/LibWeb/HTML/WindowEventHandlers.h
@@ -41,7 +41,7 @@ public:
 #undef __ENUMERATE
 
 protected:
-    virtual JS::GCPtr<DOM::EventTarget> window_event_handlers_to_event_target() = 0;
+    virtual GC::Ptr<DOM::EventTarget> window_event_handlers_to_event_target() = 0;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.cpp b/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.cpp
index 361cbae81a2..4d93c84cc5d 100644
--- a/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.cpp
+++ b/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.cpp
@@ -10,7 +10,7 @@
 #include <AK/String.h>
 #include <AK/Utf8View.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/Array.h>
 #include <LibWeb/Bindings/MainThreadVM.h>
 #include <LibWeb/Crypto/Crypto.h>
@@ -106,18 +106,18 @@ bool WindowOrWorkerGlobalScopeMixin::cross_origin_isolated() const
 }
 
 // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-createimagebitmap
-JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap(ImageBitmapSource image, Optional<ImageBitmapOptions> options) const
+GC::Ref<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap(ImageBitmapSource image, Optional<ImageBitmapOptions> options) const
 {
     return create_image_bitmap_impl(image, {}, {}, {}, {}, options);
 }
 
 // https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#dom-createimagebitmap
-JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap(ImageBitmapSource image, WebIDL::Long sx, WebIDL::Long sy, WebIDL::Long sw, WebIDL::Long sh, Optional<ImageBitmapOptions> options) const
+GC::Ref<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap(ImageBitmapSource image, WebIDL::Long sx, WebIDL::Long sy, WebIDL::Long sw, WebIDL::Long sh, Optional<ImageBitmapOptions> options) const
 {
     return create_image_bitmap_impl(image, sx, sy, sw, sh, options);
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap_impl(ImageBitmapSource& image, Optional<WebIDL::Long> sx, Optional<WebIDL::Long> sy, Optional<WebIDL::Long> sw, Optional<WebIDL::Long> sh, Optional<ImageBitmapOptions>& options) const
+GC::Ref<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_bitmap_impl(ImageBitmapSource& image, Optional<WebIDL::Long> sx, Optional<WebIDL::Long> sy, Optional<WebIDL::Long> sw, Optional<WebIDL::Long> sh, Optional<ImageBitmapOptions>& options) const
 {
     auto& realm = this_impl().realm();
 
@@ -149,9 +149,9 @@ JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_b
 
     // 6. Switch on image:
     image.visit(
-        [&](JS::Handle<FileAPI::Blob>& blob) {
+        [&](GC::Root<FileAPI::Blob>& blob) {
             // Run these step in parallel:
-            Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [=]() {
+            Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [=]() {
                 // 1. Let imageData be the result of reading image's data. If an error occurs during reading of the
                 // object, then reject p with an "InvalidStateError" DOMException and abort these steps.
                 // FIXME: I guess this is always fine for us as the data is already read.
@@ -161,7 +161,7 @@ JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_b
                 // 2. Apply the image sniffing rules to determine the file format of imageData, with MIME type of
                 // image (as given by image's type attribute) giving the official type.
 
-                auto on_failed_decode = [p = JS::Handle(*p)](Error&) {
+                auto on_failed_decode = [p = GC::Root(*p)](Error&) {
                     // 3. If imageData is not in a supported image file format (e.g., it's not an image at all), or if
                     // imageData is corrupted in some fatal way such that the image dimensions cannot be obtained
                     // (e.g., a vector graphic with no natural size), then reject p with an "InvalidStateError" DOMException
@@ -171,7 +171,7 @@ JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_b
                     WebIDL::reject_promise(realm, *p, WebIDL::InvalidStateError::create(realm, "image does not contain a supported image format"_string));
                 };
 
-                auto on_successful_decode = [image_bitmap = JS::Handle(*image_bitmap), p = JS::Handle(*p)](Web::Platform::DecodedImage& result) -> ErrorOr<void> {
+                auto on_successful_decode = [image_bitmap = GC::Root(*image_bitmap), p = GC::Root(*p)](Web::Platform::DecodedImage& result) -> ErrorOr<void> {
                     // 4. Set imageBitmap's bitmap data to imageData, cropped to the source rectangle with formatting.
                     // If this is an animated image, imageBitmap's bitmap data must only be taken from the default image
                     // of the animation (the one that the format defines is to be used when animation is not supported
@@ -202,20 +202,20 @@ JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::create_image_b
     return p;
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::fetch(Fetch::RequestInfo const& input, Fetch::RequestInit const& init) const
+GC::Ref<WebIDL::Promise> WindowOrWorkerGlobalScopeMixin::fetch(Fetch::RequestInfo const& input, Fetch::RequestInit const& init) const
 {
     auto& vm = this_impl().vm();
     return Fetch::fetch(vm, input, init);
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
-i32 WindowOrWorkerGlobalScopeMixin::set_timeout(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+i32 WindowOrWorkerGlobalScopeMixin::set_timeout(TimerHandler handler, i32 timeout, GC::MarkedVector<JS::Value> arguments)
 {
     return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::No);
 }
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
-i32 WindowOrWorkerGlobalScopeMixin::set_interval(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments)
+i32 WindowOrWorkerGlobalScopeMixin::set_interval(TimerHandler handler, i32 timeout, GC::MarkedVector<JS::Value> arguments)
 {
     return run_timer_initialization_steps(move(handler), timeout, move(arguments), Repeat::Yes);
 }
@@ -245,7 +245,7 @@ void WindowOrWorkerGlobalScopeMixin::clear_map_of_active_timers()
 
 // https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timer-initialisation-steps
 // With no active script fix from https://github.com/whatwg/html/pull/9712
-i32 WindowOrWorkerGlobalScopeMixin::run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id)
+i32 WindowOrWorkerGlobalScopeMixin::run_timer_initialization_steps(TimerHandler handler, i32 timeout, GC::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id)
 {
     // 1. Let thisArg be global if that is a WorkerGlobalScope object; otherwise let thisArg be the WindowProxy that corresponds to global.
 
@@ -269,14 +269,14 @@ i32 WindowOrWorkerGlobalScopeMixin::run_timer_initialization_steps(TimerHandler
     auto& vm = this_impl().vm();
 
     // 8. Let task be a task that runs the following substeps:
-    auto task = JS::create_heap_function(vm.heap(), Function<void()>([this, handler = move(handler), timeout, arguments = move(arguments), repeat, id, initiating_script]() {
+    auto task = GC::create_function(vm.heap(), Function<void()>([this, handler = move(handler), timeout, arguments = move(arguments), repeat, id, initiating_script]() {
         // 1. If id does not exist in global's map of active timers, then abort these steps.
         if (!m_timers.contains(id))
             return;
 
         handler.visit(
             // 2. If handler is a Function, then invoke handler given arguments with the callback this value set to thisArg. If this throws an exception, catch it, and report the exception.
-            [&](JS::Handle<WebIDL::CallbackType> const& callback) {
+            [&](GC::Root<WebIDL::CallbackType> const& callback) {
                 if (auto result = WebIDL::invoke_callback(*callback, &this_impl(), arguments); result.is_error())
                     report_exception(result, this_impl().realm());
             },
@@ -338,7 +338,7 @@ i32 WindowOrWorkerGlobalScopeMixin::run_timer_initialization_steps(TimerHandler
 
     // 11. Let completionStep be an algorithm step which queues a global task on the timer task source given global to run task.
     Function<void()> completion_step = [this, task = move(task)]() mutable {
-        queue_global_task(Task::Source::TimerTask, this_impl(), JS::create_heap_function(this_impl().heap(), [this, task] {
+        queue_global_task(Task::Source::TimerTask, this_impl(), GC::create_function(this_impl().heap(), [this, task] {
             HTML::TemporaryExecutionContext execution_context { this_impl().realm(), HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
             task->function()();
         }));
@@ -364,10 +364,10 @@ PerformanceTimeline::PerformanceEntryTuple& WindowOrWorkerGlobalScopeMixin::rele
 }
 
 // https://www.w3.org/TR/performance-timeline/#dfn-queue-a-performanceentry
-void WindowOrWorkerGlobalScopeMixin::queue_performance_entry(JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry> new_entry)
+void WindowOrWorkerGlobalScopeMixin::queue_performance_entry(GC::Ref<PerformanceTimeline::PerformanceEntry> new_entry)
 {
     // 1. Let interested observers be an initially empty set of PerformanceObserver objects.
-    Vector<JS::Handle<PerformanceTimeline::PerformanceObserver>> interested_observers;
+    Vector<GC::Root<PerformanceTimeline::PerformanceObserver>> interested_observers;
 
     // 2. Let entryType be newEntry’s entryType value.
     auto const& entry_type = new_entry->entry_type();
@@ -428,16 +428,16 @@ void WindowOrWorkerGlobalScopeMixin::clear_performance_entry_buffer(Badge<HighRe
 void WindowOrWorkerGlobalScopeMixin::remove_entries_from_performance_entry_buffer(Badge<HighResolutionTime::Performance>, FlyString const& entry_type, String entry_name)
 {
     auto& tuple = relevant_performance_entry_tuple(entry_type);
-    tuple.performance_entry_buffer.remove_all_matching([&entry_name](JS::Handle<PerformanceTimeline::PerformanceEntry> const& entry) {
+    tuple.performance_entry_buffer.remove_all_matching([&entry_name](GC::Root<PerformanceTimeline::PerformanceEntry> const& entry) {
         return entry->name() == entry_name;
     });
 }
 
 // https://www.w3.org/TR/performance-timeline/#dfn-filter-buffer-map-by-name-and-type
-ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> WindowOrWorkerGlobalScopeMixin::filter_buffer_map_by_name_and_type(Optional<String> name, Optional<String> type) const
+ErrorOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> WindowOrWorkerGlobalScopeMixin::filter_buffer_map_by_name_and_type(Optional<String> name, Optional<String> type) const
 {
     // 1. Let result be an initially empty list.
-    Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> result;
+    Vector<GC::Root<PerformanceTimeline::PerformanceEntry>> result;
 
     // 2. Let map be the performance entry buffer map associated with the relevant global object of this.
     auto const& map = m_performance_entry_buffer_map;
@@ -481,17 +481,17 @@ ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> WindowOrWorke
     return result;
 }
 
-void WindowOrWorkerGlobalScopeMixin::register_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver> observer)
+void WindowOrWorkerGlobalScopeMixin::register_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, GC::Ref<PerformanceTimeline::PerformanceObserver> observer)
 {
     m_registered_performance_observer_objects.set(observer, AK::HashSetExistingEntryBehavior::Keep);
 }
 
-void WindowOrWorkerGlobalScopeMixin::unregister_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver> observer)
+void WindowOrWorkerGlobalScopeMixin::unregister_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, GC::Ref<PerformanceTimeline::PerformanceObserver> observer)
 {
     m_registered_performance_observer_objects.remove(observer);
 }
 
-bool WindowOrWorkerGlobalScopeMixin::has_registered_performance_observer(JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver> observer)
+bool WindowOrWorkerGlobalScopeMixin::has_registered_performance_observer(GC::Ref<PerformanceTimeline::PerformanceObserver> observer)
 {
     return m_registered_performance_observer_objects.contains(observer);
 }
@@ -508,7 +508,7 @@ void WindowOrWorkerGlobalScopeMixin::queue_the_performance_observer_task()
 
     // 3. Queue a task that consists of running the following substeps. The task source for the queued task is the performance
     //    timeline task source.
-    queue_global_task(Task::Source::PerformanceTimeline, this_impl(), JS::create_heap_function(this_impl().heap(), [this]() {
+    queue_global_task(Task::Source::PerformanceTimeline, this_impl(), GC::create_function(this_impl().heap(), [this]() {
         auto& realm = this_impl().realm();
         HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
@@ -530,7 +530,7 @@ void WindowOrWorkerGlobalScopeMixin::queue_the_performance_observer_task()
             if (entries.is_empty())
                 continue;
 
-            Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>> entries_as_gc_ptrs;
+            Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>> entries_as_gc_ptrs;
             for (auto& entry : entries)
                 entries_as_gc_ptrs.append(*entry);
 
@@ -589,12 +589,12 @@ void WindowOrWorkerGlobalScopeMixin::queue_the_performance_observer_task()
     }));
 }
 
-void WindowOrWorkerGlobalScopeMixin::register_event_source(Badge<EventSource>, JS::NonnullGCPtr<EventSource> event_source)
+void WindowOrWorkerGlobalScopeMixin::register_event_source(Badge<EventSource>, GC::Ref<EventSource> event_source)
 {
     m_registered_event_sources.set(event_source);
 }
 
-void WindowOrWorkerGlobalScopeMixin::unregister_event_source(Badge<EventSource>, JS::NonnullGCPtr<EventSource> event_source)
+void WindowOrWorkerGlobalScopeMixin::unregister_event_source(Badge<EventSource>, GC::Ref<EventSource> event_source)
 {
     m_registered_event_sources.remove(event_source);
 }
@@ -638,15 +638,15 @@ void WindowOrWorkerGlobalScopeMixin::run_steps_after_a_timeout_impl(i32 timeout,
 }
 
 // https://w3c.github.io/hr-time/#dom-windoworworkerglobalscope-performance
-JS::NonnullGCPtr<HighResolutionTime::Performance> WindowOrWorkerGlobalScopeMixin::performance()
+GC::Ref<HighResolutionTime::Performance> WindowOrWorkerGlobalScopeMixin::performance()
 {
     auto& realm = this_impl().realm();
     if (!m_performance)
         m_performance = realm.create<HighResolutionTime::Performance>(realm);
-    return JS::NonnullGCPtr { *m_performance };
+    return GC::Ref { *m_performance };
 }
 
-JS::NonnullGCPtr<IndexedDB::IDBFactory> WindowOrWorkerGlobalScopeMixin::indexed_db()
+GC::Ref<IndexedDB::IDBFactory> WindowOrWorkerGlobalScopeMixin::indexed_db()
 {
     auto& realm = this_impl().realm();
 
@@ -656,7 +656,7 @@ JS::NonnullGCPtr<IndexedDB::IDBFactory> WindowOrWorkerGlobalScopeMixin::indexed_
 }
 
 // https://w3c.github.io/performance-timeline/#dfn-frozen-array-of-supported-entry-types
-JS::NonnullGCPtr<JS::Object> WindowOrWorkerGlobalScopeMixin::supported_entry_types() const
+GC::Ref<JS::Object> WindowOrWorkerGlobalScopeMixin::supported_entry_types() const
 {
     // Each global object has an associated frozen array of supported entry types, which is initialized to the
     // FrozenArray created from the sequence of strings among the registry that are supported for the global
@@ -665,7 +665,7 @@ JS::NonnullGCPtr<JS::Object> WindowOrWorkerGlobalScopeMixin::supported_entry_typ
     auto& realm = this_impl().realm();
 
     if (!m_supported_entry_types_array) {
-        JS::MarkedVector<JS::Value> supported_entry_types(vm.heap());
+        GC::MarkedVector<JS::Value> supported_entry_types(vm.heap());
 
 #define __ENUMERATE_SUPPORTED_PERFORMANCE_ENTRY_TYPES(entry_type, cpp_class) \
     supported_entry_types.append(JS::PrimitiveString::create(vm, entry_type));
@@ -735,7 +735,7 @@ void WindowOrWorkerGlobalScopeMixin::report_an_exception(JS::Value const& e)
     // 6. If script is a classic script and script's muted errors is true, then set message to "Script error.",
     //    urlString to the empty string, line and col to 0, and errorValue to null.
     script_or_module.visit(
-        [&](JS::NonnullGCPtr<JS::Script> const& js_script) {
+        [&](GC::Ref<JS::Script> const& js_script) {
             if (verify_cast<ClassicScript>(js_script->host_defined())->muted_errors() == ClassicScript::MutedErrors::Yes) {
                 message = "Script error."_string;
                 url_string = String {};
@@ -746,7 +746,7 @@ void WindowOrWorkerGlobalScopeMixin::report_an_exception(JS::Value const& e)
                 url_string = script_or_module_filename(js_script);
             }
         },
-        [&](JS::NonnullGCPtr<JS::Module> const& js_module) {
+        [&](GC::Ref<JS::Module> const& js_module) {
             url_string = script_or_module_filename(js_module);
         },
         [](Empty) {});
@@ -783,14 +783,14 @@ void WindowOrWorkerGlobalScopeMixin::report_an_exception(JS::Value const& e)
 }
 
 // https://w3c.github.io/webcrypto/#dom-windoworworkerglobalscope-crypto
-JS::NonnullGCPtr<Crypto::Crypto> WindowOrWorkerGlobalScopeMixin::crypto()
+GC::Ref<Crypto::Crypto> WindowOrWorkerGlobalScopeMixin::crypto()
 {
     auto& platform_object = this_impl();
     auto& realm = platform_object.realm();
 
     if (!m_crypto)
         m_crypto = realm.create<Crypto::Crypto>(realm);
-    return JS::NonnullGCPtr { *m_crypto };
+    return GC::Ref { *m_crypto };
 }
 
 void WindowOrWorkerGlobalScopeMixin::push_onto_outstanding_rejected_promises_weak_set(JS::Promise* promise)
@@ -805,12 +805,12 @@ bool WindowOrWorkerGlobalScopeMixin::remove_from_outstanding_rejected_promises_w
     });
 }
 
-void WindowOrWorkerGlobalScopeMixin::push_onto_about_to_be_notified_rejected_promises_list(JS::NonnullGCPtr<JS::Promise> promise)
+void WindowOrWorkerGlobalScopeMixin::push_onto_about_to_be_notified_rejected_promises_list(GC::Ref<JS::Promise> promise)
 {
-    m_about_to_be_notified_rejected_promises_list.append(JS::make_handle(promise));
+    m_about_to_be_notified_rejected_promises_list.append(GC::make_root(promise));
 }
 
-bool WindowOrWorkerGlobalScopeMixin::remove_from_about_to_be_notified_rejected_promises_list(JS::NonnullGCPtr<JS::Promise> promise)
+bool WindowOrWorkerGlobalScopeMixin::remove_from_about_to_be_notified_rejected_promises_list(GC::Ref<JS::Promise> promise)
 {
     return m_about_to_be_notified_rejected_promises_list.remove_first_matching([&](auto& promise_in_list) {
         return promise == promise_in_list;
@@ -837,7 +837,7 @@ void WindowOrWorkerGlobalScopeMixin::notify_about_rejected_promises(Badge<EventL
     auto& global = verify_cast<DOM::EventTarget>(this_impl());
 
     // 5. Queue a global task on the DOM manipulation task source given global to run the following substep:
-    queue_global_task(Task::Source::DOMManipulation, global, JS::create_heap_function(realm.heap(), [this, &global, list = move(list)] {
+    queue_global_task(Task::Source::DOMManipulation, global, GC::create_function(realm.heap(), [this, &global, list = move(list)] {
         auto& realm = global.realm();
 
         // 1. For each promise p in list:
diff --git a/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.h b/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.h
index 0221b742f15..418ebc13ab2 100644
--- a/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.h
+++ b/Libraries/LibWeb/HTML/WindowOrWorkerGlobalScope.h
@@ -22,7 +22,7 @@
 namespace Web::HTML {
 
 // https://html.spec.whatwg.org/#timerhandler
-using TimerHandler = Variant<JS::NonnullGCPtr<WebIDL::CallbackType>, String>;
+using TimerHandler = Variant<GC::Ref<WebIDL::CallbackType>, String>;
 
 // https://html.spec.whatwg.org/multipage/webappapis.html#windoworworkerglobalscope
 class WindowOrWorkerGlobalScopeMixin {
@@ -36,55 +36,55 @@ public:
     WebIDL::ExceptionOr<String> origin() const;
     bool is_secure_context() const;
     bool cross_origin_isolated() const;
-    JS::NonnullGCPtr<WebIDL::Promise> create_image_bitmap(ImageBitmapSource image, Optional<ImageBitmapOptions> options = {}) const;
-    JS::NonnullGCPtr<WebIDL::Promise> create_image_bitmap(ImageBitmapSource image, WebIDL::Long sx, WebIDL::Long sy, WebIDL::Long sw, WebIDL::Long sh, Optional<ImageBitmapOptions> options = {}) const;
-    JS::NonnullGCPtr<WebIDL::Promise> fetch(Fetch::RequestInfo const&, Fetch::RequestInit const&) const;
+    GC::Ref<WebIDL::Promise> create_image_bitmap(ImageBitmapSource image, Optional<ImageBitmapOptions> options = {}) const;
+    GC::Ref<WebIDL::Promise> create_image_bitmap(ImageBitmapSource image, WebIDL::Long sx, WebIDL::Long sy, WebIDL::Long sw, WebIDL::Long sh, Optional<ImageBitmapOptions> options = {}) const;
+    GC::Ref<WebIDL::Promise> fetch(Fetch::RequestInfo const&, Fetch::RequestInit const&) const;
 
-    i32 set_timeout(TimerHandler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
-    i32 set_interval(TimerHandler, i32 timeout, JS::MarkedVector<JS::Value> arguments);
+    i32 set_timeout(TimerHandler, i32 timeout, GC::MarkedVector<JS::Value> arguments);
+    i32 set_interval(TimerHandler, i32 timeout, GC::MarkedVector<JS::Value> arguments);
     void clear_timeout(i32);
     void clear_interval(i32);
     void clear_map_of_active_timers();
 
     PerformanceTimeline::PerformanceEntryTuple& relevant_performance_entry_tuple(FlyString const& entry_type);
-    void queue_performance_entry(JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry> new_entry);
+    void queue_performance_entry(GC::Ref<PerformanceTimeline::PerformanceEntry> new_entry);
     void clear_performance_entry_buffer(Badge<HighResolutionTime::Performance>, FlyString const& entry_type);
     void remove_entries_from_performance_entry_buffer(Badge<HighResolutionTime::Performance>, FlyString const& entry_type, String entry_name);
 
-    ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> filter_buffer_map_by_name_and_type(Optional<String> name, Optional<String> type) const;
+    ErrorOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> filter_buffer_map_by_name_and_type(Optional<String> name, Optional<String> type) const;
 
-    void register_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver>);
-    void unregister_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver>);
-    bool has_registered_performance_observer(JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver>);
+    void register_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, GC::Ref<PerformanceTimeline::PerformanceObserver>);
+    void unregister_performance_observer(Badge<PerformanceTimeline::PerformanceObserver>, GC::Ref<PerformanceTimeline::PerformanceObserver>);
+    bool has_registered_performance_observer(GC::Ref<PerformanceTimeline::PerformanceObserver>);
 
     void queue_the_performance_observer_task();
 
-    void register_event_source(Badge<EventSource>, JS::NonnullGCPtr<EventSource>);
-    void unregister_event_source(Badge<EventSource>, JS::NonnullGCPtr<EventSource>);
+    void register_event_source(Badge<EventSource>, GC::Ref<EventSource>);
+    void unregister_event_source(Badge<EventSource>, GC::Ref<EventSource>);
     void forcibly_close_all_event_sources();
 
     void run_steps_after_a_timeout(i32 timeout, Function<void()> completion_step);
 
-    [[nodiscard]] JS::NonnullGCPtr<HighResolutionTime::Performance> performance();
+    [[nodiscard]] GC::Ref<HighResolutionTime::Performance> performance();
 
-    JS::NonnullGCPtr<JS::Object> supported_entry_types() const;
+    GC::Ref<JS::Object> supported_entry_types() const;
 
-    JS::NonnullGCPtr<IndexedDB::IDBFactory> indexed_db();
+    GC::Ref<IndexedDB::IDBFactory> indexed_db();
 
     void report_error(JS::Value e);
     void report_an_exception(JS::Value const& e);
 
-    [[nodiscard]] JS::NonnullGCPtr<Crypto::Crypto> crypto();
+    [[nodiscard]] GC::Ref<Crypto::Crypto> crypto();
 
     void push_onto_outstanding_rejected_promises_weak_set(JS::Promise*);
 
     // Returns true if removed, false otherwise.
     bool remove_from_outstanding_rejected_promises_weak_set(JS::Promise*);
 
-    void push_onto_about_to_be_notified_rejected_promises_list(JS::NonnullGCPtr<JS::Promise>);
+    void push_onto_about_to_be_notified_rejected_promises_list(GC::Ref<JS::Promise>);
 
     // Returns true if removed, false otherwise.
-    bool remove_from_about_to_be_notified_rejected_promises_list(JS::NonnullGCPtr<JS::Promise>);
+    bool remove_from_about_to_be_notified_rejected_promises_list(GC::Ref<JS::Promise>);
 
     void notify_about_rejected_promises(Badge<EventLoop>);
 
@@ -98,13 +98,13 @@ private:
         Yes,
         No,
     };
-    i32 run_timer_initialization_steps(TimerHandler handler, i32 timeout, JS::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id = {});
+    i32 run_timer_initialization_steps(TimerHandler handler, i32 timeout, GC::MarkedVector<JS::Value> arguments, Repeat repeat, Optional<i32> previous_id = {});
     void run_steps_after_a_timeout_impl(i32 timeout, Function<void()> completion_step, Optional<i32> timer_key = {});
 
-    JS::NonnullGCPtr<WebIDL::Promise> create_image_bitmap_impl(ImageBitmapSource& image, Optional<WebIDL::Long> sx, Optional<WebIDL::Long> sy, Optional<WebIDL::Long> sw, Optional<WebIDL::Long> sh, Optional<ImageBitmapOptions>& options) const;
+    GC::Ref<WebIDL::Promise> create_image_bitmap_impl(ImageBitmapSource& image, Optional<WebIDL::Long> sx, Optional<WebIDL::Long> sy, Optional<WebIDL::Long> sw, Optional<WebIDL::Long> sh, Optional<ImageBitmapOptions>& options) const;
 
     IDAllocator m_timer_id_allocator;
-    HashMap<int, JS::NonnullGCPtr<Timer>> m_timers;
+    HashMap<int, GC::Ref<Timer>> m_timers;
 
     // https://www.w3.org/TR/performance-timeline/#performance-timeline
     // Each global object has:
@@ -112,31 +112,31 @@ private:
     bool m_performance_observer_task_queued { false };
 
     // - a list of registered performance observer objects that is initially empty
-    OrderedHashTable<JS::NonnullGCPtr<PerformanceTimeline::PerformanceObserver>> m_registered_performance_observer_objects;
+    OrderedHashTable<GC::Ref<PerformanceTimeline::PerformanceObserver>> m_registered_performance_observer_objects;
 
     // https://www.w3.org/TR/performance-timeline/#dfn-performance-entry-buffer-map
     // a performance entry buffer map map, keyed on a DOMString, representing the entry type to which the buffer belongs. The map's value is the following tuple:
     // NOTE: See the PerformanceEntryTuple struct above for the map's value tuple.
     OrderedHashMap<FlyString, PerformanceTimeline::PerformanceEntryTuple> m_performance_entry_buffer_map;
 
-    HashTable<JS::NonnullGCPtr<EventSource>> m_registered_event_sources;
+    HashTable<GC::Ref<EventSource>> m_registered_event_sources;
 
-    JS::GCPtr<HighResolutionTime::Performance> m_performance;
+    GC::Ptr<HighResolutionTime::Performance> m_performance;
 
-    JS::GCPtr<IndexedDB::IDBFactory> m_indexed_db;
+    GC::Ptr<IndexedDB::IDBFactory> m_indexed_db;
 
-    mutable JS::GCPtr<JS::Object> m_supported_entry_types_array;
+    mutable GC::Ptr<JS::Object> m_supported_entry_types_array;
 
-    JS::GCPtr<Crypto::Crypto> m_crypto;
+    GC::Ptr<Crypto::Crypto> m_crypto;
 
     bool m_error_reporting_mode { false };
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#about-to-be-notified-rejected-promises-list
-    Vector<JS::Handle<JS::Promise>> m_about_to_be_notified_rejected_promises_list;
+    Vector<GC::Root<JS::Promise>> m_about_to_be_notified_rejected_promises_list;
 
     // https://html.spec.whatwg.org/multipage/webappapis.html#outstanding-rejected-promises-weak-set
     // The outstanding rejected promises weak set must not create strong references to any of its members, and implementations are free to limit its size, e.g. by removing old entries from it when new ones are added.
-    Vector<JS::GCPtr<JS::Promise>> m_outstanding_rejected_promises_weak_set;
+    Vector<GC::Ptr<JS::Promise>> m_outstanding_rejected_promises_weak_set;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/WindowProxy.cpp b/Libraries/LibWeb/HTML/WindowProxy.cpp
index 438d96e289c..cb97e51a9d1 100644
--- a/Libraries/LibWeb/HTML/WindowProxy.cpp
+++ b/Libraries/LibWeb/HTML/WindowProxy.cpp
@@ -5,7 +5,7 @@
  */
 
 #include <AK/Optional.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/PropertyDescriptor.h>
@@ -20,7 +20,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WindowProxy);
+GC_DEFINE_ALLOCATOR(WindowProxy);
 
 // 7.4 The WindowProxy exotic object, https://html.spec.whatwg.org/multipage/window-object.html#the-windowproxy-exotic-object
 WindowProxy::WindowProxy(JS::Realm& realm)
@@ -228,7 +228,7 @@ JS::ThrowCompletionOr<bool> WindowProxy::internal_delete(JS::PropertyKey const&
 }
 
 // 7.4.10 [[OwnPropertyKeys]] ( ), https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-ownpropertykeys
-JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> WindowProxy::internal_own_property_keys() const
+JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> WindowProxy::internal_own_property_keys() const
 {
     auto& event_loop = main_thread_event_loop();
     auto& vm = event_loop.vm();
@@ -236,7 +236,7 @@ JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> WindowProxy::internal_own_pro
     // 1. Let W be the value of the [[Window]] internal slot of this.
 
     // 2. Let keys be a new empty List.
-    auto keys = JS::MarkedVector<JS::Value> { vm.heap() };
+    auto keys = GC::MarkedVector<JS::Value> { vm.heap() };
 
     // 3. Let maxProperties be W's associated Document's document-tree child navigables's size.
     auto max_properties = m_window->associated_document().document_tree_child_navigables().size();
@@ -267,12 +267,12 @@ void WindowProxy::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_window);
 }
 
-void WindowProxy::set_window(JS::NonnullGCPtr<Window> window)
+void WindowProxy::set_window(GC::Ref<Window> window)
 {
     m_window = move(window);
 }
 
-JS::NonnullGCPtr<BrowsingContext> WindowProxy::associated_browsing_context() const
+GC::Ref<BrowsingContext> WindowProxy::associated_browsing_context() const
 {
     return *m_window->associated_document().browsing_context();
 }
diff --git a/Libraries/LibWeb/HTML/WindowProxy.h b/Libraries/LibWeb/HTML/WindowProxy.h
index 86e72b18e48..3b6f0a49d04 100644
--- a/Libraries/LibWeb/HTML/WindowProxy.h
+++ b/Libraries/LibWeb/HTML/WindowProxy.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibJS/Runtime/Object.h>
 #include <LibWeb/Forward.h>
 
@@ -16,7 +16,7 @@ namespace Web::HTML {
 
 class WindowProxy final : public JS::Object {
     JS_OBJECT(WindowProxy, JS::Object);
-    JS_DECLARE_ALLOCATOR(WindowProxy);
+    GC_DECLARE_ALLOCATOR(WindowProxy);
 
 public:
     virtual ~WindowProxy() override = default;
@@ -30,12 +30,12 @@ public:
     virtual JS::ThrowCompletionOr<JS::Value> internal_get(JS::PropertyKey const&, JS::Value receiver, JS::CacheablePropertyMetadata*, PropertyLookupPhase) const override;
     virtual JS::ThrowCompletionOr<bool> internal_set(JS::PropertyKey const&, JS::Value value, JS::Value receiver, JS::CacheablePropertyMetadata*) override;
     virtual JS::ThrowCompletionOr<bool> internal_delete(JS::PropertyKey const&) override;
-    virtual JS::ThrowCompletionOr<JS::MarkedVector<JS::Value>> internal_own_property_keys() const override;
+    virtual JS::ThrowCompletionOr<GC::MarkedVector<JS::Value>> internal_own_property_keys() const override;
 
-    JS::GCPtr<Window> window() const { return m_window; }
-    void set_window(JS::NonnullGCPtr<Window>);
+    GC::Ptr<Window> window() const { return m_window; }
+    void set_window(GC::Ref<Window>);
 
-    JS::NonnullGCPtr<BrowsingContext> associated_browsing_context() const;
+    GC::Ref<BrowsingContext> associated_browsing_context() const;
 
 private:
     explicit WindowProxy(JS::Realm&);
@@ -43,7 +43,7 @@ private:
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
     // [[Window]], https://html.spec.whatwg.org/multipage/window-object.html#concept-windowproxy-window
-    JS::GCPtr<Window> m_window;
+    GC::Ptr<Window> m_window;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/Worker.cpp b/Libraries/LibWeb/HTML/Worker.cpp
index a41b351c7e3..5a7895bb05d 100644
--- a/Libraries/LibWeb/HTML/Worker.cpp
+++ b/Libraries/LibWeb/HTML/Worker.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(Worker);
+GC_DEFINE_ALLOCATOR(Worker);
 
 // https://html.spec.whatwg.org/multipage/workers.html#dedicated-workers-and-the-worker-interface
 Worker::Worker(String const& script_url, WorkerOptions const& options, DOM::Document& document)
@@ -41,7 +41,7 @@ void Worker::visit_edges(Cell::Visitor& visitor)
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-worker
 // https://whatpr.org/html/9893/workers.html#dom-worker
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Worker>> Worker::create(String const& script_url, WorkerOptions const& options, DOM::Document& document)
+WebIDL::ExceptionOr<GC::Ref<Worker>> Worker::create(String const& script_url, WorkerOptions const& options, DOM::Document& document)
 {
     dbgln_if(WEB_WORKER_DEBUG, "WebWorker: Creating worker with script_url = {}", script_url);
 
@@ -89,7 +89,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<Worker>> Worker::create(String const& scrip
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#run-a-worker
-void Worker::run_a_worker(URL::URL& url, EnvironmentSettingsObject& outside_settings, JS::GCPtr<MessagePort> port, WorkerOptions const& options)
+void Worker::run_a_worker(URL::URL& url, EnvironmentSettingsObject& outside_settings, GC::Ptr<MessagePort> port, WorkerOptions const& options)
 {
     // 1. Let is shared be true if worker is a SharedWorker object, and false otherwise.
     // FIXME: SharedWorker support
@@ -134,7 +134,7 @@ WebIDL::ExceptionOr<void> Worker::post_message(JS::Value message, StructuredSeri
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-worker-postmessage
-WebIDL::ExceptionOr<void> Worker::post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer)
+WebIDL::ExceptionOr<void> Worker::post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer)
 {
     // The postMessage(message, transfer) and postMessage(message, options) methods on Worker objects act as if,
     // when invoked, they immediately invoked the respective postMessage(message, transfer) and
diff --git a/Libraries/LibWeb/HTML/Worker.h b/Libraries/LibWeb/HTML/Worker.h
index a60c4a411b3..d54ec2860b5 100644
--- a/Libraries/LibWeb/HTML/Worker.h
+++ b/Libraries/LibWeb/HTML/Worker.h
@@ -23,11 +23,11 @@ class Worker
     : public DOM::EventTarget
     , public HTML::AbstractWorker {
     WEB_PLATFORM_OBJECT(Worker, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Worker);
+    GC_DECLARE_ALLOCATOR(Worker);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Worker>> create(String const& script_url, WorkerOptions const& options, DOM::Document& document);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Worker>> construct_impl(JS::Realm& realm, String const& script_url, WorkerOptions const& options)
+    static WebIDL::ExceptionOr<GC::Ref<Worker>> create(String const& script_url, WorkerOptions const& options, DOM::Document& document);
+    static WebIDL::ExceptionOr<GC::Ref<Worker>> construct_impl(JS::Realm& realm, String const& script_url, WorkerOptions const& options)
     {
         auto& window = verify_cast<HTML::Window>(realm.global_object());
         return Worker::create(script_url, options, window.associated_document());
@@ -36,11 +36,11 @@ public:
     WebIDL::ExceptionOr<void> terminate();
 
     WebIDL::ExceptionOr<void> post_message(JS::Value message, StructuredSerializeOptions const&);
-    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<JS::Handle<JS::Object>> const& transfer);
+    WebIDL::ExceptionOr<void> post_message(JS::Value message, Vector<GC::Root<JS::Object>> const& transfer);
 
     virtual ~Worker() = default;
 
-    JS::GCPtr<MessagePort> outside_message_port() { return m_outside_port; }
+    GC::Ptr<MessagePort> outside_message_port() { return m_outside_port; }
 
 #undef __ENUMERATE
 #define __ENUMERATE(attribute_name, event_name)       \
@@ -62,12 +62,12 @@ private:
     String m_script_url;
     WorkerOptions m_options;
 
-    JS::GCPtr<DOM::Document> m_document;
-    JS::GCPtr<MessagePort> m_outside_port;
+    GC::Ptr<DOM::Document> m_document;
+    GC::Ptr<MessagePort> m_outside_port;
 
-    JS::GCPtr<WorkerAgent> m_agent;
+    GC::Ptr<WorkerAgent> m_agent;
 
-    void run_a_worker(URL::URL& url, EnvironmentSettingsObject& outside_settings, JS::GCPtr<MessagePort> outside_port, WorkerOptions const& options);
+    void run_a_worker(URL::URL& url, EnvironmentSettingsObject& outside_settings, GC::Ptr<MessagePort> outside_port, WorkerOptions const& options);
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/WorkerAgent.cpp b/Libraries/LibWeb/HTML/WorkerAgent.cpp
index 7fd9870f17a..67923c006c8 100644
--- a/Libraries/LibWeb/HTML/WorkerAgent.cpp
+++ b/Libraries/LibWeb/HTML/WorkerAgent.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerAgent);
+GC_DEFINE_ALLOCATOR(WorkerAgent);
 
-WorkerAgent::WorkerAgent(URL::URL url, WorkerOptions const& options, JS::GCPtr<MessagePort> outside_port, JS::NonnullGCPtr<EnvironmentSettingsObject> outside_settings)
+WorkerAgent::WorkerAgent(URL::URL url, WorkerOptions const& options, GC::Ptr<MessagePort> outside_port, GC::Ref<EnvironmentSettingsObject> outside_settings)
     : m_worker_options(options)
     , m_url(move(url))
     , m_outside_port(outside_port)
diff --git a/Libraries/LibWeb/HTML/WorkerAgent.h b/Libraries/LibWeb/HTML/WorkerAgent.h
index 004b4739cc7..06cb709ea4f 100644
--- a/Libraries/LibWeb/HTML/WorkerAgent.h
+++ b/Libraries/LibWeb/HTML/WorkerAgent.h
@@ -20,10 +20,10 @@ struct WorkerOptions {
 };
 
 class WorkerAgent : public JS::Cell {
-    JS_CELL(WorkerAgent, JS::Cell);
-    JS_DECLARE_ALLOCATOR(WorkerAgent);
+    GC_CELL(WorkerAgent, JS::Cell);
+    GC_DECLARE_ALLOCATOR(WorkerAgent);
 
-    WorkerAgent(URL::URL url, WorkerOptions const& options, JS::GCPtr<MessagePort> outside_port, JS::NonnullGCPtr<EnvironmentSettingsObject> outside_settings);
+    WorkerAgent(URL::URL url, WorkerOptions const& options, GC::Ptr<MessagePort> outside_port, GC::Ref<EnvironmentSettingsObject> outside_settings);
 
 private:
     virtual void initialize(JS::Realm&) override;
@@ -32,9 +32,9 @@ private:
     WorkerOptions m_worker_options;
     URL::URL m_url;
 
-    JS::GCPtr<MessagePort> m_message_port;
-    JS::GCPtr<MessagePort> m_outside_port;
-    JS::NonnullGCPtr<EnvironmentSettingsObject> m_outside_settings;
+    GC::Ptr<MessagePort> m_message_port;
+    GC::Ptr<MessagePort> m_outside_port;
+    GC::Ref<EnvironmentSettingsObject> m_outside_settings;
 
     RefPtr<Web::HTML::WebWorkerClient> m_worker_ipc;
 };
diff --git a/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.cpp b/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.cpp
index 5c95312bb15..b8524524db6 100644
--- a/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.cpp
+++ b/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.cpp
@@ -5,7 +5,7 @@
  */
 
 #include <AK/StringBuilder.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibJS/Runtime/VM.h>
@@ -13,7 +13,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerDebugConsoleClient);
+GC_DEFINE_ALLOCATOR(WorkerDebugConsoleClient);
 
 WorkerDebugConsoleClient::WorkerDebugConsoleClient(JS::Console& console)
     : ConsoleClient(console)
@@ -60,7 +60,7 @@ JS::ThrowCompletionOr<JS::Value> WorkerDebugConsoleClient::printer(JS::Console::
         return JS::js_undefined();
     }
 
-    auto output = TRY(generically_format_values(arguments.get<JS::MarkedVector<JS::Value>>()));
+    auto output = TRY(generically_format_values(arguments.get<GC::MarkedVector<JS::Value>>()));
     m_console->output_debug_message(log_level, output);
     return JS::js_undefined();
 }
diff --git a/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.h b/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.h
index 88e1ca1720f..fc11e00af67 100644
--- a/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.h
+++ b/Libraries/LibWeb/HTML/WorkerDebugConsoleClient.h
@@ -15,8 +15,8 @@ namespace Web::HTML {
 // NOTE: Temporary class to handle console messages from inside Workers
 
 class WorkerDebugConsoleClient final : public JS::ConsoleClient {
-    JS_CELL(WorkerDebugConsoleClient, JS::ConsoleClient);
-    JS_DECLARE_ALLOCATOR(WorkerDebugConsoleClient);
+    GC_CELL(WorkerDebugConsoleClient, JS::ConsoleClient);
+    GC_DECLARE_ALLOCATOR(WorkerDebugConsoleClient);
 
 public:
     virtual void clear() override;
diff --git a/Libraries/LibWeb/HTML/WorkerGlobalScope.cpp b/Libraries/LibWeb/HTML/WorkerGlobalScope.cpp
index 088e2486036..198830a9072 100644
--- a/Libraries/LibWeb/HTML/WorkerGlobalScope.cpp
+++ b/Libraries/LibWeb/HTML/WorkerGlobalScope.cpp
@@ -21,9 +21,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerGlobalScope);
+GC_DEFINE_ALLOCATOR(WorkerGlobalScope);
 
-WorkerGlobalScope::WorkerGlobalScope(JS::Realm& realm, JS::NonnullGCPtr<Web::Page> page)
+WorkerGlobalScope::WorkerGlobalScope(JS::Realm& realm, GC::Ref<Web::Page> page)
     : DOM::EventTarget(realm)
     , m_page(page)
 {
@@ -59,7 +59,7 @@ void WorkerGlobalScope::finalize()
     WindowOrWorkerGlobalScopeMixin::finalize();
 }
 
-void WorkerGlobalScope::set_internal_port(JS::NonnullGCPtr<MessagePort> port)
+void WorkerGlobalScope::set_internal_port(GC::Ref<MessagePort> port)
 {
     m_internal_port = port;
     m_internal_port->set_worker_event_target(*this);
@@ -130,14 +130,14 @@ WebIDL::ExceptionOr<void> WorkerGlobalScope::import_scripts(Vector<String> const
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-workerglobalscope-location
-JS::NonnullGCPtr<WorkerLocation> WorkerGlobalScope::location() const
+GC::Ref<WorkerLocation> WorkerGlobalScope::location() const
 {
     // The location attribute must return the WorkerLocation object whose associated WorkerGlobalScope object is the WorkerGlobalScope object.
     return *m_location;
 }
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-worker-navigator
-JS::NonnullGCPtr<WorkerNavigator> WorkerGlobalScope::navigator() const
+GC::Ref<WorkerNavigator> WorkerGlobalScope::navigator() const
 {
     // The navigator attribute of the WorkerGlobalScope interface must return an instance of the WorkerNavigator interface,
     // which represents the identity and state of the user agent (the client).
@@ -157,7 +157,7 @@ JS::NonnullGCPtr<WorkerNavigator> WorkerGlobalScope::navigator() const
 ENUMERATE_WORKER_GLOBAL_SCOPE_EVENT_HANDLERS(__ENUMERATE)
 #undef __ENUMERATE
 
-JS::NonnullGCPtr<CSS::FontFaceSet> WorkerGlobalScope::fonts()
+GC::Ref<CSS::FontFaceSet> WorkerGlobalScope::fonts()
 {
     if (!m_fonts)
         m_fonts = CSS::FontFaceSet::create(realm());
diff --git a/Libraries/LibWeb/HTML/WorkerGlobalScope.h b/Libraries/LibWeb/HTML/WorkerGlobalScope.h
index 0f5350bb3df..0bea5fec5f9 100644
--- a/Libraries/LibWeb/HTML/WorkerGlobalScope.h
+++ b/Libraries/LibWeb/HTML/WorkerGlobalScope.h
@@ -37,7 +37,7 @@ class WorkerGlobalScope
     , public WindowOrWorkerGlobalScopeMixin
     , public UniversalGlobalScopeMixin {
     WEB_PLATFORM_OBJECT(WorkerGlobalScope, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(WorkerGlobalScope);
+    GC_DECLARE_ALLOCATOR(WorkerGlobalScope);
 
 public:
     virtual ~WorkerGlobalScope() override;
@@ -62,10 +62,10 @@ public:
     // https://html.spec.whatwg.org/multipage/workers.html#the-workerglobalscope-common-interface
 
     // https://html.spec.whatwg.org/multipage/workers.html#dom-workerglobalscope-self
-    JS::NonnullGCPtr<WorkerGlobalScope const> self() const { return *this; }
+    GC::Ref<WorkerGlobalScope const> self() const { return *this; }
 
-    JS::NonnullGCPtr<WorkerLocation> location() const;
-    JS::NonnullGCPtr<WorkerNavigator> navigator() const;
+    GC::Ref<WorkerLocation> location() const;
+    GC::Ref<WorkerNavigator> navigator() const;
     WebIDL::ExceptionOr<void> import_scripts(Vector<String> const& urls, PerformTheFetchHook = nullptr);
 
 #undef __ENUMERATE
@@ -75,7 +75,7 @@ public:
     ENUMERATE_WORKER_GLOBAL_SCOPE_EVENT_HANDLERS(__ENUMERATE)
 #undef __ENUMERATE
 
-    JS::NonnullGCPtr<CSS::FontFaceSet> fonts();
+    GC::Ref<CSS::FontFaceSet> fonts();
 
     // Non-IDL public methods
 
@@ -84,9 +84,9 @@ public:
 
     // Spec note: While the WorkerLocation object is created after the WorkerGlobalScope object,
     //            this is not problematic as it cannot be observed from script.
-    void set_location(JS::NonnullGCPtr<WorkerLocation> loc) { m_location = move(loc); }
+    void set_location(GC::Ref<WorkerLocation> loc) { m_location = move(loc); }
 
-    void set_internal_port(JS::NonnullGCPtr<MessagePort> port);
+    void set_internal_port(GC::Ref<MessagePort> port);
 
     void initialize_web_interfaces(Badge<WorkerEnvironmentSettingsObject>) { initialize_web_interfaces_impl(); }
 
@@ -97,7 +97,7 @@ public:
     bool is_closing() const { return m_closing; }
 
 protected:
-    explicit WorkerGlobalScope(JS::Realm&, JS::NonnullGCPtr<Web::Page>);
+    explicit WorkerGlobalScope(JS::Realm&, GC::Ref<Web::Page>);
 
     virtual void initialize_web_interfaces_impl();
 
@@ -105,15 +105,15 @@ protected:
 
     virtual void finalize() override;
 
-    JS::GCPtr<MessagePort> m_internal_port;
+    GC::Ptr<MessagePort> m_internal_port;
 
 private:
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<WorkerLocation> m_location;
-    JS::GCPtr<WorkerNavigator> m_navigator;
+    GC::Ptr<WorkerLocation> m_location;
+    GC::Ptr<WorkerNavigator> m_navigator;
 
-    JS::NonnullGCPtr<Web::Page> m_page;
+    GC::Ref<Web::Page> m_page;
 
     // FIXME: Add all these internal slots
 
@@ -153,7 +153,7 @@ private:
     bool m_closing { false };
 
     // https://drafts.csswg.org/css-font-loading/#font-source
-    JS::GCPtr<CSS::FontFaceSet> m_fonts;
+    GC::Ptr<CSS::FontFaceSet> m_fonts;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/WorkerLocation.cpp b/Libraries/LibWeb/HTML/WorkerLocation.cpp
index 82e68f5228d..09687ac29d2 100644
--- a/Libraries/LibWeb/HTML/WorkerLocation.cpp
+++ b/Libraries/LibWeb/HTML/WorkerLocation.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerLocation);
+GC_DEFINE_ALLOCATOR(WorkerLocation);
 
 // https://html.spec.whatwg.org/multipage/workers.html#dom-workerlocation-href
 WebIDL::ExceptionOr<String> WorkerLocation::href() const
diff --git a/Libraries/LibWeb/HTML/WorkerLocation.h b/Libraries/LibWeb/HTML/WorkerLocation.h
index c403a07db03..c60092f6b77 100644
--- a/Libraries/LibWeb/HTML/WorkerLocation.h
+++ b/Libraries/LibWeb/HTML/WorkerLocation.h
@@ -13,7 +13,7 @@ namespace Web::HTML {
 // https://html.spec.whatwg.org/multipage/workers.html#worker-locations
 class WorkerLocation : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(WorkerLocation, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WorkerLocation);
+    GC_DECLARE_ALLOCATOR(WorkerLocation);
 
 public:
     virtual ~WorkerLocation() override;
@@ -34,7 +34,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<WorkerGlobalScope> m_global_scope;
+    GC::Ref<WorkerGlobalScope> m_global_scope;
 };
 
 }
diff --git a/Libraries/LibWeb/HTML/WorkerNavigator.cpp b/Libraries/LibWeb/HTML/WorkerNavigator.cpp
index f70d9697d02..67145d68fc0 100644
--- a/Libraries/LibWeb/HTML/WorkerNavigator.cpp
+++ b/Libraries/LibWeb/HTML/WorkerNavigator.cpp
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/WorkerNavigatorPrototype.h>
 #include <LibWeb/HTML/WorkerGlobalScope.h>
@@ -13,9 +13,9 @@
 
 namespace Web::HTML {
 
-JS_DEFINE_ALLOCATOR(WorkerNavigator);
+GC_DEFINE_ALLOCATOR(WorkerNavigator);
 
-JS::NonnullGCPtr<WorkerNavigator> WorkerNavigator::create(WorkerGlobalScope& global_scope)
+GC::Ref<WorkerNavigator> WorkerNavigator::create(WorkerGlobalScope& global_scope)
 {
     return global_scope.realm().create<WorkerNavigator>(global_scope);
 }
@@ -40,14 +40,14 @@ void WorkerNavigator::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_service_worker_container);
 }
 
-JS::NonnullGCPtr<MediaCapabilitiesAPI::MediaCapabilities> WorkerNavigator::media_capabilities()
+GC::Ref<MediaCapabilitiesAPI::MediaCapabilities> WorkerNavigator::media_capabilities()
 {
     if (!m_media_capabilities)
         m_media_capabilities = realm().create<MediaCapabilitiesAPI::MediaCapabilities>(realm());
     return *m_media_capabilities;
 }
 
-JS::NonnullGCPtr<ServiceWorkerContainer> WorkerNavigator::service_worker()
+GC::Ref<ServiceWorkerContainer> WorkerNavigator::service_worker()
 {
     if (!m_service_worker_container)
         m_service_worker_container = realm().create<ServiceWorkerContainer>(realm());
diff --git a/Libraries/LibWeb/HTML/WorkerNavigator.h b/Libraries/LibWeb/HTML/WorkerNavigator.h
index 7848e1d62e9..ab76f1347d6 100644
--- a/Libraries/LibWeb/HTML/WorkerNavigator.h
+++ b/Libraries/LibWeb/HTML/WorkerNavigator.h
@@ -27,16 +27,16 @@ class WorkerNavigator : public Bindings::PlatformObject
     , public NavigatorOnLineMixin
     , public StorageAPI::NavigatorStorage {
     WEB_PLATFORM_OBJECT(WorkerNavigator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WorkerNavigator);
+    GC_DECLARE_ALLOCATOR(WorkerNavigator);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<WorkerNavigator> create(WorkerGlobalScope&);
+    [[nodiscard]] static GC::Ref<WorkerNavigator> create(WorkerGlobalScope&);
 
-    JS::NonnullGCPtr<ServiceWorkerContainer> service_worker();
+    GC::Ref<ServiceWorkerContainer> service_worker();
 
     virtual ~WorkerNavigator() override;
 
-    JS::NonnullGCPtr<MediaCapabilitiesAPI::MediaCapabilities> media_capabilities();
+    GC::Ref<MediaCapabilitiesAPI::MediaCapabilities> media_capabilities();
 
 private:
     explicit WorkerNavigator(WorkerGlobalScope&);
@@ -48,9 +48,9 @@ private:
     virtual Bindings::PlatformObject const& this_navigator_storage_object() const override { return *this; }
 
     // https://w3c.github.io/media-capabilities/#dom-workernavigator-mediacapabilities
-    JS::GCPtr<MediaCapabilitiesAPI::MediaCapabilities> m_media_capabilities;
+    GC::Ptr<MediaCapabilitiesAPI::MediaCapabilities> m_media_capabilities;
 
-    JS::GCPtr<ServiceWorkerContainer> m_service_worker_container;
+    GC::Ptr<ServiceWorkerContainer> m_service_worker_container;
 };
 
 }
diff --git a/Libraries/LibWeb/HighResolutionTime/Performance.cpp b/Libraries/LibWeb/HighResolutionTime/Performance.cpp
index 808d5902831..6c0cdde8ff3 100644
--- a/Libraries/LibWeb/HighResolutionTime/Performance.cpp
+++ b/Libraries/LibWeb/HighResolutionTime/Performance.cpp
@@ -20,7 +20,7 @@
 
 namespace Web::HighResolutionTime {
 
-JS_DEFINE_ALLOCATOR(Performance);
+GC_DEFINE_ALLOCATOR(Performance);
 
 Performance::Performance(JS::Realm& realm)
     : DOM::EventTarget(realm)
@@ -44,7 +44,7 @@ void Performance::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_timing);
 }
 
-JS::GCPtr<NavigationTiming::PerformanceTiming> Performance::timing()
+GC::Ptr<NavigationTiming::PerformanceTiming> Performance::timing()
 {
     auto& realm = this->realm();
     if (!m_timing)
@@ -52,7 +52,7 @@ JS::GCPtr<NavigationTiming::PerformanceTiming> Performance::timing()
     return m_timing;
 }
 
-JS::GCPtr<NavigationTiming::PerformanceNavigation> Performance::navigation()
+GC::Ptr<NavigationTiming::PerformanceNavigation> Performance::navigation()
 {
     auto& realm = this->realm();
     if (!m_navigation) {
@@ -80,7 +80,7 @@ double Performance::now() const
 }
 
 // https://w3c.github.io/user-timing/#mark-method
-WebIDL::ExceptionOr<JS::NonnullGCPtr<UserTiming::PerformanceMark>> Performance::mark(String const& mark_name, UserTiming::PerformanceMarkOptions const& mark_options)
+WebIDL::ExceptionOr<GC::Ref<UserTiming::PerformanceMark>> Performance::mark(String const& mark_name, UserTiming::PerformanceMarkOptions const& mark_options)
 {
     auto& realm = this->realm();
 
@@ -166,7 +166,7 @@ WebIDL::ExceptionOr<HighResolutionTime::DOMHighResTimeStamp> Performance::conver
         auto& tuple = window_or_worker().relevant_performance_entry_tuple(PerformanceTimeline::EntryTypes::mark);
         auto& performance_entry_buffer = tuple.performance_entry_buffer;
 
-        auto maybe_entry = performance_entry_buffer.last_matching([&mark_string](JS::Handle<PerformanceTimeline::PerformanceEntry> const& entry) {
+        auto maybe_entry = performance_entry_buffer.last_matching([&mark_string](GC::Root<PerformanceTimeline::PerformanceEntry> const& entry) {
             return entry->name() == mark_string;
         });
 
@@ -188,7 +188,7 @@ WebIDL::ExceptionOr<HighResolutionTime::DOMHighResTimeStamp> Performance::conver
 }
 
 // https://w3c.github.io/user-timing/#dom-performance-measure
-WebIDL::ExceptionOr<JS::NonnullGCPtr<UserTiming::PerformanceMeasure>> Performance::measure(String const& measure_name, Variant<String, UserTiming::PerformanceMeasureOptions> const& start_or_measure_options, Optional<String> end_mark)
+WebIDL::ExceptionOr<GC::Ref<UserTiming::PerformanceMeasure>> Performance::measure(String const& measure_name, Variant<String, UserTiming::PerformanceMeasureOptions> const& start_or_measure_options, Optional<String> end_mark)
 {
     auto& realm = this->realm();
     auto& vm = this->vm();
@@ -333,7 +333,7 @@ void Performance::clear_measures(Optional<String> measure_name)
 }
 
 // https://www.w3.org/TR/performance-timeline/#getentries-method
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries() const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries() const
 {
     auto& vm = this->vm();
 
@@ -343,7 +343,7 @@ WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> P
 }
 
 // https://www.w3.org/TR/performance-timeline/#dom-performance-getentriesbytype
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries_by_type(String const& type) const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries_by_type(String const& type) const
 {
     auto& vm = this->vm();
 
@@ -353,7 +353,7 @@ WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> P
 }
 
 // https://www.w3.org/TR/performance-timeline/#dom-performance-getentriesbyname
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries_by_name(String const& name, Optional<String> type) const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> Performance::get_entries_by_name(String const& name, Optional<String> type) const
 {
     auto& vm = this->vm();
 
diff --git a/Libraries/LibWeb/HighResolutionTime/Performance.h b/Libraries/LibWeb/HighResolutionTime/Performance.h
index acfb678e6d4..ac180b899b3 100644
--- a/Libraries/LibWeb/HighResolutionTime/Performance.h
+++ b/Libraries/LibWeb/HighResolutionTime/Performance.h
@@ -17,7 +17,7 @@ namespace Web::HighResolutionTime {
 
 class Performance final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(Performance, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(Performance);
+    GC_DECLARE_ALLOCATOR(Performance);
 
 public:
     virtual ~Performance() override;
@@ -25,17 +25,17 @@ public:
     double now() const;
     double time_origin() const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<UserTiming::PerformanceMark>> mark(String const& mark_name, UserTiming::PerformanceMarkOptions const& mark_options = {});
+    WebIDL::ExceptionOr<GC::Ref<UserTiming::PerformanceMark>> mark(String const& mark_name, UserTiming::PerformanceMarkOptions const& mark_options = {});
     void clear_marks(Optional<String> mark_name);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<UserTiming::PerformanceMeasure>> measure(String const& measure_name, Variant<String, UserTiming::PerformanceMeasureOptions> const& start_or_measure_options, Optional<String> end_mark);
+    WebIDL::ExceptionOr<GC::Ref<UserTiming::PerformanceMeasure>> measure(String const& measure_name, Variant<String, UserTiming::PerformanceMeasureOptions> const& start_or_measure_options, Optional<String> end_mark);
     void clear_measures(Optional<String> measure_name);
 
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries() const;
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries_by_type(String const& type) const;
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries_by_name(String const& name, Optional<String> type) const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries() const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries_by_type(String const& type) const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries_by_name(String const& name, Optional<String> type) const;
 
-    JS::GCPtr<NavigationTiming::PerformanceTiming> timing();
-    JS::GCPtr<NavigationTiming::PerformanceNavigation> navigation();
+    GC::Ptr<NavigationTiming::PerformanceTiming> timing();
+    GC::Ptr<NavigationTiming::PerformanceNavigation> navigation();
 
 private:
     explicit Performance(JS::Realm&);
@@ -49,8 +49,8 @@ private:
     WebIDL::ExceptionOr<HighResolutionTime::DOMHighResTimeStamp> convert_name_to_timestamp(JS::Realm& realm, String const& name);
     WebIDL::ExceptionOr<HighResolutionTime::DOMHighResTimeStamp> convert_mark_to_timestamp(JS::Realm& realm, Variant<String, HighResolutionTime::DOMHighResTimeStamp> mark);
 
-    JS::GCPtr<NavigationTiming::PerformanceNavigation> m_navigation;
-    JS::GCPtr<NavigationTiming::PerformanceTiming> m_timing;
+    GC::Ptr<NavigationTiming::PerformanceNavigation> m_navigation;
+    GC::Ptr<NavigationTiming::PerformanceTiming> m_timing;
 
     Core::ElapsedTimer m_timer;
 };
diff --git a/Libraries/LibWeb/IndexedDB/IDBDatabase.cpp b/Libraries/LibWeb/IndexedDB/IDBDatabase.cpp
index f3d9400af51..361ddcbf1a8 100644
--- a/Libraries/LibWeb/IndexedDB/IDBDatabase.cpp
+++ b/Libraries/LibWeb/IndexedDB/IDBDatabase.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::IndexedDB {
 
-JS_DEFINE_ALLOCATOR(IDBDatabase);
+GC_DEFINE_ALLOCATOR(IDBDatabase);
 
 IDBDatabase::IDBDatabase(JS::Realm& realm, Database& db)
     : EventTarget(realm)
@@ -24,7 +24,7 @@ IDBDatabase::IDBDatabase(JS::Realm& realm, Database& db)
 
 IDBDatabase::~IDBDatabase() = default;
 
-JS::NonnullGCPtr<IDBDatabase> IDBDatabase::create(JS::Realm& realm, Database& db)
+GC::Ref<IDBDatabase> IDBDatabase::create(JS::Realm& realm, Database& db)
 {
     return realm.create<IDBDatabase>(realm, db);
 }
diff --git a/Libraries/LibWeb/IndexedDB/IDBDatabase.h b/Libraries/LibWeb/IndexedDB/IDBDatabase.h
index 656b676391d..cc02d21c4ed 100644
--- a/Libraries/LibWeb/IndexedDB/IDBDatabase.h
+++ b/Libraries/LibWeb/IndexedDB/IDBDatabase.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/HTML/DOMStringList.h>
 #include <LibWeb/IndexedDB/IDBRequest.h>
@@ -21,7 +21,7 @@ namespace Web::IndexedDB {
 // https://www.w3.org/TR/IndexedDB/#database-connection
 class IDBDatabase : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(IDBDatabase, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(IDBDatabase);
+    GC_DECLARE_ALLOCATOR(IDBDatabase);
 
     enum ConnectionState {
         Open,
@@ -31,17 +31,17 @@ class IDBDatabase : public DOM::EventTarget {
 public:
     virtual ~IDBDatabase() override;
 
-    [[nodiscard]] static JS::NonnullGCPtr<IDBDatabase> create(JS::Realm&, Database&);
+    [[nodiscard]] static GC::Ref<IDBDatabase> create(JS::Realm&, Database&);
 
     void set_version(u64 version) { m_version = version; }
     void set_close_pending(bool close_pending) { m_close_pending = close_pending; }
 
-    [[nodiscard]] JS::NonnullGCPtr<HTML::DOMStringList> object_store_names() { return m_object_store_names; }
+    [[nodiscard]] GC::Ref<HTML::DOMStringList> object_store_names() { return m_object_store_names; }
     [[nodiscard]] String name() const { return m_name; }
     [[nodiscard]] u64 version() const { return m_version; }
     [[nodiscard]] bool close_pending() const { return m_close_pending; }
     [[nodiscard]] ConnectionState state() const { return m_state; }
-    [[nodiscard]] JS::NonnullGCPtr<Database> associated_database() { return m_associated_database; }
+    [[nodiscard]] GC::Ref<Database> associated_database() { return m_associated_database; }
 
     void set_onabort(WebIDL::CallbackType*);
     WebIDL::CallbackType* onabort();
@@ -61,7 +61,7 @@ protected:
 private:
     u64 m_version { 0 };
     String m_name;
-    JS::NonnullGCPtr<HTML::DOMStringList> m_object_store_names;
+    GC::Ref<HTML::DOMStringList> m_object_store_names;
 
     // Each connection has a close pending flag which is initially false.
     bool m_close_pending { false };
@@ -70,7 +70,7 @@ private:
 
     // NOTE: There is an associated database in the spec, but there is no mention where it is assigned, nor where its from
     //       So we stash the one we have when opening a connection.
-    JS::NonnullGCPtr<Database> m_associated_database;
+    GC::Ref<Database> m_associated_database;
 };
 
 }
diff --git a/Libraries/LibWeb/IndexedDB/IDBFactory.cpp b/Libraries/LibWeb/IndexedDB/IDBFactory.cpp
index e27548d982a..8e7a949fda5 100644
--- a/Libraries/LibWeb/IndexedDB/IDBFactory.cpp
+++ b/Libraries/LibWeb/IndexedDB/IDBFactory.cpp
@@ -18,7 +18,7 @@
 
 namespace Web::IndexedDB {
 
-JS_DEFINE_ALLOCATOR(IDBFactory);
+GC_DEFINE_ALLOCATOR(IDBFactory);
 
 IDBFactory::IDBFactory(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -34,7 +34,7 @@ void IDBFactory::initialize(JS::Realm& realm)
 }
 
 // https://w3c.github.io/IndexedDB/#dom-idbfactory-open
-WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBOpenDBRequest>> IDBFactory::open(String const& name, Optional<u64> version)
+WebIDL::ExceptionOr<GC::Ref<IDBOpenDBRequest>> IDBFactory::open(String const& name, Optional<u64> version)
 {
     auto& realm = this->realm();
 
@@ -55,21 +55,21 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBOpenDBRequest>> IDBFactory::open(String
     auto request = IDBOpenDBRequest::create(realm);
 
     // 5. Run these steps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, storage_key, name, version, request] {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, storage_key, name, version, request] {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
         // 1. Let result be the result of opening a database connection, with storageKey, name, version if given and undefined otherwise, and request.
         auto result = open_a_database_connection(realm, storage_key.value(), name, version, request);
 
         // 2. Queue a task to run these steps:
-        HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, JS::create_heap_function(realm.heap(), [&realm, &request, result = move(result)]() mutable {
+        HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, GC::create_function(realm.heap(), [&realm, &request, result = move(result)]() mutable {
             // 1. If result is an error, then:
             if (result.is_error()) {
                 // 1. Set request’s result to undefined.
                 request->set_result(JS::js_undefined());
 
                 // 2. Set request’s error to result.
-                request->set_error(result.exception().get<JS::NonnullGCPtr<WebIDL::DOMException>>());
+                request->set_error(result.exception().get<GC::Ref<WebIDL::DOMException>>());
 
                 // 3. Set request’s done flag to true.
                 request->set_done(true);
diff --git a/Libraries/LibWeb/IndexedDB/IDBFactory.h b/Libraries/LibWeb/IndexedDB/IDBFactory.h
index 0e4bdc2d91a..1bb8649345e 100644
--- a/Libraries/LibWeb/IndexedDB/IDBFactory.h
+++ b/Libraries/LibWeb/IndexedDB/IDBFactory.h
@@ -15,12 +15,12 @@ namespace Web::IndexedDB {
 // https://w3c.github.io/IndexedDB/#idbfactory
 class IDBFactory : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(IDBFactory, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(IDBFactory);
+    GC_DECLARE_ALLOCATOR(IDBFactory);
 
 public:
     virtual ~IDBFactory() override;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBOpenDBRequest>> open(String const& name, Optional<u64> version);
+    WebIDL::ExceptionOr<GC::Ref<IDBOpenDBRequest>> open(String const& name, Optional<u64> version);
 
 protected:
     explicit IDBFactory(JS::Realm&);
diff --git a/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.cpp b/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.cpp
index a5f5cccb1a9..297ef68886c 100644
--- a/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.cpp
+++ b/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::IndexedDB {
 
-JS_DEFINE_ALLOCATOR(IDBOpenDBRequest);
+GC_DEFINE_ALLOCATOR(IDBOpenDBRequest);
 
 IDBOpenDBRequest::~IDBOpenDBRequest() = default;
 
@@ -27,7 +27,7 @@ void IDBOpenDBRequest::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(IDBOpenDBRequest);
 }
 
-JS::NonnullGCPtr<IDBOpenDBRequest> IDBOpenDBRequest::create(JS::Realm& realm)
+GC::Ref<IDBOpenDBRequest> IDBOpenDBRequest::create(JS::Realm& realm)
 {
     return realm.create<IDBOpenDBRequest>(realm);
 }
diff --git a/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.h b/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.h
index adbdd8013de..427485cc6b6 100644
--- a/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.h
+++ b/Libraries/LibWeb/IndexedDB/IDBOpenDBRequest.h
@@ -15,12 +15,12 @@ namespace Web::IndexedDB {
 // https://w3c.github.io/IndexedDB/#idbopendbrequest
 class IDBOpenDBRequest : public IDBRequest {
     WEB_PLATFORM_OBJECT(IDBOpenDBRequest, IDBRequest);
-    JS_DECLARE_ALLOCATOR(IDBOpenDBRequest);
+    GC_DECLARE_ALLOCATOR(IDBOpenDBRequest);
 
 public:
     virtual ~IDBOpenDBRequest();
 
-    [[nodiscard]] static JS::NonnullGCPtr<IDBOpenDBRequest> create(JS::Realm&);
+    [[nodiscard]] static GC::Ref<IDBOpenDBRequest> create(JS::Realm&);
 
     void set_onblocked(WebIDL::CallbackType*);
     WebIDL::CallbackType* onblocked();
diff --git a/Libraries/LibWeb/IndexedDB/IDBRequest.cpp b/Libraries/LibWeb/IndexedDB/IDBRequest.cpp
index f451251f70b..dbf7b2530e9 100644
--- a/Libraries/LibWeb/IndexedDB/IDBRequest.cpp
+++ b/Libraries/LibWeb/IndexedDB/IDBRequest.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::IndexedDB {
 
-JS_DEFINE_ALLOCATOR(IDBRequest);
+GC_DEFINE_ALLOCATOR(IDBRequest);
 
 IDBRequest::~IDBRequest() = default;
 
diff --git a/Libraries/LibWeb/IndexedDB/IDBRequest.h b/Libraries/LibWeb/IndexedDB/IDBRequest.h
index db52ca93121..2ea9aee3b05 100644
--- a/Libraries/LibWeb/IndexedDB/IDBRequest.h
+++ b/Libraries/LibWeb/IndexedDB/IDBRequest.h
@@ -13,19 +13,19 @@ namespace Web::IndexedDB {
 
 class IDBRequest : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(IDBRequest, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(IDBRequest);
+    GC_DECLARE_ALLOCATOR(IDBRequest);
 
 public:
     virtual ~IDBRequest() override;
 
     [[nodiscard]] JS::Value result() const { return m_result; }
-    [[nodiscard]] JS::GCPtr<WebIDL::DOMException> error() const { return m_error; }
+    [[nodiscard]] GC::Ptr<WebIDL::DOMException> error() const { return m_error; }
     [[nodiscard]] bool done() const { return m_done; }
     [[nodiscard]] bool processed() const { return m_processed; }
 
     void set_done(bool done) { m_done = done; }
     void set_result(JS::Value result) { m_result = result; }
-    void set_error(JS::GCPtr<WebIDL::DOMException> error) { m_error = error; }
+    void set_error(GC::Ptr<WebIDL::DOMException> error) { m_error = error; }
     void set_processed(bool processed) { m_processed = processed; }
 
     void set_onsuccess(WebIDL::CallbackType*);
@@ -46,7 +46,7 @@ private:
     bool m_done { false };
     // A request has a result and an error
     JS::Value m_result;
-    JS::GCPtr<WebIDL::DOMException> m_error;
+    GC::Ptr<WebIDL::DOMException> m_error;
     // FIXME: A request has a source object.
     // FIXME: A request has a transaction which is initially null.
 };
diff --git a/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.cpp b/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.cpp
index f521bfac3cf..89d0bf7853e 100644
--- a/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.cpp
+++ b/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::IndexedDB {
 
-JS_DEFINE_ALLOCATOR(IDBVersionChangeEvent);
+GC_DEFINE_ALLOCATOR(IDBVersionChangeEvent);
 
-JS::NonnullGCPtr<IDBVersionChangeEvent> IDBVersionChangeEvent::create(JS::Realm& realm, FlyString const& event_name, IDBVersionChangeEventInit const& event_init)
+GC::Ref<IDBVersionChangeEvent> IDBVersionChangeEvent::create(JS::Realm& realm, FlyString const& event_name, IDBVersionChangeEventInit const& event_init)
 {
     return realm.create<IDBVersionChangeEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.h b/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.h
index cb8e0858111..aa0b22324a1 100644
--- a/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.h
+++ b/Libraries/LibWeb/IndexedDB/IDBVersionChangeEvent.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/DOM/Event.h>
 #include <LibWeb/Forward.h>
 
@@ -20,12 +20,12 @@ struct IDBVersionChangeEventInit : public DOM::EventInit {
 // https://w3c.github.io/IndexedDB/#events
 class IDBVersionChangeEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(IDBVersionChangeEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(IDBVersionChangeEvent);
+    GC_DECLARE_ALLOCATOR(IDBVersionChangeEvent);
 
 public:
     virtual ~IDBVersionChangeEvent() override;
 
-    static JS::NonnullGCPtr<IDBVersionChangeEvent> create(JS::Realm&, FlyString const&, IDBVersionChangeEventInit const&);
+    static GC::Ref<IDBVersionChangeEvent> create(JS::Realm&, FlyString const&, IDBVersionChangeEventInit const&);
 
     u64 old_version() const { return m_old_version; }
     Optional<u64> new_version() const { return m_new_version; }
diff --git a/Libraries/LibWeb/IndexedDB/Internal/Algorithms.cpp b/Libraries/LibWeb/IndexedDB/Internal/Algorithms.cpp
index 366593ac0b3..19236e774f6 100644
--- a/Libraries/LibWeb/IndexedDB/Internal/Algorithms.cpp
+++ b/Libraries/LibWeb/IndexedDB/Internal/Algorithms.cpp
@@ -17,7 +17,7 @@
 namespace Web::IndexedDB {
 
 // https://w3c.github.io/IndexedDB/#open-a-database-connection
-WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS::Realm& realm, StorageAPI::StorageKey storage_key, String name, Optional<u64> maybe_version, JS::NonnullGCPtr<IDBRequest> request)
+WebIDL::ExceptionOr<GC::Ref<IDBDatabase>> open_a_database_connection(JS::Realm& realm, StorageAPI::StorageKey storage_key, String name, Optional<u64> maybe_version, GC::Ref<IDBRequest> request)
 {
     // 1. Let queue be the connection queue for storageKey and name.
     auto& queue = ConnectionQueueHandler::for_key_and_name(storage_key, name);
@@ -26,13 +26,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS
     queue.append(request);
 
     // 3. Wait until all previous requests in queue have been processed.
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(realm.vm().heap(), [queue, request]() {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(realm.vm().heap(), [queue, request]() {
         return queue.all_previous_requests_processed(request);
     }));
 
     // 4. Let db be the database named name in storageKey, or null otherwise.
     auto maybe_db = Database::for_key_and_name(storage_key, name);
-    JS::GCPtr<Database> db;
+    GC::Ptr<Database> db;
 
     // 5. If version is undefined, let version be 1 if db is null, or db’s version otherwise.
     auto version = maybe_version.value_or(maybe_db.has_value() ? maybe_db.value()->version() : 1);
@@ -69,7 +69,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS
         //    queue a task to fire a version change event named versionchange at entry with db’s version and version.
         for (auto& entry : open_connections) {
             if (!entry->close_pending()) {
-                HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, JS::create_heap_function(realm.vm().heap(), [&realm, entry, db, version]() {
+                HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, GC::create_function(realm.vm().heap(), [&realm, entry, db, version]() {
                     fire_a_version_change_event(realm, HTML::EventNames::versionchange, *entry, db->version(), version);
                 }));
             }
@@ -81,14 +81,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS
         //    queue a task to fire a version change event named blocked at request with db’s version and version.
         for (auto& entry : open_connections) {
             if (entry->state() != IDBDatabase::ConnectionState::Closed) {
-                HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, JS::create_heap_function(realm.vm().heap(), [&realm, entry, db, version]() {
+                HTML::queue_a_task(HTML::Task::Source::DatabaseAccess, nullptr, nullptr, GC::create_function(realm.vm().heap(), [&realm, entry, db, version]() {
                     fire_a_version_change_event(realm, HTML::EventNames::blocked, *entry, db->version(), version);
                 }));
             }
         }
 
         // 5. Wait until all connections in openConnections are closed.
-        HTML::main_thread_event_loop().spin_until(JS::create_heap_function(realm.vm().heap(), [open_connections]() {
+        HTML::main_thread_event_loop().spin_until(GC::create_function(realm.vm().heap(), [open_connections]() {
             for (auto const& entry : open_connections) {
                 if (entry->state() != IDBDatabase::ConnectionState::Closed) {
                     return false;
@@ -115,7 +115,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS
     return connection;
 }
 
-bool fire_a_version_change_event(JS::Realm& realm, FlyString const& event_name, JS::NonnullGCPtr<DOM::EventTarget> target, u64 old_version, Optional<u64> new_version)
+bool fire_a_version_change_event(JS::Realm& realm, FlyString const& event_name, GC::Ref<DOM::EventTarget> target, u64 old_version, Optional<u64> new_version)
 {
     IDBVersionChangeEventInit event_init = {};
     // 4. Set event’s oldVersion attribute to oldVersion.
diff --git a/Libraries/LibWeb/IndexedDB/Internal/Algorithms.h b/Libraries/LibWeb/IndexedDB/Internal/Algorithms.h
index b56fb34a00d..b81d76af823 100644
--- a/Libraries/LibWeb/IndexedDB/Internal/Algorithms.h
+++ b/Libraries/LibWeb/IndexedDB/Internal/Algorithms.h
@@ -12,7 +12,7 @@
 
 namespace Web::IndexedDB {
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<IDBDatabase>> open_a_database_connection(JS::Realm&, StorageAPI::StorageKey, String, Optional<u64>, JS::NonnullGCPtr<IDBRequest>);
-bool fire_a_version_change_event(JS::Realm&, FlyString const&, JS::NonnullGCPtr<DOM::EventTarget>, u64, Optional<u64>);
+WebIDL::ExceptionOr<GC::Ref<IDBDatabase>> open_a_database_connection(JS::Realm&, StorageAPI::StorageKey, String, Optional<u64>, GC::Ref<IDBRequest>);
+bool fire_a_version_change_event(JS::Realm&, FlyString const&, GC::Ref<DOM::EventTarget>, u64, Optional<u64>);
 
 }
diff --git a/Libraries/LibWeb/IndexedDB/Internal/ConnectionQueueHandler.h b/Libraries/LibWeb/IndexedDB/Internal/ConnectionQueueHandler.h
index 9a4bd9ff9f1..c9715830576 100644
--- a/Libraries/LibWeb/IndexedDB/Internal/ConnectionQueueHandler.h
+++ b/Libraries/LibWeb/IndexedDB/Internal/ConnectionQueueHandler.h
@@ -7,16 +7,16 @@
 #pragma once
 
 #include <AK/HashMap.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/IndexedDB/IDBRequest.h>
 #include <LibWeb/StorageAPI/StorageKey.h>
 
 namespace Web::IndexedDB {
 
-class ConnectionQueue : public AK::Vector<JS::Handle<IDBRequest>> {
+class ConnectionQueue : public AK::Vector<GC::Root<IDBRequest>> {
 public:
-    bool all_previous_requests_processed(JS::NonnullGCPtr<IDBRequest> const& request) const
+    bool all_previous_requests_processed(GC::Ref<IDBRequest> const& request) const
     {
         for (auto const& entry : *this) {
             if (entry == request)
diff --git a/Libraries/LibWeb/IndexedDB/Internal/Database.cpp b/Libraries/LibWeb/IndexedDB/Internal/Database.cpp
index 1daa55ccd6a..456fe770844 100644
--- a/Libraries/LibWeb/IndexedDB/Internal/Database.cpp
+++ b/Libraries/LibWeb/IndexedDB/Internal/Database.cpp
@@ -9,14 +9,14 @@
 
 namespace Web::IndexedDB {
 
-using IDBDatabaseMapping = HashMap<StorageAPI::StorageKey, HashMap<String, JS::Handle<Database>>>;
+using IDBDatabaseMapping = HashMap<StorageAPI::StorageKey, HashMap<String, GC::Root<Database>>>;
 static IDBDatabaseMapping m_databases;
 
-JS_DEFINE_ALLOCATOR(Database);
+GC_DEFINE_ALLOCATOR(Database);
 
 Database::~Database() = default;
 
-JS::NonnullGCPtr<Database> Database::create(JS::Realm& realm, String const& name)
+GC::Ref<Database> Database::create(JS::Realm& realm, String const& name)
 {
     return realm.create<Database>(realm, name);
 }
@@ -37,18 +37,18 @@ ConnectionQueue& ConnectionQueueHandler::for_key_and_name(StorageAPI::StorageKey
         });
 }
 
-Optional<JS::Handle<Database>> Database::for_key_and_name(StorageAPI::StorageKey& key, String& name)
+Optional<GC::Root<Database>> Database::for_key_and_name(StorageAPI::StorageKey& key, String& name)
 {
     return m_databases.ensure(key, [] {
-                          return HashMap<String, JS::Handle<Database>>();
+                          return HashMap<String, GC::Root<Database>>();
                       })
         .get(name);
 }
 
-ErrorOr<JS::Handle<Database>> Database::create_for_key_and_name(JS::Realm& realm, StorageAPI::StorageKey& key, String& name)
+ErrorOr<GC::Root<Database>> Database::create_for_key_and_name(JS::Realm& realm, StorageAPI::StorageKey& key, String& name)
 {
     auto database_mapping = TRY(m_databases.try_ensure(key, [] {
-        return HashMap<String, JS::Handle<Database>>();
+        return HashMap<String, GC::Root<Database>>();
     }));
 
     return database_mapping.try_ensure(name, [&] {
diff --git a/Libraries/LibWeb/IndexedDB/Internal/Database.h b/Libraries/LibWeb/IndexedDB/Internal/Database.h
index 303d1a9bfa5..0da84efaffa 100644
--- a/Libraries/LibWeb/IndexedDB/Internal/Database.h
+++ b/Libraries/LibWeb/IndexedDB/Internal/Database.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/HashMap.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/DOM/EventTarget.h>
 #include <LibWeb/IndexedDB/IDBDatabase.h>
 #include <LibWeb/IndexedDB/IDBRequest.h>
@@ -18,18 +18,18 @@ namespace Web::IndexedDB {
 // https://www.w3.org/TR/IndexedDB/#database-construct
 class Database : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Database, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Database);
+    GC_DECLARE_ALLOCATOR(Database);
 
 public:
     void set_version(u64 version) { m_version = version; }
     u64 version() const { return m_version; }
     String name() const { return m_name; }
 
-    void associate(JS::NonnullGCPtr<IDBDatabase> connection) { m_associated_connections.append(connection); }
-    ReadonlySpan<JS::NonnullGCPtr<IDBDatabase>> associated_connections() { return m_associated_connections; }
-    Vector<JS::Handle<IDBDatabase>> associated_connections_except(IDBDatabase& connection)
+    void associate(GC::Ref<IDBDatabase> connection) { m_associated_connections.append(connection); }
+    ReadonlySpan<GC::Ref<IDBDatabase>> associated_connections() { return m_associated_connections; }
+    Vector<GC::Root<IDBDatabase>> associated_connections_except(IDBDatabase& connection)
     {
-        Vector<JS::Handle<IDBDatabase>> connections;
+        Vector<GC::Root<IDBDatabase>> connections;
         for (auto& associated_connection : m_associated_connections) {
             if (associated_connection != &connection)
                 connections.append(associated_connection);
@@ -37,11 +37,11 @@ public:
         return connections;
     }
 
-    [[nodiscard]] static Optional<JS::Handle<Database>> for_key_and_name(StorageAPI::StorageKey&, String&);
-    [[nodiscard]] static ErrorOr<JS::Handle<Database>> create_for_key_and_name(JS::Realm&, StorageAPI::StorageKey&, String&);
+    [[nodiscard]] static Optional<GC::Root<Database>> for_key_and_name(StorageAPI::StorageKey&, String&);
+    [[nodiscard]] static ErrorOr<GC::Root<Database>> create_for_key_and_name(JS::Realm&, StorageAPI::StorageKey&, String&);
     [[nodiscard]] static ErrorOr<void> delete_for_key_and_name(StorageAPI::StorageKey&, String&);
 
-    [[nodiscard]] static JS::NonnullGCPtr<Database> create(JS::Realm&, String const&);
+    [[nodiscard]] static GC::Ref<Database> create(JS::Realm&, String const&);
     virtual ~Database();
 
 protected:
@@ -56,7 +56,7 @@ protected:
     virtual void visit_edges(Visitor&) override;
 
 private:
-    Vector<JS::NonnullGCPtr<IDBDatabase>> m_associated_connections;
+    Vector<GC::Ref<IDBDatabase>> m_associated_connections;
 
     // FIXME: A database has zero or more object stores which hold the data stored in the database.
 
diff --git a/Libraries/LibWeb/Internals/Inspector.cpp b/Libraries/LibWeb/Internals/Inspector.cpp
index b0c597d39ce..7406b94612a 100644
--- a/Libraries/LibWeb/Internals/Inspector.cpp
+++ b/Libraries/LibWeb/Internals/Inspector.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::Internals {
 
-JS_DEFINE_ALLOCATOR(Inspector);
+GC_DEFINE_ALLOCATOR(Inspector);
 
 Inspector::Inspector(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -59,12 +59,12 @@ void Inspector::set_dom_node_tag(i64 node_id, String const& tag)
     inspector_page_client().inspector_did_set_dom_node_tag(node_id, tag);
 }
 
-void Inspector::add_dom_node_attributes(i64 node_id, JS::NonnullGCPtr<DOM::NamedNodeMap> attributes)
+void Inspector::add_dom_node_attributes(i64 node_id, GC::Ref<DOM::NamedNodeMap> attributes)
 {
     inspector_page_client().inspector_did_add_dom_node_attributes(node_id, attributes);
 }
 
-void Inspector::replace_dom_node_attribute(i64 node_id, WebIDL::UnsignedLongLong attribute_index, JS::NonnullGCPtr<DOM::NamedNodeMap> replacement_attributes)
+void Inspector::replace_dom_node_attribute(i64 node_id, WebIDL::UnsignedLongLong attribute_index, GC::Ref<DOM::NamedNodeMap> replacement_attributes)
 {
     inspector_page_client().inspector_did_replace_dom_node_attribute(node_id, static_cast<size_t>(attribute_index), replacement_attributes);
 }
diff --git a/Libraries/LibWeb/Internals/Inspector.h b/Libraries/LibWeb/Internals/Inspector.h
index 66aef85bdb5..f888feb702c 100644
--- a/Libraries/LibWeb/Internals/Inspector.h
+++ b/Libraries/LibWeb/Internals/Inspector.h
@@ -14,7 +14,7 @@ namespace Web::Internals {
 
 class Inspector final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Inspector, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Inspector);
+    GC_DECLARE_ALLOCATOR(Inspector);
 
 public:
     virtual ~Inspector() override;
@@ -24,8 +24,8 @@ public:
 
     void set_dom_node_text(i64 node_id, String const& text);
     void set_dom_node_tag(i64 node_id, String const& tag);
-    void add_dom_node_attributes(i64 node_id, JS::NonnullGCPtr<DOM::NamedNodeMap> attributes);
-    void replace_dom_node_attribute(i64 node_id, WebIDL::UnsignedLongLong attribute_index, JS::NonnullGCPtr<DOM::NamedNodeMap> replacement_attributes);
+    void add_dom_node_attributes(i64 node_id, GC::Ref<DOM::NamedNodeMap> attributes);
+    void replace_dom_node_attribute(i64 node_id, WebIDL::UnsignedLongLong attribute_index, GC::Ref<DOM::NamedNodeMap> replacement_attributes);
 
     void request_dom_tree_context_menu(i64 node_id, i32 client_x, i32 client_y, String const& type, Optional<String> const& tag, Optional<WebIDL::UnsignedLongLong> const& attribute_index);
 
diff --git a/Libraries/LibWeb/Internals/InternalAnimationTimeline.cpp b/Libraries/LibWeb/Internals/InternalAnimationTimeline.cpp
index a255e11fa69..47eb4a994af 100644
--- a/Libraries/LibWeb/Internals/InternalAnimationTimeline.cpp
+++ b/Libraries/LibWeb/Internals/InternalAnimationTimeline.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::Internals {
 
-JS_DEFINE_ALLOCATOR(InternalAnimationTimeline);
+GC_DEFINE_ALLOCATOR(InternalAnimationTimeline);
 
 void InternalAnimationTimeline::set_current_time(Optional<double> current_time)
 {
diff --git a/Libraries/LibWeb/Internals/InternalAnimationTimeline.h b/Libraries/LibWeb/Internals/InternalAnimationTimeline.h
index f10477a1de1..8b1ddd53141 100644
--- a/Libraries/LibWeb/Internals/InternalAnimationTimeline.h
+++ b/Libraries/LibWeb/Internals/InternalAnimationTimeline.h
@@ -13,7 +13,7 @@ namespace Web::Internals {
 class InternalAnimationTimeline : public Web::Animations::AnimationTimeline {
 public:
     WEB_PLATFORM_OBJECT(InternalAnimationTimeline, Web::Animations::AnimationTimeline);
-    JS_DECLARE_ALLOCATOR(InternalAnimationTimeline);
+    GC_DECLARE_ALLOCATOR(InternalAnimationTimeline);
 
     virtual void set_current_time(Optional<double> current_time) override;
 
diff --git a/Libraries/LibWeb/Internals/Internals.cpp b/Libraries/LibWeb/Internals/Internals.cpp
index 6319bd7f6c6..577ca4abce7 100644
--- a/Libraries/LibWeb/Internals/Internals.cpp
+++ b/Libraries/LibWeb/Internals/Internals.cpp
@@ -21,7 +21,7 @@
 
 namespace Web::Internals {
 
-JS_DEFINE_ALLOCATOR(Internals);
+GC_DEFINE_ALLOCATOR(Internals);
 
 Internals::Internals(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -158,7 +158,7 @@ void Internals::spoof_current_url(String const& url_string)
     HTML::relevant_settings_object(window.associated_document()).creation_url = url;
 }
 
-JS::NonnullGCPtr<InternalAnimationTimeline> Internals::create_internal_animation_timeline()
+GC::Ref<InternalAnimationTimeline> Internals::create_internal_animation_timeline()
 {
     auto& realm = this->realm();
     return realm.create<InternalAnimationTimeline>(realm);
diff --git a/Libraries/LibWeb/Internals/Internals.h b/Libraries/LibWeb/Internals/Internals.h
index 4e9bfe492a9..6e8584913b8 100644
--- a/Libraries/LibWeb/Internals/Internals.h
+++ b/Libraries/LibWeb/Internals/Internals.h
@@ -15,7 +15,7 @@ namespace Web::Internals {
 
 class Internals final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Internals, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Internals);
+    GC_DECLARE_ALLOCATOR(Internals);
 
 public:
     virtual ~Internals() override;
@@ -39,7 +39,7 @@ public:
 
     void spoof_current_url(String const& url);
 
-    JS::NonnullGCPtr<InternalAnimationTimeline> create_internal_animation_timeline();
+    GC::Ref<InternalAnimationTimeline> create_internal_animation_timeline();
 
     void simulate_drag_start(double x, double y, String const& name, String const& contents);
     void simulate_drag_move(double x, double y);
diff --git a/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.cpp b/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.cpp
index 173113085a7..f8fa224e502 100644
--- a/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.cpp
+++ b/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.cpp
@@ -16,10 +16,10 @@
 
 namespace Web::IntersectionObserver {
 
-JS_DEFINE_ALLOCATOR(IntersectionObserver);
+GC_DEFINE_ALLOCATOR(IntersectionObserver);
 
 // https://w3c.github.io/IntersectionObserver/#dom-intersectionobserver-intersectionobserver
-WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserver>> IntersectionObserver::construct_impl(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback, IntersectionObserverInit const& options)
+WebIDL::ExceptionOr<GC::Ref<IntersectionObserver>> IntersectionObserver::construct_impl(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback, IntersectionObserverInit const& options)
 {
     // 4. Let thresholds be a list equal to options.threshold.
     Vector<double> thresholds;
@@ -48,12 +48,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserver>> IntersectionObserver
     return realm.create<IntersectionObserver>(realm, callback, options.root, move(thresholds));
 }
 
-IntersectionObserver::IntersectionObserver(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback, Optional<Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>>> const& root, Vector<double>&& thresholds)
+IntersectionObserver::IntersectionObserver(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback, Optional<Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>>> const& root, Vector<double>&& thresholds)
     : PlatformObject(realm)
     , m_callback(callback)
     , m_thresholds(move(thresholds))
 {
-    m_root = root.has_value() ? root->visit([](auto& value) -> JS::GCPtr<DOM::Node> { return *value; }) : nullptr;
+    m_root = root.has_value() ? root->visit([](auto& value) -> GC::Ptr<DOM::Node> { return *value; }) : nullptr;
     intersection_root().visit([this](auto& node) {
         m_document = node->document();
     });
@@ -89,7 +89,7 @@ void IntersectionObserver::observe(DOM::Element& target)
     // Run the observe a target Element algorithm, providing this and target.
     // https://www.w3.org/TR/intersection-observer/#observe-a-target-element
     // 1. If target is in observer’s internal [[ObservationTargets]] slot, return.
-    if (m_observation_targets.contains_slow(JS::NonnullGCPtr { target }))
+    if (m_observation_targets.contains_slow(GC::Ref { target }))
         return;
 
     // 2. Let intersectionObserverRegistration be an IntersectionObserverRegistration record with an observer
@@ -117,7 +117,7 @@ void IntersectionObserver::unobserve(DOM::Element& target)
     target.unregister_intersection_observer({}, *this);
 
     // 2. Remove target from this’s internal [[ObservationTargets]] slot, if present
-    m_observation_targets.remove_first_matching([&target](JS::NonnullGCPtr<DOM::Element> const& entry) {
+    m_observation_targets.remove_first_matching([&target](GC::Ref<DOM::Element> const& entry) {
         return entry.ptr() == &target;
     });
 }
@@ -136,10 +136,10 @@ void IntersectionObserver::disconnect()
 }
 
 // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-takerecords
-Vector<JS::Handle<IntersectionObserverEntry>> IntersectionObserver::take_records()
+Vector<GC::Root<IntersectionObserverEntry>> IntersectionObserver::take_records()
 {
     // 1. Let queue be a copy of this’s internal [[QueuedEntries]] slot.
-    Vector<JS::Handle<IntersectionObserverEntry>> queue;
+    Vector<GC::Root<IntersectionObserverEntry>> queue;
     for (auto& entry : m_queued_entries)
         queue.append(*entry);
 
@@ -150,32 +150,32 @@ Vector<JS::Handle<IntersectionObserverEntry>> IntersectionObserver::take_records
     return queue;
 }
 
-Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>, Empty> IntersectionObserver::root() const
+Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>, Empty> IntersectionObserver::root() const
 {
     if (!m_root)
         return Empty {};
     if (m_root->is_element())
-        return JS::make_handle(static_cast<DOM::Element&>(*m_root));
+        return GC::make_root(static_cast<DOM::Element&>(*m_root));
     if (m_root->is_document())
-        return JS::make_handle(static_cast<DOM::Document&>(*m_root));
+        return GC::make_root(static_cast<DOM::Document&>(*m_root));
     VERIFY_NOT_REACHED();
 }
 
 // https://www.w3.org/TR/intersection-observer/#intersectionobserver-intersection-root
-Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>> IntersectionObserver::intersection_root() const
+Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>> IntersectionObserver::intersection_root() const
 {
     // The intersection root for an IntersectionObserver is the value of its root attribute
     // if the attribute is non-null;
     if (m_root) {
         if (m_root->is_element())
-            return JS::make_handle(static_cast<DOM::Element&>(*m_root));
+            return GC::make_root(static_cast<DOM::Element&>(*m_root));
         if (m_root->is_document())
-            return JS::make_handle(static_cast<DOM::Document&>(*m_root));
+            return GC::make_root(static_cast<DOM::Document&>(*m_root));
         VERIFY_NOT_REACHED();
     }
 
     // otherwise, it is the top-level browsing context’s document node, referred to as the implicit root.
-    return JS::make_handle(verify_cast<HTML::Window>(HTML::relevant_global_object(*this)).page().top_level_browsing_context().active_document());
+    return GC::make_root(verify_cast<HTML::Window>(HTML::relevant_global_object(*this)).page().top_level_browsing_context().active_document());
 }
 
 // https://www.w3.org/TR/intersection-observer/#intersectionobserver-root-intersection-rectangle
@@ -189,8 +189,8 @@ CSSPixelRect IntersectionObserver::root_intersection_rectangle() const
 
     // If the intersection root is a document,
     //    it’s the size of the document's viewport (note that this processing step can only be reached if the document is fully active).
-    if (intersection_root.has<JS::Handle<DOM::Document>>()) {
-        auto document = intersection_root.get<JS::Handle<DOM::Document>>();
+    if (intersection_root.has<GC::Root<DOM::Document>>()) {
+        auto document = intersection_root.get<GC::Root<DOM::Document>>();
 
         // Since the spec says that this is only reach if the document is fully active, that means it must have a navigable.
         VERIFY(document->navigable());
@@ -199,8 +199,8 @@ CSSPixelRect IntersectionObserver::root_intersection_rectangle() const
         //       as intersections are computed using viewport-relative element rects.
         rect = CSSPixelRect { CSSPixelPoint { 0, 0 }, document->viewport_rect().size() };
     } else {
-        VERIFY(intersection_root.has<JS::Handle<DOM::Element>>());
-        auto element = intersection_root.get<JS::Handle<DOM::Element>>();
+        VERIFY(intersection_root.has<GC::Root<DOM::Element>>());
+        auto element = intersection_root.get<GC::Root<DOM::Element>>();
 
         // FIXME: Otherwise, if the intersection root has a content clip,
         //          it’s the element’s content area.
@@ -220,7 +220,7 @@ CSSPixelRect IntersectionObserver::root_intersection_rectangle() const
     return rect;
 }
 
-void IntersectionObserver::queue_entry(Badge<DOM::Document>, JS::NonnullGCPtr<IntersectionObserverEntry> entry)
+void IntersectionObserver::queue_entry(Badge<DOM::Document>, GC::Ref<IntersectionObserverEntry> entry)
 {
     m_queued_entries.append(entry);
 }
diff --git a/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.h b/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.h
index 72676e9e6fa..2ef1ae2899b 100644
--- a/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.h
+++ b/Libraries/LibWeb/IntersectionObserver/IntersectionObserver.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/IntersectionObserver/IntersectionObserverEntry.h>
 #include <LibWeb/PixelUnits.h>
@@ -14,7 +14,7 @@
 namespace Web::IntersectionObserver {
 
 struct IntersectionObserverInit {
-    Optional<Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>>> root;
+    Optional<Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>>> root;
     String root_margin { "0px"_string };
     Variant<double, Vector<double>> threshold { 0 };
 };
@@ -23,7 +23,7 @@ struct IntersectionObserverInit {
 struct IntersectionObserverRegistration {
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverregistration-observer
     // [A]n observer property holding an IntersectionObserver.
-    JS::NonnullGCPtr<IntersectionObserver> observer;
+    GC::Ref<IntersectionObserver> observer;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverregistration-observer
     // NOTE: Optional is used in place of the spec using -1 to indicate no previous index.
@@ -38,51 +38,51 @@ struct IntersectionObserverRegistration {
 // https://w3c.github.io/IntersectionObserver/#intersection-observer-interface
 class IntersectionObserver final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(IntersectionObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(IntersectionObserver);
+    GC_DECLARE_ALLOCATOR(IntersectionObserver);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserver>> construct_impl(JS::Realm&, JS::GCPtr<WebIDL::CallbackType> callback, IntersectionObserverInit const& options = {});
+    static WebIDL::ExceptionOr<GC::Ref<IntersectionObserver>> construct_impl(JS::Realm&, GC::Ptr<WebIDL::CallbackType> callback, IntersectionObserverInit const& options = {});
 
     virtual ~IntersectionObserver() override;
 
     void observe(DOM::Element& target);
     void unobserve(DOM::Element& target);
     void disconnect();
-    Vector<JS::Handle<IntersectionObserverEntry>> take_records();
+    Vector<GC::Root<IntersectionObserverEntry>> take_records();
 
-    Vector<JS::NonnullGCPtr<DOM::Element>> const& observation_targets() const { return m_observation_targets; }
+    Vector<GC::Ref<DOM::Element>> const& observation_targets() const { return m_observation_targets; }
 
-    Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>, Empty> root() const;
+    Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>, Empty> root() const;
     Vector<double> const& thresholds() const { return m_thresholds; }
 
-    Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>> intersection_root() const;
+    Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>> intersection_root() const;
     CSSPixelRect root_intersection_rectangle() const;
 
-    void queue_entry(Badge<DOM::Document>, JS::NonnullGCPtr<IntersectionObserverEntry>);
+    void queue_entry(Badge<DOM::Document>, GC::Ref<IntersectionObserverEntry>);
 
     WebIDL::CallbackType& callback() { return *m_callback; }
 
 private:
-    explicit IntersectionObserver(JS::Realm&, JS::GCPtr<WebIDL::CallbackType> callback, Optional<Variant<JS::Handle<DOM::Element>, JS::Handle<DOM::Document>>> const& root, Vector<double>&& thresholds);
+    explicit IntersectionObserver(JS::Realm&, GC::Ptr<WebIDL::CallbackType> callback, Optional<Variant<GC::Root<DOM::Element>, GC::Root<DOM::Document>>> const& root, Vector<double>&& thresholds);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
     virtual void finalize() override;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-callback-slot
-    JS::GCPtr<WebIDL::CallbackType> m_callback;
+    GC::Ptr<WebIDL::CallbackType> m_callback;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-root
-    JS::GCPtr<DOM::Node> m_root;
+    GC::Ptr<DOM::Node> m_root;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-thresholds
     Vector<double> m_thresholds;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-queuedentries-slot
-    Vector<JS::NonnullGCPtr<IntersectionObserverEntry>> m_queued_entries;
+    Vector<GC::Ref<IntersectionObserverEntry>> m_queued_entries;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserver-observationtargets-slot
-    Vector<JS::NonnullGCPtr<DOM::Element>> m_observation_targets;
+    Vector<GC::Ref<DOM::Element>> m_observation_targets;
 
     // AD-HOC: This is the document where we've registered the IntersectionObserver.
     WeakPtr<DOM::Document> m_document;
diff --git a/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.cpp b/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.cpp
index 1a060633d70..499fcbdd7ef 100644
--- a/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.cpp
+++ b/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.cpp
@@ -11,13 +11,13 @@
 
 namespace Web::IntersectionObserver {
 
-JS_DEFINE_ALLOCATOR(IntersectionObserverEntry);
+GC_DEFINE_ALLOCATOR(IntersectionObserverEntry);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserverEntry>> IntersectionObserverEntry::construct_impl(JS::Realm& realm, Web::IntersectionObserver::IntersectionObserverEntryInit const& options)
+WebIDL::ExceptionOr<GC::Ref<IntersectionObserverEntry>> IntersectionObserverEntry::construct_impl(JS::Realm& realm, Web::IntersectionObserver::IntersectionObserverEntryInit const& options)
 {
     auto& vm = realm.vm();
 
-    JS::GCPtr<Geometry::DOMRectReadOnly> root_bounds;
+    GC::Ptr<Geometry::DOMRectReadOnly> root_bounds;
     if (options.root_bounds.has_value())
         root_bounds = Geometry::DOMRectReadOnly::from_rect(vm, options.root_bounds.value());
 
@@ -26,7 +26,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserverEntry>> IntersectionObs
     return realm.create<IntersectionObserverEntry>(realm, options.time, root_bounds, bounding_client_rect, intersection_rect, options.is_intersecting, options.intersection_ratio, *options.target);
 }
 
-IntersectionObserverEntry::IntersectionObserverEntry(JS::Realm& realm, HighResolutionTime::DOMHighResTimeStamp time, JS::GCPtr<Geometry::DOMRectReadOnly> root_bounds, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, JS::NonnullGCPtr<DOM::Element> target)
+IntersectionObserverEntry::IntersectionObserverEntry(JS::Realm& realm, HighResolutionTime::DOMHighResTimeStamp time, GC::Ptr<Geometry::DOMRectReadOnly> root_bounds, GC::Ref<Geometry::DOMRectReadOnly> bounding_client_rect, GC::Ref<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, GC::Ref<DOM::Element> target)
     : Bindings::PlatformObject(realm)
     , m_time(time)
     , m_root_bounds(root_bounds)
diff --git a/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.h b/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.h
index fb66952f1be..6c47e4fa3f8 100644
--- a/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.h
+++ b/Libraries/LibWeb/IntersectionObserver/IntersectionObserverEntry.h
@@ -32,28 +32,28 @@ struct IntersectionObserverEntryInit {
     double intersection_ratio { 0.0 };
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-target
-    JS::Handle<DOM::Element> target;
+    GC::Root<DOM::Element> target;
 };
 
 class IntersectionObserverEntry final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(IntersectionObserverEntry, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(IntersectionObserverEntry);
+    GC_DECLARE_ALLOCATOR(IntersectionObserverEntry);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<IntersectionObserverEntry>> construct_impl(JS::Realm&, IntersectionObserverEntryInit const& options);
+    static WebIDL::ExceptionOr<GC::Ref<IntersectionObserverEntry>> construct_impl(JS::Realm&, IntersectionObserverEntryInit const& options);
 
     virtual ~IntersectionObserverEntry() override;
 
     HighResolutionTime::DOMHighResTimeStamp time() const { return m_time; }
-    JS::GCPtr<Geometry::DOMRectReadOnly> root_bounds() const { return m_root_bounds; }
-    JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect() const { return m_bounding_client_rect; }
-    JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect() const { return m_intersection_rect; }
+    GC::Ptr<Geometry::DOMRectReadOnly> root_bounds() const { return m_root_bounds; }
+    GC::Ref<Geometry::DOMRectReadOnly> bounding_client_rect() const { return m_bounding_client_rect; }
+    GC::Ref<Geometry::DOMRectReadOnly> intersection_rect() const { return m_intersection_rect; }
     bool is_intersecting() const { return m_is_intersecting; }
     double intersection_ratio() const { return m_intersection_ratio; }
-    JS::NonnullGCPtr<DOM::Element> target() const { return m_target; }
+    GC::Ref<DOM::Element> target() const { return m_target; }
 
 private:
-    IntersectionObserverEntry(JS::Realm&, HighResolutionTime::DOMHighResTimeStamp time, JS::GCPtr<Geometry::DOMRectReadOnly> root_bounds, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> bounding_client_rect, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, JS::NonnullGCPtr<DOM::Element> target);
+    IntersectionObserverEntry(JS::Realm&, HighResolutionTime::DOMHighResTimeStamp time, GC::Ptr<Geometry::DOMRectReadOnly> root_bounds, GC::Ref<Geometry::DOMRectReadOnly> bounding_client_rect, GC::Ref<Geometry::DOMRectReadOnly> intersection_rect, bool is_intersecting, double intersection_ratio, GC::Ref<DOM::Element> target);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
@@ -62,13 +62,13 @@ private:
     HighResolutionTime::DOMHighResTimeStamp m_time { 0.0 };
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-rootbounds
-    JS::GCPtr<Geometry::DOMRectReadOnly> m_root_bounds;
+    GC::Ptr<Geometry::DOMRectReadOnly> m_root_bounds;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-boundingclientrect
-    JS::NonnullGCPtr<Geometry::DOMRectReadOnly> m_bounding_client_rect;
+    GC::Ref<Geometry::DOMRectReadOnly> m_bounding_client_rect;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-intersectionrect
-    JS::NonnullGCPtr<Geometry::DOMRectReadOnly> m_intersection_rect;
+    GC::Ref<Geometry::DOMRectReadOnly> m_intersection_rect;
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-isintersecting
     bool m_is_intersecting { false };
@@ -77,7 +77,7 @@ private:
     double m_intersection_ratio { 0.0 };
 
     // https://www.w3.org/TR/intersection-observer/#dom-intersectionobserverentry-target
-    JS::NonnullGCPtr<DOM::Element> m_target;
+    GC::Ref<DOM::Element> m_target;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/AudioBox.cpp b/Libraries/LibWeb/Layout/AudioBox.cpp
index fee0c2589dd..5f7270ad892 100644
--- a/Libraries/LibWeb/Layout/AudioBox.cpp
+++ b/Libraries/LibWeb/Layout/AudioBox.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(AudioBox);
+GC_DEFINE_ALLOCATOR(AudioBox);
 
 AudioBox::AudioBox(DOM::Document& document, DOM::Element& element, CSS::StyleProperties style)
     : ReplacedBox(document, element, move(style))
@@ -29,7 +29,7 @@ HTML::HTMLAudioElement const& AudioBox::dom_node() const
     return static_cast<HTML::HTMLAudioElement const&>(ReplacedBox::dom_node());
 }
 
-JS::GCPtr<Painting::Paintable> AudioBox::create_paintable() const
+GC::Ptr<Painting::Paintable> AudioBox::create_paintable() const
 {
     return Painting::AudioPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/AudioBox.h b/Libraries/LibWeb/Layout/AudioBox.h
index 8f192411280..8c8f33819b2 100644
--- a/Libraries/LibWeb/Layout/AudioBox.h
+++ b/Libraries/LibWeb/Layout/AudioBox.h
@@ -13,14 +13,14 @@
 namespace Web::Layout {
 
 class AudioBox final : public ReplacedBox {
-    JS_CELL(AudioBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(AudioBox);
+    GC_CELL(AudioBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(AudioBox);
 
 public:
     HTML::HTMLAudioElement& dom_node();
     HTML::HTMLAudioElement const& dom_node() const;
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     AudioBox(DOM::Document&, DOM::Element&, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/BlockContainer.cpp b/Libraries/LibWeb/Layout/BlockContainer.cpp
index d709579464e..3902d0d87f4 100644
--- a/Libraries/LibWeb/Layout/BlockContainer.cpp
+++ b/Libraries/LibWeb/Layout/BlockContainer.cpp
@@ -26,7 +26,7 @@ Painting::PaintableWithLines const* BlockContainer::paintable_with_lines() const
     return static_cast<Painting::PaintableWithLines const*>(Box::paintable_box());
 }
 
-JS::GCPtr<Painting::Paintable> BlockContainer::create_paintable() const
+GC::Ptr<Painting::Paintable> BlockContainer::create_paintable() const
 {
     return Painting::PaintableWithLines::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/BlockContainer.h b/Libraries/LibWeb/Layout/BlockContainer.h
index 14ef8661104..7bcfd0ae96c 100644
--- a/Libraries/LibWeb/Layout/BlockContainer.h
+++ b/Libraries/LibWeb/Layout/BlockContainer.h
@@ -13,7 +13,7 @@ namespace Web::Layout {
 
 // https://www.w3.org/TR/css-display/#block-container
 class BlockContainer : public Box {
-    JS_CELL(BlockContainer, Box);
+    GC_CELL(BlockContainer, Box);
 
 public:
     BlockContainer(DOM::Document&, DOM::Node*, CSS::StyleProperties);
@@ -22,7 +22,7 @@ public:
 
     Painting::PaintableWithLines const* paintable_with_lines() const;
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     virtual bool is_block_container() const final { return true; }
diff --git a/Libraries/LibWeb/Layout/BlockFormattingContext.h b/Libraries/LibWeb/Layout/BlockFormattingContext.h
index 14b7c4e0885..8e85b3e42b9 100644
--- a/Libraries/LibWeb/Layout/BlockFormattingContext.h
+++ b/Libraries/LibWeb/Layout/BlockFormattingContext.h
@@ -87,7 +87,7 @@ private:
     };
 
     struct FloatingBox {
-        JS::NonnullGCPtr<Box const> box;
+        GC::Ref<Box const> box;
 
         LayoutState::UsedValues& used_values;
 
diff --git a/Libraries/LibWeb/Layout/Box.cpp b/Libraries/LibWeb/Layout/Box.cpp
index 6533845cab9..454509e048c 100644
--- a/Libraries/LibWeb/Layout/Box.cpp
+++ b/Libraries/LibWeb/Layout/Box.cpp
@@ -34,7 +34,7 @@ void Box::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_contained_abspos_children);
 }
 
-JS::GCPtr<Painting::Paintable> Box::create_paintable() const
+GC::Ptr<Painting::Paintable> Box::create_paintable() const
 {
     return Painting::PaintableBox::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/Box.h b/Libraries/LibWeb/Layout/Box.h
index 2e0dce9a0a3..d7a24044331 100644
--- a/Libraries/LibWeb/Layout/Box.h
+++ b/Libraries/LibWeb/Layout/Box.h
@@ -19,7 +19,7 @@ struct LineBoxFragmentCoordinate {
 };
 
 class Box : public NodeWithStyleAndBoxModelMetrics {
-    JS_CELL(Box, NodeWithStyleAndBoxModelMetrics);
+    GC_CELL(Box, NodeWithStyleAndBoxModelMetrics);
 
 public:
     Painting::PaintableBox const* paintable_box() const;
@@ -46,11 +46,11 @@ public:
 
     virtual void did_set_content_size() { }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
-    void add_contained_abspos_child(JS::NonnullGCPtr<Node> child) { m_contained_abspos_children.append(child); }
+    void add_contained_abspos_child(GC::Ref<Node> child) { m_contained_abspos_children.append(child); }
     void clear_contained_abspos_children() { m_contained_abspos_children.clear(); }
-    Vector<JS::NonnullGCPtr<Node>> const& contained_abspos_children() const { return m_contained_abspos_children; }
+    Vector<GC::Ref<Node>> const& contained_abspos_children() const { return m_contained_abspos_children; }
 
     virtual void visit_edges(Cell::Visitor&) override;
 
@@ -65,7 +65,7 @@ private:
     Optional<CSSPixels> m_natural_height;
     Optional<CSSPixelFraction> m_natural_aspect_ratio;
 
-    Vector<JS::NonnullGCPtr<Node>> m_contained_abspos_children;
+    Vector<GC::Ref<Node>> m_contained_abspos_children;
 };
 
 template<>
diff --git a/Libraries/LibWeb/Layout/BreakNode.cpp b/Libraries/LibWeb/Layout/BreakNode.cpp
index ede3e6bffc2..421840d3bee 100644
--- a/Libraries/LibWeb/Layout/BreakNode.cpp
+++ b/Libraries/LibWeb/Layout/BreakNode.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(BreakNode);
+GC_DEFINE_ALLOCATOR(BreakNode);
 
 BreakNode::BreakNode(DOM::Document& document, HTML::HTMLBRElement& element, CSS::StyleProperties style)
     : Layout::NodeWithStyleAndBoxModelMetrics(document, &element, move(style))
diff --git a/Libraries/LibWeb/Layout/BreakNode.h b/Libraries/LibWeb/Layout/BreakNode.h
index 63707996bd0..1776e0a1a54 100644
--- a/Libraries/LibWeb/Layout/BreakNode.h
+++ b/Libraries/LibWeb/Layout/BreakNode.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class BreakNode final : public NodeWithStyleAndBoxModelMetrics {
-    JS_CELL(BreakNode, NodeWithStyleAndBoxModelMetrics);
-    JS_DECLARE_ALLOCATOR(BreakNode);
+    GC_CELL(BreakNode, NodeWithStyleAndBoxModelMetrics);
+    GC_DECLARE_ALLOCATOR(BreakNode);
 
 public:
     BreakNode(DOM::Document&, HTML::HTMLBRElement&, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/CanvasBox.cpp b/Libraries/LibWeb/Layout/CanvasBox.cpp
index 25608e11112..5411ebf6a97 100644
--- a/Libraries/LibWeb/Layout/CanvasBox.cpp
+++ b/Libraries/LibWeb/Layout/CanvasBox.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(CanvasBox);
+GC_DEFINE_ALLOCATOR(CanvasBox);
 
 CanvasBox::CanvasBox(DOM::Document& document, HTML::HTMLCanvasElement& element, CSS::StyleProperties style)
     : ReplacedBox(document, element, move(style))
@@ -24,7 +24,7 @@ void CanvasBox::prepare_for_replaced_layout()
     set_natural_height(dom_node().height());
 }
 
-JS::GCPtr<Painting::Paintable> CanvasBox::create_paintable() const
+GC::Ptr<Painting::Paintable> CanvasBox::create_paintable() const
 {
     return Painting::CanvasPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/CanvasBox.h b/Libraries/LibWeb/Layout/CanvasBox.h
index 3f541ce0c11..c9781e0541c 100644
--- a/Libraries/LibWeb/Layout/CanvasBox.h
+++ b/Libraries/LibWeb/Layout/CanvasBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class CanvasBox final : public ReplacedBox {
-    JS_CELL(CanvasBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(CanvasBox);
+    GC_CELL(CanvasBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(CanvasBox);
 
 public:
     CanvasBox(DOM::Document&, HTML::HTMLCanvasElement&, CSS::StyleProperties);
@@ -23,7 +23,7 @@ public:
 
     const HTML::HTMLCanvasElement& dom_node() const { return static_cast<const HTML::HTMLCanvasElement&>(ReplacedBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/CheckBox.cpp b/Libraries/LibWeb/Layout/CheckBox.cpp
index c727912f81a..8dfc6416dfd 100644
--- a/Libraries/LibWeb/Layout/CheckBox.cpp
+++ b/Libraries/LibWeb/Layout/CheckBox.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(CheckBox);
+GC_DEFINE_ALLOCATOR(CheckBox);
 
 CheckBox::CheckBox(DOM::Document& document, HTML::HTMLInputElement& element, CSS::StyleProperties style)
     : FormAssociatedLabelableNode(document, element, move(style))
@@ -22,7 +22,7 @@ CheckBox::CheckBox(DOM::Document& document, HTML::HTMLInputElement& element, CSS
 
 CheckBox::~CheckBox() = default;
 
-JS::GCPtr<Painting::Paintable> CheckBox::create_paintable() const
+GC::Ptr<Painting::Paintable> CheckBox::create_paintable() const
 {
     return Painting::CheckBoxPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/CheckBox.h b/Libraries/LibWeb/Layout/CheckBox.h
index 43d9632f57c..4472577537e 100644
--- a/Libraries/LibWeb/Layout/CheckBox.h
+++ b/Libraries/LibWeb/Layout/CheckBox.h
@@ -12,15 +12,15 @@
 namespace Web::Layout {
 
 class CheckBox final : public FormAssociatedLabelableNode {
-    JS_CELL(CheckBox, FormAssociatedLabelableNode);
-    JS_DECLARE_ALLOCATOR(CheckBox);
+    GC_CELL(CheckBox, FormAssociatedLabelableNode);
+    GC_DECLARE_ALLOCATOR(CheckBox);
 
 public:
     CheckBox(DOM::Document&, HTML::HTMLInputElement&, CSS::StyleProperties);
     virtual ~CheckBox() override;
 
 private:
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/FlexFormattingContext.h b/Libraries/LibWeb/Layout/FlexFormattingContext.h
index a9ad1aff3e3..52aa74d9d68 100644
--- a/Libraries/LibWeb/Layout/FlexFormattingContext.h
+++ b/Libraries/LibWeb/Layout/FlexFormattingContext.h
@@ -54,7 +54,7 @@ private:
     };
 
     struct FlexItem {
-        JS::NonnullGCPtr<Box> box;
+        GC::Ref<Box> box;
         LayoutState::UsedValues& used_values;
         Optional<CSS::FlexBasis> used_flex_basis {};
         bool used_flex_basis_is_definite { false };
diff --git a/Libraries/LibWeb/Layout/FormAssociatedLabelableNode.h b/Libraries/LibWeb/Layout/FormAssociatedLabelableNode.h
index 60d547311e8..6398bbcd9d1 100644
--- a/Libraries/LibWeb/Layout/FormAssociatedLabelableNode.h
+++ b/Libraries/LibWeb/Layout/FormAssociatedLabelableNode.h
@@ -14,7 +14,7 @@
 namespace Web::Layout {
 
 class FormAssociatedLabelableNode : public LabelableNode {
-    JS_CELL(FormAssociatedLabelableNode, LabelableNode);
+    GC_CELL(FormAssociatedLabelableNode, LabelableNode);
 
 public:
     const HTML::FormAssociatedElement& dom_node() const { return dynamic_cast<const HTML::FormAssociatedElement&>(LabelableNode::dom_node()); }
diff --git a/Libraries/LibWeb/Layout/FormattingContext.h b/Libraries/LibWeb/Layout/FormattingContext.h
index f1902067236..606fa1d7656 100644
--- a/Libraries/LibWeb/Layout/FormattingContext.h
+++ b/Libraries/LibWeb/Layout/FormattingContext.h
@@ -123,7 +123,7 @@ protected:
         // Each block in the containing chain adds its own margin and we store the total here.
         CSSPixels left_total_containing_margin;
         CSSPixels right_total_containing_margin;
-        JS::GCPtr<Box const> matching_left_float_box;
+        GC::Ptr<Box const> matching_left_float_box;
     };
 
     struct ShrinkToFitResult {
@@ -160,7 +160,7 @@ protected:
     LayoutMode m_layout_mode;
 
     FormattingContext* m_parent { nullptr };
-    JS::NonnullGCPtr<Box const> m_context_box;
+    GC::Ref<Box const> m_context_box;
 
     LayoutState& m_state;
 };
diff --git a/Libraries/LibWeb/Layout/FrameBox.cpp b/Libraries/LibWeb/Layout/FrameBox.cpp
index 309543184d0..373e7143d23 100644
--- a/Libraries/LibWeb/Layout/FrameBox.cpp
+++ b/Libraries/LibWeb/Layout/FrameBox.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(FrameBox);
+GC_DEFINE_ALLOCATOR(FrameBox);
 
 FrameBox::FrameBox(DOM::Document& document, DOM::Element& element, CSS::StyleProperties style)
     : ReplacedBox(document, element, move(style))
@@ -35,7 +35,7 @@ void FrameBox::did_set_content_size()
         dom_node().content_navigable()->set_viewport_size(paintable_box()->content_size());
 }
 
-JS::GCPtr<Painting::Paintable> FrameBox::create_paintable() const
+GC::Ptr<Painting::Paintable> FrameBox::create_paintable() const
 {
     return Painting::NestedBrowsingContextPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/FrameBox.h b/Libraries/LibWeb/Layout/FrameBox.h
index 525a76b55f4..5d6c3f7c21a 100644
--- a/Libraries/LibWeb/Layout/FrameBox.h
+++ b/Libraries/LibWeb/Layout/FrameBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class FrameBox final : public ReplacedBox {
-    JS_CELL(FrameBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(FrameBox);
+    GC_CELL(FrameBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(FrameBox);
 
 public:
     FrameBox(DOM::Document&, DOM::Element&, CSS::StyleProperties);
@@ -24,7 +24,7 @@ public:
     const HTML::HTMLIFrameElement& dom_node() const { return verify_cast<HTML::HTMLIFrameElement>(ReplacedBox::dom_node()); }
     HTML::HTMLIFrameElement& dom_node() { return verify_cast<HTML::HTMLIFrameElement>(ReplacedBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     virtual void did_set_content_size() override;
diff --git a/Libraries/LibWeb/Layout/GridFormattingContext.cpp b/Libraries/LibWeb/Layout/GridFormattingContext.cpp
index d1eafd46de3..f484e5c348e 100644
--- a/Libraries/LibWeb/Layout/GridFormattingContext.cpp
+++ b/Libraries/LibWeb/Layout/GridFormattingContext.cpp
@@ -1335,7 +1335,7 @@ void GridFormattingContext::place_grid_items()
     // flex items), which are then assigned to predefined areas in the grid. They can be explicitly
     // placed using coordinates through the grid-placement properties or implicitly placed into
     // empty areas using auto-placement.
-    HashMap<int, Vector<JS::NonnullGCPtr<Box const>>> order_item_bucket;
+    HashMap<int, Vector<GC::Ref<Box const>>> order_item_bucket;
     grid_container().for_each_child_of_type<Box>([&](Box& child_box) {
         if (can_skip_is_anonymous_text_run(child_box))
             return IterationDecision::Continue;
diff --git a/Libraries/LibWeb/Layout/GridFormattingContext.h b/Libraries/LibWeb/Layout/GridFormattingContext.h
index dd6e271eb8a..dd350c82034 100644
--- a/Libraries/LibWeb/Layout/GridFormattingContext.h
+++ b/Libraries/LibWeb/Layout/GridFormattingContext.h
@@ -35,7 +35,7 @@ struct GridPosition {
 };
 
 struct GridItem {
-    JS::NonnullGCPtr<Box const> box;
+    GC::Ref<Box const> box;
 
     // Position and span are empty if the item is auto-placed which could only be the case for abspos items
     Optional<int> row;
diff --git a/Libraries/LibWeb/Layout/ImageBox.cpp b/Libraries/LibWeb/Layout/ImageBox.cpp
index aa45774aaa1..2d23ef1cdfe 100644
--- a/Libraries/LibWeb/Layout/ImageBox.cpp
+++ b/Libraries/LibWeb/Layout/ImageBox.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(ImageBox);
+GC_DEFINE_ALLOCATOR(ImageBox);
 
 ImageBox::ImageBox(DOM::Document& document, DOM::Element& element, CSS::StyleProperties style, ImageProvider const& image_provider)
     : ReplacedBox(document, element, move(style))
@@ -71,7 +71,7 @@ bool ImageBox::renders_as_alt_text() const
     return false;
 }
 
-JS::GCPtr<Painting::Paintable> ImageBox::create_paintable() const
+GC::Ptr<Painting::Paintable> ImageBox::create_paintable() const
 {
     return Painting::ImagePaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/ImageBox.h b/Libraries/LibWeb/Layout/ImageBox.h
index 9277a7e8af5..de6f42f9b00 100644
--- a/Libraries/LibWeb/Layout/ImageBox.h
+++ b/Libraries/LibWeb/Layout/ImageBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class ImageBox final : public ReplacedBox {
-    JS_CELL(ImageBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(ImageBox);
+    GC_CELL(ImageBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(ImageBox);
 
 public:
     ImageBox(DOM::Document&, DOM::Element&, CSS::StyleProperties, ImageProvider const&);
@@ -25,7 +25,7 @@ public:
 
     bool renders_as_alt_text() const;
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
     auto const& image_provider() const { return m_image_provider; }
     auto& image_provider() { return m_image_provider; }
diff --git a/Libraries/LibWeb/Layout/ImageProvider.h b/Libraries/LibWeb/Layout/ImageProvider.h
index 060ade5daae..499089e733a 100644
--- a/Libraries/LibWeb/Layout/ImageProvider.h
+++ b/Libraries/LibWeb/Layout/ImageProvider.h
@@ -25,7 +25,7 @@ public:
     virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize) const = 0;
     virtual void set_visible_in_viewport(bool) = 0;
 
-    virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const = 0;
+    virtual GC::Ref<DOM::Element const> to_html_element() const = 0;
 
 protected:
     static void did_update_alt_text(ImageBox&);
diff --git a/Libraries/LibWeb/Layout/InlineLevelIterator.h b/Libraries/LibWeb/Layout/InlineLevelIterator.h
index 801a71fb204..de345215932 100644
--- a/Libraries/LibWeb/Layout/InlineLevelIterator.h
+++ b/Libraries/LibWeb/Layout/InlineLevelIterator.h
@@ -31,7 +31,7 @@ public:
             FloatingElement,
         };
         Type type {};
-        JS::GCPtr<Layout::Node const> node {};
+        GC::Ptr<Layout::Node const> node {};
         RefPtr<Gfx::GlyphRun> glyph_run {};
         size_t offset_in_node { 0 };
         size_t length_in_node { 0 };
@@ -72,10 +72,10 @@ private:
 
     Layout::InlineFormattingContext& m_inline_formatting_context;
     Layout::LayoutState& m_layout_state;
-    JS::NonnullGCPtr<BlockContainer const> m_containing_block;
+    GC::Ref<BlockContainer const> m_containing_block;
     LayoutState::UsedValues const& m_containing_block_used_values;
-    JS::GCPtr<Layout::Node const> m_current_node;
-    JS::GCPtr<Layout::Node const> m_next_node;
+    GC::Ptr<Layout::Node const> m_current_node;
+    GC::Ptr<Layout::Node const> m_next_node;
     LayoutMode const m_layout_mode;
 
     struct TextNodeContext {
@@ -99,7 +99,7 @@ private:
     Optional<ExtraBoxMetrics> m_extra_leading_metrics;
     Optional<ExtraBoxMetrics> m_extra_trailing_metrics;
 
-    Vector<JS::NonnullGCPtr<NodeWithStyleAndBoxModelMetrics const>> m_box_model_node_stack;
+    Vector<GC::Ref<NodeWithStyleAndBoxModelMetrics const>> m_box_model_node_stack;
     Queue<InlineLevelIterator::Item> m_lookahead_items;
 };
 
diff --git a/Libraries/LibWeb/Layout/InlineNode.cpp b/Libraries/LibWeb/Layout/InlineNode.cpp
index 64053c5e030..7961b096f91 100644
--- a/Libraries/LibWeb/Layout/InlineNode.cpp
+++ b/Libraries/LibWeb/Layout/InlineNode.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(InlineNode);
+GC_DEFINE_ALLOCATOR(InlineNode);
 
 InlineNode::InlineNode(DOM::Document& document, DOM::Element* element, CSS::StyleProperties style)
     : Layout::NodeWithStyleAndBoxModelMetrics(document, element, move(style))
@@ -23,7 +23,7 @@ InlineNode::InlineNode(DOM::Document& document, DOM::Element* element, CSS::Styl
 
 InlineNode::~InlineNode() = default;
 
-JS::GCPtr<Painting::PaintableWithLines> InlineNode::create_paintable_for_line_with_index(size_t line_index) const
+GC::Ptr<Painting::PaintableWithLines> InlineNode::create_paintable_for_line_with_index(size_t line_index) const
 {
     for (auto const& paintable : paintables()) {
         if (is<Painting::PaintableWithLines>(paintable)) {
diff --git a/Libraries/LibWeb/Layout/InlineNode.h b/Libraries/LibWeb/Layout/InlineNode.h
index 23023c1fc59..b9b1535eff0 100644
--- a/Libraries/LibWeb/Layout/InlineNode.h
+++ b/Libraries/LibWeb/Layout/InlineNode.h
@@ -11,14 +11,14 @@
 namespace Web::Layout {
 
 class InlineNode final : public NodeWithStyleAndBoxModelMetrics {
-    JS_CELL(InlineNode, NodeWithStyleAndBoxModelMetrics);
-    JS_DECLARE_ALLOCATOR(InlineNode);
+    GC_CELL(InlineNode, NodeWithStyleAndBoxModelMetrics);
+    GC_DECLARE_ALLOCATOR(InlineNode);
 
 public:
     InlineNode(DOM::Document&, DOM::Element*, CSS::StyleProperties);
     virtual ~InlineNode() override;
 
-    JS::GCPtr<Painting::PaintableWithLines> create_paintable_for_line_with_index(size_t line_index) const;
+    GC::Ptr<Painting::PaintableWithLines> create_paintable_for_line_with_index(size_t line_index) const;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/Label.cpp b/Libraries/LibWeb/Layout/Label.cpp
index 6a5ef121934..d650656302e 100644
--- a/Libraries/LibWeb/Layout/Label.cpp
+++ b/Libraries/LibWeb/Layout/Label.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(Label);
+GC_DEFINE_ALLOCATOR(Label);
 
 Label::Label(DOM::Document& document, HTML::HTMLLabelElement* element, CSS::StyleProperties style)
     : BlockContainer(document, element, move(style))
diff --git a/Libraries/LibWeb/Layout/Label.h b/Libraries/LibWeb/Layout/Label.h
index 19abd65abe6..d8a8f227b1b 100644
--- a/Libraries/LibWeb/Layout/Label.h
+++ b/Libraries/LibWeb/Layout/Label.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class Label final : public BlockContainer {
-    JS_CELL(Label, BlockContainer);
-    JS_DECLARE_ALLOCATOR(Label);
+    GC_CELL(Label, BlockContainer);
+    GC_DECLARE_ALLOCATOR(Label);
 
 public:
     Label(DOM::Document&, HTML::HTMLLabelElement*, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/LabelableNode.h b/Libraries/LibWeb/Layout/LabelableNode.h
index b0f282b9a40..19e3efa20b7 100644
--- a/Libraries/LibWeb/Layout/LabelableNode.h
+++ b/Libraries/LibWeb/Layout/LabelableNode.h
@@ -12,7 +12,7 @@
 namespace Web::Layout {
 
 class LabelableNode : public ReplacedBox {
-    JS_CELL(LabelableNode, ReplacedBox);
+    GC_CELL(LabelableNode, ReplacedBox);
 
 public:
     Painting::LabelablePaintable* paintable();
diff --git a/Libraries/LibWeb/Layout/LayoutState.h b/Libraries/LibWeb/Layout/LayoutState.h
index e1231f9802f..a6e24c1a548 100644
--- a/Libraries/LibWeb/Layout/LayoutState.h
+++ b/Libraries/LibWeb/Layout/LayoutState.h
@@ -191,7 +191,7 @@ struct LayoutState {
         CSSPixels border_top_collapsed() const { return use_collapsing_borders_model() ? round(border_top / 2) : border_top; }
         CSSPixels border_bottom_collapsed() const { return use_collapsing_borders_model() ? round(border_bottom / 2) : border_bottom; }
 
-        JS::GCPtr<Layout::NodeWithStyle> m_node { nullptr };
+        GC::Ptr<Layout::NodeWithStyle> m_node { nullptr };
         UsedValues const* m_containing_block_used_values { nullptr };
 
         CSSPixels m_content_width { 0 };
@@ -200,7 +200,7 @@ struct LayoutState {
         bool m_has_definite_width { false };
         bool m_has_definite_height { false };
 
-        HashTable<JS::GCPtr<Box const>> m_floating_descendants;
+        HashTable<GC::Ptr<Box const>> m_floating_descendants;
 
         Optional<Painting::PaintableBox::BordersDataWithElementKind> m_override_borders_data;
         Optional<Painting::PaintableBox::TableCellCoordinates> m_table_cell_coordinates;
@@ -223,7 +223,7 @@ struct LayoutState {
     // NOTE: get() will not CoW the UsedValues.
     UsedValues const& get(NodeWithStyle const&) const;
 
-    HashMap<JS::NonnullGCPtr<Layout::Node const>, NonnullOwnPtr<UsedValues>> used_values_per_layout_node;
+    HashMap<GC::Ref<Layout::Node const>, NonnullOwnPtr<UsedValues>> used_values_per_layout_node;
 
     // We cache intrinsic sizes once determined, as they will not change over the course of a full layout.
     // This avoids computing them several times while performing flex layout.
@@ -235,7 +235,7 @@ struct LayoutState {
         HashMap<CSSPixels, Optional<CSSPixels>> max_content_height;
     };
 
-    HashMap<JS::GCPtr<NodeWithStyle const>, NonnullOwnPtr<IntrinsicSizes>> mutable intrinsic_sizes;
+    HashMap<GC::Ptr<NodeWithStyle const>, NonnullOwnPtr<IntrinsicSizes>> mutable intrinsic_sizes;
 
     LayoutState const* m_parent { nullptr };
     LayoutState const& m_root;
diff --git a/Libraries/LibWeb/Layout/LineBoxFragment.h b/Libraries/LibWeb/Layout/LineBoxFragment.h
index 5b132de0380..425a640eebe 100644
--- a/Libraries/LibWeb/Layout/LineBoxFragment.h
+++ b/Libraries/LibWeb/Layout/LineBoxFragment.h
@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibGfx/Rect.h>
 #include <LibGfx/TextLayout.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/Painting/BorderRadiiData.h>
 #include <LibWeb/PixelUnits.h>
@@ -60,7 +60,7 @@ private:
     void append_glyph_run_ltr(RefPtr<Gfx::GlyphRun> const&, CSSPixels run_width);
     void append_glyph_run_rtl(RefPtr<Gfx::GlyphRun> const&, CSSPixels run_width);
 
-    JS::NonnullGCPtr<Node const> m_layout_node;
+    GC::Ref<Node const> m_layout_node;
     int m_start { 0 };
     int m_length { 0 };
     CSSPixels m_inline_offset;
diff --git a/Libraries/LibWeb/Layout/ListItemBox.cpp b/Libraries/LibWeb/Layout/ListItemBox.cpp
index 46b46cfbf24..3205919cbd4 100644
--- a/Libraries/LibWeb/Layout/ListItemBox.cpp
+++ b/Libraries/LibWeb/Layout/ListItemBox.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(ListItemBox);
+GC_DEFINE_ALLOCATOR(ListItemBox);
 
 ListItemBox::ListItemBox(DOM::Document& document, DOM::Element* element, CSS::StyleProperties style)
     : Layout::BlockContainer(document, element, move(style))
@@ -25,7 +25,7 @@ void ListItemBox::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_marker);
 }
 
-void ListItemBox::set_marker(JS::GCPtr<ListItemMarkerBox> marker)
+void ListItemBox::set_marker(GC::Ptr<ListItemMarkerBox> marker)
 {
     m_marker = move(marker);
 }
diff --git a/Libraries/LibWeb/Layout/ListItemBox.h b/Libraries/LibWeb/Layout/ListItemBox.h
index 00250cefcaf..c543fef7f11 100644
--- a/Libraries/LibWeb/Layout/ListItemBox.h
+++ b/Libraries/LibWeb/Layout/ListItemBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class ListItemBox final : public BlockContainer {
-    JS_CELL(ListItemBox, BlockContainer);
-    JS_DECLARE_ALLOCATOR(ListItemBox);
+    GC_CELL(ListItemBox, BlockContainer);
+    GC_DECLARE_ALLOCATOR(ListItemBox);
 
 public:
     ListItemBox(DOM::Document&, DOM::Element*, CSS::StyleProperties);
@@ -23,14 +23,14 @@ public:
     DOM::Element const& dom_node() const { return static_cast<DOM::Element const&>(*BlockContainer::dom_node()); }
 
     ListItemMarkerBox const* marker() const { return m_marker; }
-    void set_marker(JS::GCPtr<ListItemMarkerBox>);
+    void set_marker(GC::Ptr<ListItemMarkerBox>);
 
 private:
     virtual bool is_list_item_box() const override { return true; }
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<ListItemMarkerBox> m_marker;
+    GC::Ptr<ListItemMarkerBox> m_marker;
 };
 
 template<>
diff --git a/Libraries/LibWeb/Layout/ListItemMarkerBox.cpp b/Libraries/LibWeb/Layout/ListItemMarkerBox.cpp
index 8dc8b86caf9..c00b095aebc 100644
--- a/Libraries/LibWeb/Layout/ListItemMarkerBox.cpp
+++ b/Libraries/LibWeb/Layout/ListItemMarkerBox.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(ListItemMarkerBox);
+GC_DEFINE_ALLOCATOR(ListItemMarkerBox);
 
 ListItemMarkerBox::ListItemMarkerBox(DOM::Document& document, CSS::ListStyleType style_type, CSS::ListStylePosition style_position, size_t index, CSS::StyleProperties style)
     : Box(document, nullptr, move(style))
@@ -56,7 +56,7 @@ ListItemMarkerBox::ListItemMarkerBox(DOM::Document& document, CSS::ListStyleType
 
 ListItemMarkerBox::~ListItemMarkerBox() = default;
 
-JS::GCPtr<Painting::Paintable> ListItemMarkerBox::create_paintable() const
+GC::Ptr<Painting::Paintable> ListItemMarkerBox::create_paintable() const
 {
     return Painting::MarkerPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/ListItemMarkerBox.h b/Libraries/LibWeb/Layout/ListItemMarkerBox.h
index 8f5485c285a..4f98281be10 100644
--- a/Libraries/LibWeb/Layout/ListItemMarkerBox.h
+++ b/Libraries/LibWeb/Layout/ListItemMarkerBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class ListItemMarkerBox final : public Box {
-    JS_CELL(ListItemMarkerBox, Box);
-    JS_DECLARE_ALLOCATOR(ListItemMarkerBox);
+    GC_CELL(ListItemMarkerBox, Box);
+    GC_DECLARE_ALLOCATOR(ListItemMarkerBox);
 
 public:
     explicit ListItemMarkerBox(DOM::Document&, CSS::ListStyleType, CSS::ListStylePosition, size_t index, CSS::StyleProperties);
@@ -21,7 +21,7 @@ public:
 
     Optional<ByteString> const& text() const { return m_text; }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
     CSS::ListStyleType list_style_type() const { return m_list_style_type; }
     CSS::ListStylePosition list_style_position() const { return m_list_style_position; }
diff --git a/Libraries/LibWeb/Layout/Node.cpp b/Libraries/LibWeb/Layout/Node.cpp
index bc8bee6e70b..778f963f32f 100644
--- a/Libraries/LibWeb/Layout/Node.cpp
+++ b/Libraries/LibWeb/Layout/Node.cpp
@@ -48,7 +48,7 @@ void Node::visit_edges(Cell::Visitor& visitor)
     Base::visit_edges(visitor);
     visitor.visit(m_dom_node);
     for (auto const& paintable : m_paintable) {
-        visitor.visit(JS::GCPtr { &paintable });
+        visitor.visit(GC::Ptr { &paintable });
     }
     visitor.visit(m_pseudo_element_generator);
     TreeNode::visit_edges(visitor);
@@ -205,7 +205,7 @@ bool Node::establishes_stacking_context() const
     return computed_values().opacity() < 1.0f;
 }
 
-JS::GCPtr<HTML::Navigable> Node::navigable() const
+GC::Ptr<HTML::Navigable> Node::navigable() const
 {
     return document().navigable();
 }
@@ -1008,7 +1008,7 @@ bool Node::is_inline_table() const
     return display.is_inline_outside() && display.is_table_inside();
 }
 
-JS::NonnullGCPtr<NodeWithStyle> NodeWithStyle::create_anonymous_wrapper() const
+GC::Ref<NodeWithStyle> NodeWithStyle::create_anonymous_wrapper() const
 {
     auto wrapper = heap().allocate<BlockContainer>(const_cast<DOM::Document&>(document()), nullptr, computed_values().clone_inherited_values());
     wrapper->mutable_computed_values().set_display(CSS::Display(CSS::DisplayOutside::Block, CSS::DisplayInside::Flow));
@@ -1080,7 +1080,7 @@ bool NodeWithStyle::is_scroll_container() const
         || overflow_value_makes_box_a_scroll_container(computed_values().overflow_y());
 }
 
-void Node::add_paintable(JS::GCPtr<Painting::Paintable> paintable)
+void Node::add_paintable(GC::Ptr<Painting::Paintable> paintable)
 {
     if (!paintable)
         return;
@@ -1092,7 +1092,7 @@ void Node::clear_paintables()
     m_paintable.clear();
 }
 
-JS::GCPtr<Painting::Paintable> Node::create_paintable() const
+GC::Ptr<Painting::Paintable> Node::create_paintable() const
 {
     return nullptr;
 }
diff --git a/Libraries/LibWeb/Layout/Node.h b/Libraries/LibWeb/Layout/Node.h
index f9d87d91ecd..e81e4f1dcb0 100644
--- a/Libraries/LibWeb/Layout/Node.h
+++ b/Libraries/LibWeb/Layout/Node.h
@@ -9,9 +9,9 @@
 #include <AK/NonnullRefPtr.h>
 #include <AK/TypeCasts.h>
 #include <AK/Vector.h>
+#include <LibGC/Root.h>
 #include <LibGfx/Rect.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWeb/CSS/ComputedValues.h>
 #include <LibWeb/CSS/StyleComputer.h>
 #include <LibWeb/CSS/StyleProperties.h>
@@ -39,7 +39,7 @@ enum class LayoutMode {
 class Node
     : public JS::Cell
     , public TreeNode<Node> {
-    JS_CELL(Node, JS::Cell);
+    GC_CELL(Node, JS::Cell);
 
 public:
     virtual ~Node();
@@ -71,15 +71,15 @@ public:
     Painting::Paintable const* first_paintable() const { return m_paintable.first(); }
     PaintableList& paintables() { return m_paintable; }
     PaintableList const& paintables() const { return m_paintable; }
-    void add_paintable(JS::GCPtr<Painting::Paintable>);
+    void add_paintable(GC::Ptr<Painting::Paintable>);
     void clear_paintables();
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const;
 
     DOM::Document& document();
     DOM::Document const& document() const;
 
-    JS::GCPtr<HTML::Navigable> navigable() const;
+    GC::Ptr<HTML::Navigable> navigable() const;
 
     Viewport const& root() const;
     Viewport& root();
@@ -186,10 +186,10 @@ protected:
 private:
     friend class NodeWithStyle;
 
-    JS::NonnullGCPtr<DOM::Node> m_dom_node;
+    GC::Ref<DOM::Node> m_dom_node;
     PaintableList m_paintable;
 
-    JS::GCPtr<DOM::Element> m_pseudo_element_generator;
+    GC::Ptr<DOM::Element> m_pseudo_element_generator;
 
     bool m_anonymous { false };
     bool m_has_style { false };
@@ -204,7 +204,7 @@ private:
 };
 
 class NodeWithStyle : public Node {
-    JS_CELL(NodeWithStyle, Node);
+    GC_CELL(NodeWithStyle, Node);
 
 public:
     virtual ~NodeWithStyle() override = default;
@@ -218,7 +218,7 @@ public:
     Vector<CSS::BackgroundLayerData> const& background_layers() const { return computed_values().background_layers(); }
     const CSS::AbstractImageStyleValue* list_style_image() const { return m_list_style_image; }
 
-    JS::NonnullGCPtr<NodeWithStyle> create_anonymous_wrapper() const;
+    GC::Ref<NodeWithStyle> create_anonymous_wrapper() const;
 
     void transfer_table_box_computed_values_to_wrapper_computed_values(CSS::ComputedValues& wrapper_computed_values);
 
@@ -240,7 +240,7 @@ private:
 };
 
 class NodeWithStyleAndBoxModelMetrics : public NodeWithStyle {
-    JS_CELL(NodeWithStyleAndBoxModelMetrics, NodeWithStyle);
+    GC_CELL(NodeWithStyleAndBoxModelMetrics, NodeWithStyle);
 
 public:
     BoxModelMetrics& box_model() { return m_box_model; }
diff --git a/Libraries/LibWeb/Layout/RadioButton.cpp b/Libraries/LibWeb/Layout/RadioButton.cpp
index 60755ca5487..406938a4e24 100644
--- a/Libraries/LibWeb/Layout/RadioButton.cpp
+++ b/Libraries/LibWeb/Layout/RadioButton.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(RadioButton);
+GC_DEFINE_ALLOCATOR(RadioButton);
 
 RadioButton::RadioButton(DOM::Document& document, HTML::HTMLInputElement& element, CSS::StyleProperties style)
     : FormAssociatedLabelableNode(document, element, move(style))
@@ -24,7 +24,7 @@ RadioButton::RadioButton(DOM::Document& document, HTML::HTMLInputElement& elemen
 
 RadioButton::~RadioButton() = default;
 
-JS::GCPtr<Painting::Paintable> RadioButton::create_paintable() const
+GC::Ptr<Painting::Paintable> RadioButton::create_paintable() const
 {
     return Painting::RadioButtonPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/RadioButton.h b/Libraries/LibWeb/Layout/RadioButton.h
index f685af94119..3af87c34475 100644
--- a/Libraries/LibWeb/Layout/RadioButton.h
+++ b/Libraries/LibWeb/Layout/RadioButton.h
@@ -12,15 +12,15 @@
 namespace Web::Layout {
 
 class RadioButton final : public FormAssociatedLabelableNode {
-    JS_CELL(RadioButton, FormAssociatedLabelableNode);
-    JS_DECLARE_ALLOCATOR(RadioButton);
+    GC_CELL(RadioButton, FormAssociatedLabelableNode);
+    GC_DECLARE_ALLOCATOR(RadioButton);
 
 public:
     RadioButton(DOM::Document&, HTML::HTMLInputElement&, CSS::StyleProperties);
     virtual ~RadioButton() override;
 
 private:
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/ReplacedBox.h b/Libraries/LibWeb/Layout/ReplacedBox.h
index 579b2e26961..bff51fcd256 100644
--- a/Libraries/LibWeb/Layout/ReplacedBox.h
+++ b/Libraries/LibWeb/Layout/ReplacedBox.h
@@ -12,7 +12,7 @@
 namespace Web::Layout {
 
 class ReplacedBox : public Box {
-    JS_CELL(ReplacedBox, Box);
+    GC_CELL(ReplacedBox, Box);
 
 public:
     ReplacedBox(DOM::Document&, DOM::Element&, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/SVGBox.h b/Libraries/LibWeb/Layout/SVGBox.h
index 9607141687e..3a53ebee428 100644
--- a/Libraries/LibWeb/Layout/SVGBox.h
+++ b/Libraries/LibWeb/Layout/SVGBox.h
@@ -13,7 +13,7 @@
 namespace Web::Layout {
 
 class SVGBox : public Box {
-    JS_CELL(SVGBox, Box);
+    GC_CELL(SVGBox, Box);
 
 public:
     SVGBox(DOM::Document&, SVG::SVGElement&, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/SVGClipBox.cpp b/Libraries/LibWeb/Layout/SVGClipBox.cpp
index 8b1d03b757b..5c93d0da161 100644
--- a/Libraries/LibWeb/Layout/SVGClipBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGClipBox.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGClipBox);
+GC_DEFINE_ALLOCATOR(SVGClipBox);
 
 SVGClipBox::SVGClipBox(DOM::Document& document, SVG::SVGClipPathElement& element, CSS::StyleProperties properties)
     : SVGBox(document, element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGClipBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGClipBox::create_paintable() const
 {
     return Painting::SVGClipPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGClipBox.h b/Libraries/LibWeb/Layout/SVGClipBox.h
index 121af6ff9ae..bb1a4c52a09 100644
--- a/Libraries/LibWeb/Layout/SVGClipBox.h
+++ b/Libraries/LibWeb/Layout/SVGClipBox.h
@@ -13,8 +13,8 @@
 namespace Web::Layout {
 
 class SVGClipBox : public SVGBox {
-    JS_CELL(SVGClipBox, SVGBox);
-    JS_DECLARE_ALLOCATOR(SVGClipBox);
+    GC_CELL(SVGClipBox, SVGBox);
+    GC_DECLARE_ALLOCATOR(SVGClipBox);
 
 public:
     SVGClipBox(DOM::Document&, SVG::SVGClipPathElement&, CSS::StyleProperties);
@@ -23,7 +23,7 @@ public:
     SVG::SVGClipPathElement& dom_node() { return verify_cast<SVG::SVGClipPathElement>(SVGBox::dom_node()); }
     SVG::SVGClipPathElement const& dom_node() const { return verify_cast<SVG::SVGClipPathElement>(SVGBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/SVGForeignObjectBox.cpp b/Libraries/LibWeb/Layout/SVGForeignObjectBox.cpp
index dd695fa47dd..616f16a5251 100644
--- a/Libraries/LibWeb/Layout/SVGForeignObjectBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGForeignObjectBox.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGForeignObjectBox);
+GC_DEFINE_ALLOCATOR(SVGForeignObjectBox);
 
 SVGForeignObjectBox::SVGForeignObjectBox(DOM::Document& document, SVG::SVGForeignObjectElement& element, CSS::StyleProperties properties)
     : BlockContainer(document, &element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGForeignObjectBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGForeignObjectBox::create_paintable() const
 {
     return Painting::SVGForeignObjectPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGForeignObjectBox.h b/Libraries/LibWeb/Layout/SVGForeignObjectBox.h
index 5a98e100ce9..6a127d23873 100644
--- a/Libraries/LibWeb/Layout/SVGForeignObjectBox.h
+++ b/Libraries/LibWeb/Layout/SVGForeignObjectBox.h
@@ -14,8 +14,8 @@
 namespace Web::Layout {
 
 class SVGForeignObjectBox final : public BlockContainer {
-    JS_CELL(SVGForeignObjectBox, BlockContainer);
-    JS_DECLARE_ALLOCATOR(SVGForeignObjectBox);
+    GC_CELL(SVGForeignObjectBox, BlockContainer);
+    GC_DECLARE_ALLOCATOR(SVGForeignObjectBox);
 
 public:
     SVGForeignObjectBox(DOM::Document&, SVG::SVGForeignObjectElement&, CSS::StyleProperties);
@@ -24,7 +24,7 @@ public:
     SVG::SVGForeignObjectElement& dom_node() { return static_cast<SVG::SVGForeignObjectElement&>(*BlockContainer::dom_node()); }
     SVG::SVGForeignObjectElement const& dom_node() const { return static_cast<SVG::SVGForeignObjectElement const&>(*BlockContainer::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/SVGGeometryBox.cpp b/Libraries/LibWeb/Layout/SVGGeometryBox.cpp
index 0a1fdbb5fbe..ca36d95a81b 100644
--- a/Libraries/LibWeb/Layout/SVGGeometryBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGGeometryBox.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGGeometryBox);
+GC_DEFINE_ALLOCATOR(SVGGeometryBox);
 
 SVGGeometryBox::SVGGeometryBox(DOM::Document& document, SVG::SVGGeometryElement& element, CSS::StyleProperties properties)
     : SVGGraphicsBox(document, element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGGeometryBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGGeometryBox::create_paintable() const
 {
     return Painting::SVGPathPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGGeometryBox.h b/Libraries/LibWeb/Layout/SVGGeometryBox.h
index 6076345f613..28afb19a451 100644
--- a/Libraries/LibWeb/Layout/SVGGeometryBox.h
+++ b/Libraries/LibWeb/Layout/SVGGeometryBox.h
@@ -13,8 +13,8 @@
 namespace Web::Layout {
 
 class SVGGeometryBox final : public SVGGraphicsBox {
-    JS_CELL(SVGGeometryBox, SVGGraphicsBox);
-    JS_DECLARE_ALLOCATOR(SVGGeometryBox);
+    GC_CELL(SVGGeometryBox, SVGGraphicsBox);
+    GC_DECLARE_ALLOCATOR(SVGGeometryBox);
 
 public:
     SVGGeometryBox(DOM::Document&, SVG::SVGGeometryElement&, CSS::StyleProperties);
@@ -23,7 +23,7 @@ public:
     SVG::SVGGeometryElement& dom_node() { return static_cast<SVG::SVGGeometryElement&>(SVGGraphicsBox::dom_node()); }
     SVG::SVGGeometryElement const& dom_node() const { return static_cast<SVG::SVGGeometryElement const&>(SVGGraphicsBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     virtual bool is_svg_geometry_box() const final { return true; }
diff --git a/Libraries/LibWeb/Layout/SVGGraphicsBox.cpp b/Libraries/LibWeb/Layout/SVGGraphicsBox.cpp
index be8a716cd07..03a71761958 100644
--- a/Libraries/LibWeb/Layout/SVGGraphicsBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGGraphicsBox.cpp
@@ -15,7 +15,7 @@ SVGGraphicsBox::SVGGraphicsBox(DOM::Document& document, SVG::SVGGraphicsElement&
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGGraphicsBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGGraphicsBox::create_paintable() const
 {
     return Painting::SVGGraphicsPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGGraphicsBox.h b/Libraries/LibWeb/Layout/SVGGraphicsBox.h
index 14d915ef657..7b4e98aac57 100644
--- a/Libraries/LibWeb/Layout/SVGGraphicsBox.h
+++ b/Libraries/LibWeb/Layout/SVGGraphicsBox.h
@@ -13,7 +13,7 @@
 namespace Web::Layout {
 
 class SVGGraphicsBox : public SVGBox {
-    JS_CELL(SVGGraphicsBox, SVGBox);
+    GC_CELL(SVGGraphicsBox, SVGBox);
 
 public:
     SVGGraphicsBox(DOM::Document&, SVG::SVGGraphicsElement&, CSS::StyleProperties);
@@ -22,7 +22,7 @@ public:
     SVG::SVGGraphicsElement& dom_node() { return verify_cast<SVG::SVGGraphicsElement>(SVGBox::dom_node()); }
     SVG::SVGGraphicsElement const& dom_node() const { return verify_cast<SVG::SVGGraphicsElement>(SVGBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/SVGImageBox.cpp b/Libraries/LibWeb/Layout/SVGImageBox.cpp
index 73b6c243e03..477aff07a04 100644
--- a/Libraries/LibWeb/Layout/SVGImageBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGImageBox.cpp
@@ -16,7 +16,7 @@ SVGImageBox::SVGImageBox(DOM::Document& document, SVG::SVGGraphicsElement& eleme
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGImageBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGImageBox::create_paintable() const
 {
     return Painting::ImagePaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGImageBox.h b/Libraries/LibWeb/Layout/SVGImageBox.h
index b5aee89e085..d500082c70f 100644
--- a/Libraries/LibWeb/Layout/SVGImageBox.h
+++ b/Libraries/LibWeb/Layout/SVGImageBox.h
@@ -6,14 +6,14 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Layout/SVGGraphicsBox.h>
 #include <LibWeb/SVG/SVGImageElement.h>
 
 namespace Web::Layout {
 
 class SVGImageBox : public SVGGraphicsBox {
-    JS_CELL(SVGImageBox, SVGGraphicsBox);
+    GC_CELL(SVGImageBox, SVGGraphicsBox);
 
 public:
     SVGImageBox(DOM::Document&, SVG::SVGGraphicsElement&, CSS::StyleProperties);
@@ -22,7 +22,7 @@ public:
     SVG::SVGImageElement& dom_node() { return static_cast<SVG::SVGImageElement&>(SVGGraphicsBox::dom_node()); }
     SVG::SVGImageElement const& dom_node() const { return static_cast<SVG::SVGImageElement const&>(SVGGraphicsBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 }
diff --git a/Libraries/LibWeb/Layout/SVGMaskBox.cpp b/Libraries/LibWeb/Layout/SVGMaskBox.cpp
index b06ec858dfb..5133e203c61 100644
--- a/Libraries/LibWeb/Layout/SVGMaskBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGMaskBox.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGMaskBox);
+GC_DEFINE_ALLOCATOR(SVGMaskBox);
 
 SVGMaskBox::SVGMaskBox(DOM::Document& document, SVG::SVGMaskElement& element, CSS::StyleProperties properties)
     : SVGGraphicsBox(document, element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGMaskBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGMaskBox::create_paintable() const
 {
     return Painting::SVGMaskPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGMaskBox.h b/Libraries/LibWeb/Layout/SVGMaskBox.h
index 0a70dd007c1..0cfa1879204 100644
--- a/Libraries/LibWeb/Layout/SVGMaskBox.h
+++ b/Libraries/LibWeb/Layout/SVGMaskBox.h
@@ -13,8 +13,8 @@
 namespace Web::Layout {
 
 class SVGMaskBox : public SVGGraphicsBox {
-    JS_CELL(SVGMaskBox, SVGGraphicsBox);
-    JS_DECLARE_ALLOCATOR(SVGMaskBox);
+    GC_CELL(SVGMaskBox, SVGGraphicsBox);
+    GC_DECLARE_ALLOCATOR(SVGMaskBox);
 
 public:
     SVGMaskBox(DOM::Document&, SVG::SVGMaskElement&, CSS::StyleProperties);
@@ -25,7 +25,7 @@ public:
     SVG::SVGMaskElement& dom_node() { return verify_cast<SVG::SVGMaskElement>(SVGGraphicsBox::dom_node()); }
     SVG::SVGMaskElement const& dom_node() const { return verify_cast<SVG::SVGMaskElement>(SVGGraphicsBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 };
 
 template<>
diff --git a/Libraries/LibWeb/Layout/SVGSVGBox.cpp b/Libraries/LibWeb/Layout/SVGSVGBox.cpp
index 78ddfb5307f..d8c61d9ae9c 100644
--- a/Libraries/LibWeb/Layout/SVGSVGBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGSVGBox.cpp
@@ -13,14 +13,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGSVGBox);
+GC_DEFINE_ALLOCATOR(SVGSVGBox);
 
 SVGSVGBox::SVGSVGBox(DOM::Document& document, SVG::SVGSVGElement& element, CSS::StyleProperties properties)
     : ReplacedBox(document, element, move(properties))
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGSVGBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGSVGBox::create_paintable() const
 {
     return Painting::SVGSVGPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGSVGBox.h b/Libraries/LibWeb/Layout/SVGSVGBox.h
index d2ff206616c..260caf93bb9 100644
--- a/Libraries/LibWeb/Layout/SVGSVGBox.h
+++ b/Libraries/LibWeb/Layout/SVGSVGBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class SVGSVGBox final : public ReplacedBox {
-    JS_CELL(SVGSVGBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(SVGSVGBox);
+    GC_CELL(SVGSVGBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(SVGSVGBox);
 
 public:
     SVGSVGBox(DOM::Document&, SVG::SVGSVGElement&, CSS::StyleProperties);
@@ -24,7 +24,7 @@ public:
 
     virtual bool can_have_children() const override { return true; }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
     virtual void prepare_for_replaced_layout() override;
 
diff --git a/Libraries/LibWeb/Layout/SVGTextBox.cpp b/Libraries/LibWeb/Layout/SVGTextBox.cpp
index 75e9ecacc5a..e3737b04cc8 100644
--- a/Libraries/LibWeb/Layout/SVGTextBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGTextBox.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGTextBox);
+GC_DEFINE_ALLOCATOR(SVGTextBox);
 
 SVGTextBox::SVGTextBox(DOM::Document& document, SVG::SVGTextPositioningElement& element, CSS::StyleProperties properties)
     : SVGGraphicsBox(document, element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGTextBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGTextBox::create_paintable() const
 {
     return Painting::SVGPathPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGTextBox.h b/Libraries/LibWeb/Layout/SVGTextBox.h
index 75f9aa2a76c..ad22976f7bf 100644
--- a/Libraries/LibWeb/Layout/SVGTextBox.h
+++ b/Libraries/LibWeb/Layout/SVGTextBox.h
@@ -13,8 +13,8 @@
 namespace Web::Layout {
 
 class SVGTextBox final : public SVGGraphicsBox {
-    JS_CELL(SVGTextBox, SVGGraphicsBox);
-    JS_DECLARE_ALLOCATOR(SVGTextBox);
+    GC_CELL(SVGTextBox, SVGGraphicsBox);
+    GC_DECLARE_ALLOCATOR(SVGTextBox);
 
 public:
     SVGTextBox(DOM::Document&, SVG::SVGTextPositioningElement&, CSS::StyleProperties);
@@ -23,7 +23,7 @@ public:
     SVG::SVGTextPositioningElement& dom_node() { return static_cast<SVG::SVGTextPositioningElement&>(SVGGraphicsBox::dom_node()); }
     SVG::SVGTextPositioningElement const& dom_node() const { return static_cast<SVG::SVGTextPositioningElement const&>(SVGGraphicsBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     CSSPixelPoint viewbox_origin() const;
diff --git a/Libraries/LibWeb/Layout/SVGTextPathBox.cpp b/Libraries/LibWeb/Layout/SVGTextPathBox.cpp
index f5ebdda2248..900b8508ca6 100644
--- a/Libraries/LibWeb/Layout/SVGTextPathBox.cpp
+++ b/Libraries/LibWeb/Layout/SVGTextPathBox.cpp
@@ -9,14 +9,14 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(SVGTextPathBox);
+GC_DEFINE_ALLOCATOR(SVGTextPathBox);
 
 SVGTextPathBox::SVGTextPathBox(DOM::Document& document, SVG::SVGTextPathElement& element, CSS::StyleProperties properties)
     : SVGGraphicsBox(document, element, properties)
 {
 }
 
-JS::GCPtr<Painting::Paintable> SVGTextPathBox::create_paintable() const
+GC::Ptr<Painting::Paintable> SVGTextPathBox::create_paintable() const
 {
     return Painting::SVGPathPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/SVGTextPathBox.h b/Libraries/LibWeb/Layout/SVGTextPathBox.h
index 686d49506ea..87e88bd647f 100644
--- a/Libraries/LibWeb/Layout/SVGTextPathBox.h
+++ b/Libraries/LibWeb/Layout/SVGTextPathBox.h
@@ -12,8 +12,8 @@
 namespace Web::Layout {
 
 class SVGTextPathBox final : public SVGGraphicsBox {
-    JS_CELL(SVGTextPathBox, SVGGraphicsBox);
-    JS_DECLARE_ALLOCATOR(SVGTextPathBox);
+    GC_CELL(SVGTextPathBox, SVGGraphicsBox);
+    GC_DECLARE_ALLOCATOR(SVGTextPathBox);
 
 public:
     SVGTextPathBox(DOM::Document&, SVG::SVGTextPathElement&, CSS::StyleProperties);
@@ -22,7 +22,7 @@ public:
     SVG::SVGTextPathElement& dom_node() { return static_cast<SVG::SVGTextPathElement&>(SVGGraphicsBox::dom_node()); }
     SVG::SVGTextPathElement const& dom_node() const { return static_cast<SVG::SVGTextPathElement const&>(SVGGraphicsBox::dom_node()); }
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     CSSPixelPoint viewbox_origin() const;
diff --git a/Libraries/LibWeb/Layout/TableFormattingContext.h b/Libraries/LibWeb/Layout/TableFormattingContext.h
index 432d09755fc..f38bdab9201 100644
--- a/Libraries/LibWeb/Layout/TableFormattingContext.h
+++ b/Libraries/LibWeb/Layout/TableFormattingContext.h
@@ -141,7 +141,7 @@ private:
     };
 
     struct ConflictingEdge {
-        JS::GCPtr<Node const> element;
+        GC::Ptr<Node const> element;
         Painting::PaintableBox::ConflictingElementKind element_kind;
         ConflictingSide side;
         Optional<size_t> row;
@@ -168,7 +168,7 @@ private:
         void collect_column_group_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
         void collect_table_box_conflicting_edges(Vector<ConflictingEdge>&, Cell const&, ConflictingSide) const;
 
-        JS::GCPtr<Node const> get_col_element(size_t index) const
+        GC::Ptr<Node const> get_col_element(size_t index) const
         {
             if (index >= m_col_elements_by_index.size())
                 return {};
@@ -176,12 +176,12 @@ private:
         }
 
         struct RowGroupInfo {
-            JS::GCPtr<Node const> row_group;
+            GC::Ptr<Node const> row_group;
             size_t start_index;
             size_t row_count;
         };
 
-        Vector<JS::GCPtr<Node const>> m_col_elements_by_index;
+        Vector<GC::Ptr<Node const>> m_col_elements_by_index;
         Vector<Optional<RowGroupInfo>> m_row_group_elements_by_index;
         TableFormattingContext const* m_context;
     };
diff --git a/Libraries/LibWeb/Layout/TableGrid.h b/Libraries/LibWeb/Layout/TableGrid.h
index de1ae3699ba..fffd61e417b 100644
--- a/Libraries/LibWeb/Layout/TableGrid.h
+++ b/Libraries/LibWeb/Layout/TableGrid.h
@@ -20,7 +20,7 @@ public:
     };
 
     struct Row {
-        JS::NonnullGCPtr<Box const> box;
+        GC::Ref<Box const> box;
         CSSPixels base_height { 0 };
         CSSPixels reference_height { 0 };
         CSSPixels final_height { 0 };
@@ -34,7 +34,7 @@ public:
     };
 
     struct Cell {
-        JS::NonnullGCPtr<Box const> box;
+        GC::Ref<Box const> box;
         size_t column_index;
         size_t row_index;
         size_t column_span;
diff --git a/Libraries/LibWeb/Layout/TableWrapper.cpp b/Libraries/LibWeb/Layout/TableWrapper.cpp
index 5cc8ddb4610..11940d5b80d 100644
--- a/Libraries/LibWeb/Layout/TableWrapper.cpp
+++ b/Libraries/LibWeb/Layout/TableWrapper.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(TableWrapper);
+GC_DEFINE_ALLOCATOR(TableWrapper);
 
 TableWrapper::TableWrapper(DOM::Document& document, DOM::Node* node, CSS::StyleProperties style)
     : BlockContainer(document, node, move(style))
diff --git a/Libraries/LibWeb/Layout/TableWrapper.h b/Libraries/LibWeb/Layout/TableWrapper.h
index 31b68585783..0ed2a1ec116 100644
--- a/Libraries/LibWeb/Layout/TableWrapper.h
+++ b/Libraries/LibWeb/Layout/TableWrapper.h
@@ -11,8 +11,8 @@
 namespace Web::Layout {
 
 class TableWrapper : public BlockContainer {
-    JS_CELL(TableWrapper, BlockContainer);
-    JS_DECLARE_ALLOCATOR(TableWrapper);
+    GC_CELL(TableWrapper, BlockContainer);
+    GC_DECLARE_ALLOCATOR(TableWrapper);
 
 public:
     TableWrapper(DOM::Document&, DOM::Node*, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/TextNode.cpp b/Libraries/LibWeb/Layout/TextNode.cpp
index 00e87718999..63c1b3cf5ad 100644
--- a/Libraries/LibWeb/Layout/TextNode.cpp
+++ b/Libraries/LibWeb/Layout/TextNode.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(TextNode);
+GC_DEFINE_ALLOCATOR(TextNode);
 
 TextNode::TextNode(DOM::Document& document, DOM::Text& text)
     : Node(document, &text)
@@ -585,7 +585,7 @@ Optional<TextNode::Chunk> TextNode::ChunkIterator::try_commit_chunk(size_t start
     return {};
 }
 
-JS::GCPtr<Painting::Paintable> TextNode::create_paintable() const
+GC::Ptr<Painting::Paintable> TextNode::create_paintable() const
 {
     return Painting::TextPaintable::create(*this, text_for_rendering());
 }
diff --git a/Libraries/LibWeb/Layout/TextNode.h b/Libraries/LibWeb/Layout/TextNode.h
index 0b29167b16b..c9eec9e57bc 100644
--- a/Libraries/LibWeb/Layout/TextNode.h
+++ b/Libraries/LibWeb/Layout/TextNode.h
@@ -16,8 +16,8 @@ namespace Web::Layout {
 class LineBoxFragment;
 
 class TextNode final : public Node {
-    JS_CELL(TextNode, Node);
-    JS_DECLARE_ALLOCATOR(TextNode);
+    GC_CELL(TextNode, Node);
+    GC_DECLARE_ALLOCATOR(TextNode);
 
 public:
     TextNode(DOM::Document&, DOM::Text&);
@@ -65,7 +65,7 @@ public:
 
     Unicode::Segmenter& grapheme_segmenter() const;
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     virtual bool is_text_node() const final { return true; }
diff --git a/Libraries/LibWeb/Layout/TreeBuilder.cpp b/Libraries/LibWeb/Layout/TreeBuilder.cpp
index 1a4d6e2f64b..5311e30a1a1 100644
--- a/Libraries/LibWeb/Layout/TreeBuilder.cpp
+++ b/Libraries/LibWeb/Layout/TreeBuilder.cpp
@@ -119,10 +119,10 @@ static Layout::Node& insertion_parent_for_block_node(Layout::NodeWithStyle& layo
 
     // Parent block has inline-level children (our siblings).
     // First move these siblings into an anonymous wrapper block.
-    Vector<JS::Handle<Layout::Node>> children;
+    Vector<GC::Root<Layout::Node>> children;
     {
-        JS::GCPtr<Layout::Node> next;
-        for (JS::GCPtr<Layout::Node> child = layout_parent.first_child(); child; child = next) {
+        GC::Ptr<Layout::Node> next;
+        for (GC::Ptr<Layout::Node> child = layout_parent.first_child(); child; child = next) {
             next = child->next_sibling();
             // NOTE: We let out-of-flow children stay in the parent, to preserve tree structure.
             if (child->is_out_of_flow())
@@ -317,7 +317,7 @@ void TreeBuilder::create_layout_tree(DOM::Node& dom_node, TreeBuilder::Context&
             dom_node.document().style_computer().pop_ancestor(static_cast<DOM::Element const&>(dom_node));
     };
 
-    JS::GCPtr<Layout::Node> layout_node;
+    GC::Ptr<Layout::Node> layout_node;
     Optional<TemporaryChange<bool>> has_svg_root_change;
 
     ScopeGuard remove_stale_layout_node_guard = [&] {
@@ -457,7 +457,7 @@ void TreeBuilder::create_layout_tree(DOM::Node& dom_node, TreeBuilder::Context&
         // Note: This will create a new subtree for each use of the mask (so there's  not a 1-to-1 mapping
         // from DOM node to mask layout node). Each use of a mask may be laid out differently so this
         // duplication is necessary.
-        auto layout_mask_or_clip_path = [&](JS::GCPtr<SVG::SVGElement const> mask_or_clip_path) {
+        auto layout_mask_or_clip_path = [&](GC::Ptr<SVG::SVGElement const> mask_or_clip_path) {
             TemporaryChange<bool> layout_mask(context.layout_svg_mask_or_clip_path, true);
             push_parent(verify_cast<NodeWithStyle>(*layout_node));
             create_layout_tree(const_cast<SVG::SVGElement&>(*mask_or_clip_path), context);
@@ -511,7 +511,7 @@ void TreeBuilder::create_layout_tree(DOM::Node& dom_node, TreeBuilder::Context&
         auto content_box_wrapper = parent.heap().template allocate<BlockContainer>(parent.document(), nullptr, move(content_box_computed_values));
         content_box_wrapper->set_children_are_inline(parent.children_are_inline());
 
-        Vector<JS::Handle<Node>> sequence;
+        Vector<GC::Root<Node>> sequence;
         for (auto child = parent.first_child(); child; child = child->next_sibling()) {
             if (child->is_generated_for_before_pseudo_element())
                 continue;
@@ -538,7 +538,7 @@ void TreeBuilder::create_layout_tree(DOM::Node& dom_node, TreeBuilder::Context&
     }
 }
 
-JS::GCPtr<Layout::Node> TreeBuilder::build(DOM::Node& dom_node)
+GC::Ptr<Layout::Node> TreeBuilder::build(DOM::Node& dom_node)
 {
     VERIFY(dom_node.is_document());
 
@@ -588,7 +588,7 @@ void TreeBuilder::remove_irrelevant_boxes(NodeWithStyle& root)
 {
     // The following boxes are discarded as if they were display:none:
 
-    Vector<JS::Handle<Node>> to_remove;
+    Vector<GC::Root<Node>> to_remove;
 
     // Children of a table-column.
     for_each_in_tree_with_internal_display<CSS::DisplayInternal::TableColumn>(root, [&](Box& table_column) {
@@ -673,7 +673,7 @@ static bool is_not_table_cell(Node const& node)
 template<typename Matcher, typename Callback>
 static void for_each_sequence_of_consecutive_children_matching(NodeWithStyle& parent, Matcher matcher, Callback callback)
 {
-    Vector<JS::Handle<Node>> sequence;
+    Vector<GC::Root<Node>> sequence;
 
     auto sequence_is_all_ignorable_whitespace = [&]() -> bool {
         for (auto& node : sequence) {
@@ -699,7 +699,7 @@ static void for_each_sequence_of_consecutive_children_matching(NodeWithStyle& pa
 }
 
 template<typename WrapperBoxType>
-static void wrap_in_anonymous(Vector<JS::Handle<Node>>& sequence, Node* nearest_sibling, CSS::Display display)
+static void wrap_in_anonymous(Vector<GC::Root<Node>>& sequence, Node* nearest_sibling, CSS::Display display)
 {
     VERIFY(!sequence.is_empty());
     auto& parent = *sequence.first()->parent();
@@ -753,9 +753,9 @@ void TreeBuilder::generate_missing_child_wrappers(NodeWithStyle& root)
     });
 }
 
-Vector<JS::Handle<Box>> TreeBuilder::generate_missing_parents(NodeWithStyle& root)
+Vector<GC::Root<Box>> TreeBuilder::generate_missing_parents(NodeWithStyle& root)
 {
-    Vector<JS::Handle<Box>> table_roots_to_wrap;
+    Vector<GC::Root<Box>> table_roots_to_wrap;
     root.for_each_in_inclusive_subtree_of_type<Box>([&](auto& parent) {
         // An anonymous table-row box must be generated around each sequence of consecutive table-cell boxes whose parent is not a table-row.
         if (is_not_table_row(parent)) {
@@ -833,7 +833,7 @@ static void fixup_row(Box& row_box, TableGrid const& table_grid, size_t row_inde
     }
 }
 
-void TreeBuilder::missing_cells_fixup(Vector<JS::Handle<Box>> const& table_root_boxes)
+void TreeBuilder::missing_cells_fixup(Vector<GC::Root<Box>> const& table_root_boxes)
 {
     // Implements https://www.w3.org/TR/css-tables-3/#missing-cells-fixup.
     for (auto& table_box : table_root_boxes) {
diff --git a/Libraries/LibWeb/Layout/TreeBuilder.h b/Libraries/LibWeb/Layout/TreeBuilder.h
index e54afecdc5d..b103500a1d4 100644
--- a/Libraries/LibWeb/Layout/TreeBuilder.h
+++ b/Libraries/LibWeb/Layout/TreeBuilder.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/RefPtr.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/CSS/Display.h>
 #include <LibWeb/CSS/Selector.h>
 #include <LibWeb/Forward.h>
@@ -18,7 +18,7 @@ class TreeBuilder {
 public:
     TreeBuilder();
 
-    JS::GCPtr<Layout::Node> build(DOM::Node&);
+    GC::Ptr<Layout::Node> build(DOM::Node&);
 
 private:
     struct Context {
@@ -43,8 +43,8 @@ private:
     void fixup_tables(NodeWithStyle& root);
     void remove_irrelevant_boxes(NodeWithStyle& root);
     void generate_missing_child_wrappers(NodeWithStyle& root);
-    Vector<JS::Handle<Box>> generate_missing_parents(NodeWithStyle& root);
-    void missing_cells_fixup(Vector<JS::Handle<Box>> const&);
+    Vector<GC::Root<Box>> generate_missing_parents(NodeWithStyle& root);
+    void missing_cells_fixup(Vector<GC::Root<Box>> const&);
 
     enum class AppendOrPrepend {
         Append,
@@ -53,8 +53,8 @@ private:
     void insert_node_into_inline_or_block_ancestor(Layout::Node&, CSS::Display, AppendOrPrepend);
     void create_pseudo_element_if_needed(DOM::Element&, CSS::Selector::PseudoElement::Type, AppendOrPrepend);
 
-    JS::GCPtr<Layout::Node> m_layout_root;
-    Vector<JS::NonnullGCPtr<Layout::NodeWithStyle>> m_ancestor_stack;
+    GC::Ptr<Layout::Node> m_layout_root;
+    Vector<GC::Ref<Layout::NodeWithStyle>> m_ancestor_stack;
 
     u32 m_quote_nesting_level { 0 };
 };
diff --git a/Libraries/LibWeb/Layout/VideoBox.cpp b/Libraries/LibWeb/Layout/VideoBox.cpp
index 6b45c1673b9..33852d24baa 100644
--- a/Libraries/LibWeb/Layout/VideoBox.cpp
+++ b/Libraries/LibWeb/Layout/VideoBox.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(VideoBox);
+GC_DEFINE_ALLOCATOR(VideoBox);
 
 VideoBox::VideoBox(DOM::Document& document, DOM::Element& element, CSS::StyleProperties style)
     : ReplacedBox(document, element, move(style))
@@ -57,7 +57,7 @@ void VideoBox::did_set_viewport_rect(CSSPixelRect const&)
     //        is in view. Implement those steps.
 }
 
-JS::GCPtr<Painting::Paintable> VideoBox::create_paintable() const
+GC::Ptr<Painting::Paintable> VideoBox::create_paintable() const
 {
     return Painting::VideoPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/VideoBox.h b/Libraries/LibWeb/Layout/VideoBox.h
index f158b9d200b..3e7e82dbf85 100644
--- a/Libraries/LibWeb/Layout/VideoBox.h
+++ b/Libraries/LibWeb/Layout/VideoBox.h
@@ -15,8 +15,8 @@ namespace Web::Layout {
 class VideoBox final
     : public ReplacedBox
     , public DOM::Document::ViewportClient {
-    JS_CELL(VideoBox, ReplacedBox);
-    JS_DECLARE_ALLOCATOR(VideoBox);
+    GC_CELL(VideoBox, ReplacedBox);
+    GC_DECLARE_ALLOCATOR(VideoBox);
 
 public:
     virtual void prepare_for_replaced_layout() override;
@@ -24,7 +24,7 @@ public:
     HTML::HTMLVideoElement& dom_node();
     HTML::HTMLVideoElement const& dom_node() const;
 
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
 private:
     VideoBox(DOM::Document&, DOM::Element&, CSS::StyleProperties);
diff --git a/Libraries/LibWeb/Layout/Viewport.cpp b/Libraries/LibWeb/Layout/Viewport.cpp
index 97498b4acfe..0ee2456f3d0 100644
--- a/Libraries/LibWeb/Layout/Viewport.cpp
+++ b/Libraries/LibWeb/Layout/Viewport.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Layout {
 
-JS_DEFINE_ALLOCATOR(Viewport);
+GC_DEFINE_ALLOCATOR(Viewport);
 
 Viewport::Viewport(DOM::Document& document, CSS::StyleProperties style)
     : BlockContainer(document, &document, move(style))
@@ -23,7 +23,7 @@ Viewport::Viewport(DOM::Document& document, CSS::StyleProperties style)
 
 Viewport::~Viewport() = default;
 
-JS::GCPtr<Painting::Paintable> Viewport::create_paintable() const
+GC::Ptr<Painting::Paintable> Viewport::create_paintable() const
 {
     return Painting::ViewportPaintable::create(*this);
 }
diff --git a/Libraries/LibWeb/Layout/Viewport.h b/Libraries/LibWeb/Layout/Viewport.h
index d93e11c7295..3f19c9334fc 100644
--- a/Libraries/LibWeb/Layout/Viewport.h
+++ b/Libraries/LibWeb/Layout/Viewport.h
@@ -12,15 +12,15 @@
 namespace Web::Layout {
 
 class Viewport final : public BlockContainer {
-    JS_CELL(Viewport, BlockContainer);
-    JS_DECLARE_ALLOCATOR(Viewport);
+    GC_CELL(Viewport, BlockContainer);
+    GC_DECLARE_ALLOCATOR(Viewport);
 
 public:
     explicit Viewport(DOM::Document&, CSS::StyleProperties);
     virtual ~Viewport() override;
 
     struct TextPosition {
-        JS::NonnullGCPtr<DOM::Text> dom_node;
+        GC::Ref<DOM::Text> dom_node;
         size_t start_offset { 0 };
     };
     struct TextBlock {
@@ -34,7 +34,7 @@ public:
     virtual void visit_edges(Visitor&) override;
 
 private:
-    virtual JS::GCPtr<Painting::Paintable> create_paintable() const override;
+    virtual GC::Ptr<Painting::Paintable> create_paintable() const override;
 
     void update_text_blocks();
 
diff --git a/Libraries/LibWeb/Loader/LoadRequest.h b/Libraries/LibWeb/Loader/LoadRequest.h
index fab769e8abe..14d57235908 100644
--- a/Libraries/LibWeb/Loader/LoadRequest.h
+++ b/Libraries/LibWeb/Loader/LoadRequest.h
@@ -43,7 +43,7 @@ public:
     void start_timer() { m_load_timer.start(); }
     AK::Duration load_time() const { return m_load_timer.elapsed_time(); }
 
-    JS::GCPtr<Page> page() const { return m_page.ptr(); }
+    GC::Ptr<Page> page() const { return m_page.ptr(); }
     void set_page(Page& page) { m_page = page; }
 
     unsigned hash() const
@@ -80,7 +80,7 @@ private:
     HashMap<ByteString, ByteString, CaseInsensitiveStringTraits> m_headers;
     ByteBuffer m_body;
     Core::ElapsedTimer m_load_timer;
-    JS::Handle<Page> m_page;
+    GC::Root<Page> m_page;
     bool m_main_resource { false };
 };
 
diff --git a/Libraries/LibWeb/Loader/Resource.cpp b/Libraries/LibWeb/Loader/Resource.cpp
index 395ae3cb0c4..075cd7e378f 100644
--- a/Libraries/LibWeb/Loader/Resource.cpp
+++ b/Libraries/LibWeb/Loader/Resource.cpp
@@ -159,7 +159,7 @@ void ResourceClient::set_resource(Resource* resource)
         // This ensures that these callbacks always happen in a consistent way, instead of being invoked
         // synchronously in some cases, and asynchronously in others.
         if (resource->is_loaded() || resource->is_failed()) {
-            Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(ResourceLoader::the().heap(), [weak_this = make_weak_ptr(), strong_resource = NonnullRefPtr { *m_resource }] {
+            Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(ResourceLoader::the().heap(), [weak_this = make_weak_ptr(), strong_resource = NonnullRefPtr { *m_resource }] {
                 if (!weak_this)
                     return;
 
diff --git a/Libraries/LibWeb/Loader/ResourceLoader.cpp b/Libraries/LibWeb/Loader/ResourceLoader.cpp
index 28796b1f020..84f08bb1f6f 100644
--- a/Libraries/LibWeb/Loader/ResourceLoader.cpp
+++ b/Libraries/LibWeb/Loader/ResourceLoader.cpp
@@ -30,7 +30,7 @@ namespace Web {
 
 static RefPtr<ResourceLoader> s_resource_loader;
 
-void ResourceLoader::initialize(JS::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
+void ResourceLoader::initialize(GC::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
 {
     s_resource_loader = adopt_ref(*new ResourceLoader(heap, move(request_client)));
 }
@@ -44,7 +44,7 @@ ResourceLoader& ResourceLoader::the()
     return *s_resource_loader;
 }
 
-ResourceLoader::ResourceLoader(JS::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
+ResourceLoader::ResourceLoader(GC::Heap& heap, NonnullRefPtr<Requests::RequestClient> request_client)
     : m_heap(heap)
     , m_request_client(move(request_client))
     , m_user_agent(MUST(String::from_utf8(default_user_agent)))
@@ -108,10 +108,10 @@ RefPtr<Resource> ResourceLoader::load_resource(Resource::Type type, LoadRequest&
 
     load(
         request,
-        JS::create_heap_function(m_heap, [=](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
+        GC::create_function(m_heap, [=](ReadonlyBytes data, HTTP::HeaderMap const& headers, Optional<u32> status_code, Optional<String> const&) {
             const_cast<Resource&>(*resource).did_load({}, data, headers, status_code);
         }),
-        JS::create_heap_function(m_heap, [=](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
+        GC::create_function(m_heap, [=](ByteString const& error, Optional<u32> status_code, Optional<String> const&, ReadonlyBytes data, HTTP::HeaderMap const& headers) {
             const_cast<Resource&>(*resource).did_fail({}, error, data, headers, status_code);
         }));
 
@@ -230,7 +230,7 @@ static bool should_block_request(LoadRequest const& request)
     return false;
 }
 
-void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback, Optional<u32> timeout, JS::Handle<TimeoutCallback> timeout_callback)
+void ResourceLoader::load(LoadRequest& request, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback, Optional<u32> timeout, GC::Root<TimeoutCallback> timeout_callback)
 {
     auto const& url = request.url();
 
@@ -242,7 +242,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
         return;
     }
 
-    auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback) {
+    auto respond_directory_page = [](LoadRequest const& request, URL::URL const& url, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback) {
         auto maybe_response = load_file_directory_page(url);
         if (maybe_response.is_error()) {
             log_failure(request, maybe_response.error());
@@ -278,7 +278,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
             return;
         }
 
-        Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(m_heap, [success_callback, response_headers = move(response_headers)] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [success_callback, response_headers = move(response_headers)] {
             success_callback->function()(ByteString::empty().to_byte_buffer(), response_headers, {}, {});
         }));
         return;
@@ -303,7 +303,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
 
         log_success(request);
 
-        Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] {
+        Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(m_heap, [data = move(data_url.body), response_headers = move(response_headers), success_callback] {
             success_callback->function()(data, response_headers, {}, {});
         }));
         return;
@@ -415,7 +415,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
 
         if (timeout.has_value() && timeout.value() > 0) {
             auto timer = Platform::Timer::create_single_shot(m_heap, timeout.value(), nullptr);
-            timer->on_timeout = JS::create_heap_function(m_heap, [timer = JS::make_handle(timer), protocol_request, timeout_callback] {
+            timer->on_timeout = GC::create_function(m_heap, [timer = GC::make_root(timer), protocol_request, timeout_callback] {
                 (void)timer;
                 protocol_request->stop();
                 if (timeout_callback)
@@ -465,7 +465,7 @@ void ResourceLoader::load(LoadRequest& request, JS::Handle<SuccessCallback> succ
         error_callback->function()(not_implemented_error, {}, {}, {}, {});
 }
 
-void ResourceLoader::load_unbuffered(LoadRequest& request, JS::Handle<OnHeadersReceived> on_headers_received, JS::Handle<OnDataReceived> on_data_received, JS::Handle<OnComplete> on_complete)
+void ResourceLoader::load_unbuffered(LoadRequest& request, GC::Root<OnHeadersReceived> on_headers_received, GC::Root<OnDataReceived> on_data_received, GC::Root<OnComplete> on_complete)
 {
     auto const& url = request.url();
 
diff --git a/Libraries/LibWeb/Loader/ResourceLoader.h b/Libraries/LibWeb/Loader/ResourceLoader.h
index 13da92fe07d..0af694226f6 100644
--- a/Libraries/LibWeb/Loader/ResourceLoader.h
+++ b/Libraries/LibWeb/Loader/ResourceLoader.h
@@ -21,22 +21,22 @@ namespace Web {
 class ResourceLoader : public Core::EventReceiver {
     C_OBJECT_ABSTRACT(ResourceLoader)
 public:
-    static void initialize(JS::Heap&, NonnullRefPtr<Requests::RequestClient>);
+    static void initialize(GC::Heap&, NonnullRefPtr<Requests::RequestClient>);
     static ResourceLoader& the();
 
     RefPtr<Resource> load_resource(Resource::Type, LoadRequest&);
 
-    using SuccessCallback = JS::HeapFunction<void(ReadonlyBytes, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
-    using ErrorCallback = JS::HeapFunction<void(ByteString const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
-    using TimeoutCallback = JS::HeapFunction<void()>;
+    using SuccessCallback = GC::Function<void(ReadonlyBytes, HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
+    using ErrorCallback = GC::Function<void(ByteString const&, Optional<u32> status_code, Optional<String> const& reason_phrase, ReadonlyBytes payload, HTTP::HeaderMap const& response_headers)>;
+    using TimeoutCallback = GC::Function<void()>;
 
-    void load(LoadRequest&, JS::Handle<SuccessCallback> success_callback, JS::Handle<ErrorCallback> error_callback = nullptr, Optional<u32> timeout = {}, JS::Handle<TimeoutCallback> timeout_callback = nullptr);
+    void load(LoadRequest&, GC::Root<SuccessCallback> success_callback, GC::Root<ErrorCallback> error_callback = nullptr, Optional<u32> timeout = {}, GC::Root<TimeoutCallback> timeout_callback = nullptr);
 
-    using OnHeadersReceived = JS::HeapFunction<void(HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
-    using OnDataReceived = JS::HeapFunction<void(ReadonlyBytes data)>;
-    using OnComplete = JS::HeapFunction<void(bool success, Optional<StringView> error_message)>;
+    using OnHeadersReceived = GC::Function<void(HTTP::HeaderMap const& response_headers, Optional<u32> status_code, Optional<String> const& reason_phrase)>;
+    using OnDataReceived = GC::Function<void(ReadonlyBytes data)>;
+    using OnComplete = GC::Function<void(bool success, Optional<StringView> error_message)>;
 
-    void load_unbuffered(LoadRequest&, JS::Handle<OnHeadersReceived>, JS::Handle<OnDataReceived>, JS::Handle<OnComplete>);
+    void load_unbuffered(LoadRequest&, GC::Root<OnHeadersReceived>, GC::Root<OnDataReceived>, GC::Root<OnComplete>);
 
     Requests::RequestClient& request_client() { return *m_request_client; }
 
@@ -73,10 +73,10 @@ public:
     void clear_cache();
     void evict_from_cache(LoadRequest const&);
 
-    JS::Heap& heap() { return m_heap; }
+    GC::Heap& heap() { return m_heap; }
 
 private:
-    explicit ResourceLoader(JS::Heap&, NonnullRefPtr<Requests::RequestClient>);
+    explicit ResourceLoader(GC::Heap&, NonnullRefPtr<Requests::RequestClient>);
 
     RefPtr<Requests::Request> start_network_request(LoadRequest const&);
     void handle_network_response_headers(LoadRequest const&, HTTP::HeaderMap const&);
@@ -84,7 +84,7 @@ private:
 
     int m_pending_loads { 0 };
 
-    JS::Heap& m_heap;
+    GC::Heap& m_heap;
     NonnullRefPtr<Requests::RequestClient> m_request_client;
     HashTable<NonnullRefPtr<Requests::Request>> m_active_requests;
 
@@ -93,7 +93,7 @@ private:
     Vector<String> m_preferred_languages = { "en"_string };
     NavigatorCompatibilityMode m_navigator_compatibility_mode;
     bool m_enable_do_not_track { false };
-    Optional<JS::GCPtr<Page>> m_page {};
+    Optional<GC::Ptr<Page>> m_page {};
 };
 
 }
diff --git a/Libraries/LibWeb/MathML/MathMLElement.cpp b/Libraries/LibWeb/MathML/MathMLElement.cpp
index 677007d1c34..b5857695722 100644
--- a/Libraries/LibWeb/MathML/MathMLElement.cpp
+++ b/Libraries/LibWeb/MathML/MathMLElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::MathML {
 
-JS_DEFINE_ALLOCATOR(MathMLElement);
+GC_DEFINE_ALLOCATOR(MathMLElement);
 
 MathMLElement::~MathMLElement() = default;
 
diff --git a/Libraries/LibWeb/MathML/MathMLElement.h b/Libraries/LibWeb/MathML/MathMLElement.h
index 48f57c6bff8..934bec2232e 100644
--- a/Libraries/LibWeb/MathML/MathMLElement.h
+++ b/Libraries/LibWeb/MathML/MathMLElement.h
@@ -16,7 +16,7 @@ class MathMLElement : public DOM::Element
     , public HTML::GlobalEventHandlers
     , public HTML::HTMLOrSVGElement<MathMLElement> {
     WEB_PLATFORM_OBJECT(MathMLElement, DOM::Element);
-    JS_DECLARE_ALLOCATOR(MathMLElement);
+    GC_DECLARE_ALLOCATOR(MathMLElement);
 
 public:
     virtual ~MathMLElement() override;
@@ -27,7 +27,7 @@ protected:
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
     virtual WebIDL::ExceptionOr<void> cloned(DOM::Node&, bool) override;
     virtual void inserted() override;
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
 
 private:
     MathMLElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.cpp b/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.cpp
index 82211b47d87..40198bf43ef 100644
--- a/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.cpp
+++ b/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::MediaCapabilitiesAPI {
 
-JS_DEFINE_ALLOCATOR(MediaCapabilities);
+GC_DEFINE_ALLOCATOR(MediaCapabilities);
 
-JS::NonnullGCPtr<MediaCapabilities> MediaCapabilities::create(JS::Realm& realm)
+GC::Ref<MediaCapabilities> MediaCapabilities::create(JS::Realm& realm)
 {
     return realm.create<MediaCapabilities>(realm);
 }
diff --git a/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.h b/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.h
index 590b38e8f8e..13006bec44d 100644
--- a/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.h
+++ b/Libraries/LibWeb/MediaCapabilitiesAPI/MediaCapabilities.h
@@ -12,10 +12,10 @@ namespace Web::MediaCapabilitiesAPI {
 
 class MediaCapabilities final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MediaCapabilities, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MediaCapabilities);
+    GC_DECLARE_ALLOCATOR(MediaCapabilities);
 
 public:
-    static JS::NonnullGCPtr<MediaCapabilities> create(JS::Realm&);
+    static GC::Ref<MediaCapabilities> create(JS::Realm&);
     virtual ~MediaCapabilities() override = default;
 
 private:
diff --git a/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.cpp b/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.cpp
index 7703fbdf832..bddb8402fb8 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(BufferedChangeEvent);
+GC_DEFINE_ALLOCATOR(BufferedChangeEvent);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<BufferedChangeEvent>> BufferedChangeEvent::construct_impl(JS::Realm& realm, AK::FlyString const& type, BufferedChangeEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<BufferedChangeEvent>> BufferedChangeEvent::construct_impl(JS::Realm& realm, AK::FlyString const& type, BufferedChangeEventInit const& event_init)
 {
     return realm.create<BufferedChangeEvent>(realm, type, event_init);
 }
diff --git a/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.h b/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.h
index 120ba5395dc..43da71d61f1 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/BufferedChangeEvent.h
@@ -12,17 +12,17 @@
 namespace Web::MediaSourceExtensions {
 
 struct BufferedChangeEventInit : public DOM::EventInit {
-    JS::GCPtr<HTML::TimeRanges> added_ranges;
-    JS::GCPtr<HTML::TimeRanges> removed_ranges;
+    GC::Ptr<HTML::TimeRanges> added_ranges;
+    GC::Ptr<HTML::TimeRanges> removed_ranges;
 };
 
 // https://w3c.github.io/media-source/#bufferedchangeevent-interface
 class BufferedChangeEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(BufferedChangeEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(BufferedChangeEvent);
+    GC_DECLARE_ALLOCATOR(BufferedChangeEvent);
 
 public:
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<BufferedChangeEvent>> construct_impl(JS::Realm&, FlyString const& type, BufferedChangeEventInit const& = {});
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<BufferedChangeEvent>> construct_impl(JS::Realm&, FlyString const& type, BufferedChangeEventInit const& = {});
 
 private:
     BufferedChangeEvent(JS::Realm&, FlyString const& type, BufferedChangeEventInit const& event_init);
diff --git a/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.cpp b/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.cpp
index 7cf53c42fef..fa370995d1f 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(ManagedMediaSource);
+GC_DEFINE_ALLOCATOR(ManagedMediaSource);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ManagedMediaSource>> ManagedMediaSource::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<ManagedMediaSource>> ManagedMediaSource::construct_impl(JS::Realm& realm)
 {
     return realm.create<ManagedMediaSource>(realm);
 }
diff --git a/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.h b/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.h
index 58dc88b2716..dd9a5045914 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/ManagedMediaSource.h
@@ -13,10 +13,10 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#managedmediasource-interface
 class ManagedMediaSource : public MediaSource {
     WEB_PLATFORM_OBJECT(ManagedMediaSource, MediaSource);
-    JS_DECLARE_ALLOCATOR(ManagedMediaSource);
+    GC_DECLARE_ALLOCATOR(ManagedMediaSource);
 
 public:
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<ManagedMediaSource>> construct_impl(JS::Realm&);
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<ManagedMediaSource>> construct_impl(JS::Realm&);
 
 private:
     ManagedMediaSource(JS::Realm&);
diff --git a/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.cpp b/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.cpp
index f00c7e1a423..062b4805913 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(ManagedSourceBuffer);
+GC_DEFINE_ALLOCATOR(ManagedSourceBuffer);
 
 ManagedSourceBuffer::ManagedSourceBuffer(JS::Realm& realm)
     : SourceBuffer(realm)
diff --git a/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.h b/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.h
index 32731813ad4..348d177bb3f 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/ManagedSourceBuffer.h
@@ -13,7 +13,7 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#managedsourcebuffer-interface
 class ManagedSourceBuffer : public SourceBuffer {
     WEB_PLATFORM_OBJECT(ManagedSourceBuffer, SourceBuffer);
-    JS_DECLARE_ALLOCATOR(ManagedSourceBuffer);
+    GC_DECLARE_ALLOCATOR(ManagedSourceBuffer);
 
 public:
 private:
diff --git a/Libraries/LibWeb/MediaSourceExtensions/MediaSource.cpp b/Libraries/LibWeb/MediaSourceExtensions/MediaSource.cpp
index 8df56855133..b2027628b65 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/MediaSource.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/MediaSource.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(MediaSource);
+GC_DEFINE_ALLOCATOR(MediaSource);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MediaSource>> MediaSource::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<MediaSource>> MediaSource::construct_impl(JS::Realm& realm)
 {
     return realm.create<MediaSource>(realm);
 }
diff --git a/Libraries/LibWeb/MediaSourceExtensions/MediaSource.h b/Libraries/LibWeb/MediaSourceExtensions/MediaSource.h
index 738d194568e..eb8a125b11d 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/MediaSource.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/MediaSource.h
@@ -13,10 +13,10 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#dom-mediasource
 class MediaSource : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(MediaSource, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(MediaSource);
+    GC_DECLARE_ALLOCATOR(MediaSource);
 
 public:
-    [[nodiscard]] static WebIDL::ExceptionOr<JS::NonnullGCPtr<MediaSource>> construct_impl(JS::Realm&);
+    [[nodiscard]] static WebIDL::ExceptionOr<GC::Ref<MediaSource>> construct_impl(JS::Realm&);
 
     // https://w3c.github.io/media-source/#dom-mediasource-canconstructindedicatedworker
     static bool can_construct_in_dedicated_worker(JS::VM&) { return true; }
diff --git a/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.cpp b/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.cpp
index 9275aaab214..0400615699e 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(MediaSourceHandle);
+GC_DEFINE_ALLOCATOR(MediaSourceHandle);
 
 MediaSourceHandle::MediaSourceHandle(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
diff --git a/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.h b/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.h
index f479b85c207..a1379ffadd9 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/MediaSourceHandle.h
@@ -14,7 +14,7 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#dom-mediasourcehandle
 class MediaSourceHandle : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(MediaSourceHandle, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(MediaSourceHandle);
+    GC_DECLARE_ALLOCATOR(MediaSourceHandle);
 
 public:
 private:
diff --git a/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.cpp b/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.cpp
index 1a295f91147..8a1a7c8391f 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(SourceBuffer);
+GC_DEFINE_ALLOCATOR(SourceBuffer);
 
 SourceBuffer::SourceBuffer(JS::Realm& realm)
     : DOM::EventTarget(realm)
diff --git a/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.h b/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.h
index a7d0d066251..c1e1a9a0d71 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/SourceBuffer.h
@@ -13,7 +13,7 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#dom-sourcebuffer
 class SourceBuffer : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(SourceBuffer, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(SourceBuffer);
+    GC_DECLARE_ALLOCATOR(SourceBuffer);
 
 protected:
     SourceBuffer(JS::Realm&);
diff --git a/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.cpp b/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.cpp
index 53f6db6b9d6..8a7a33f48ff 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.cpp
+++ b/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::MediaSourceExtensions {
 
-JS_DEFINE_ALLOCATOR(SourceBufferList);
+GC_DEFINE_ALLOCATOR(SourceBufferList);
 
 SourceBufferList::SourceBufferList(JS::Realm& realm)
     : DOM::EventTarget(realm)
diff --git a/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.h b/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.h
index 3949f263b10..d853dc5ae4a 100644
--- a/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.h
+++ b/Libraries/LibWeb/MediaSourceExtensions/SourceBufferList.h
@@ -13,7 +13,7 @@ namespace Web::MediaSourceExtensions {
 // https://w3c.github.io/media-source/#dom-sourcebufferlist
 class SourceBufferList : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(SourceBufferList, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(SourceBufferList);
+    GC_DECLARE_ALLOCATOR(SourceBufferList);
 
 private:
     SourceBufferList(JS::Realm&);
diff --git a/Libraries/LibWeb/MixedContent/AbstractOperations.cpp b/Libraries/LibWeb/MixedContent/AbstractOperations.cpp
index ae65f7e08d6..e51c88bb628 100644
--- a/Libraries/LibWeb/MixedContent/AbstractOperations.cpp
+++ b/Libraries/LibWeb/MixedContent/AbstractOperations.cpp
@@ -42,7 +42,7 @@ void upgrade_a_mixed_content_request_to_a_potentially_trustworthy_url_if_appropr
 }
 
 // https://w3c.github.io/webappsec-mixed-content/#categorize-settings-object
-ProhibitsMixedSecurityContexts does_settings_prohibit_mixed_security_contexts(JS::GCPtr<HTML::EnvironmentSettingsObject> settings)
+ProhibitsMixedSecurityContexts does_settings_prohibit_mixed_security_contexts(GC::Ptr<HTML::EnvironmentSettingsObject> settings)
 {
     // 1. If settings’ origin is a potentially trustworthy origin, then return "Prohibits Mixed Security Contexts".
     if (SecureContexts::is_origin_potentially_trustworthy(settings->origin()) == SecureContexts::Trustworthiness::PotentiallyTrustworthy)
@@ -91,7 +91,7 @@ Fetch::Infrastructure::RequestOrResponseBlocking should_fetching_request_be_bloc
 }
 
 // https://w3c.github.io/webappsec-mixed-content/#should-block-response
-Web::Fetch::Infrastructure::RequestOrResponseBlocking should_response_to_request_be_blocked_as_mixed_content(Fetch::Infrastructure::Request& request, JS::NonnullGCPtr<Fetch::Infrastructure::Response>& response)
+Web::Fetch::Infrastructure::RequestOrResponseBlocking should_response_to_request_be_blocked_as_mixed_content(Fetch::Infrastructure::Request& request, GC::Ref<Fetch::Infrastructure::Response>& response)
 {
     // 1. Return allowed if one or more of the following conditions are met:
     if (
diff --git a/Libraries/LibWeb/MixedContent/AbstractOperations.h b/Libraries/LibWeb/MixedContent/AbstractOperations.h
index 9025c902f38..8696dd97694 100644
--- a/Libraries/LibWeb/MixedContent/AbstractOperations.h
+++ b/Libraries/LibWeb/MixedContent/AbstractOperations.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Fetch/Infrastructure/RequestOrResponseBlocking.h>
 #include <LibWeb/HTML/Scripting/Environments.h>
 
@@ -19,10 +19,10 @@ enum class ProhibitsMixedSecurityContexts {
     DoesNotRestrictMixedSecurityContexts,
 };
 
-ProhibitsMixedSecurityContexts does_settings_prohibit_mixed_security_contexts(JS::GCPtr<HTML::EnvironmentSettingsObject>);
+ProhibitsMixedSecurityContexts does_settings_prohibit_mixed_security_contexts(GC::Ptr<HTML::EnvironmentSettingsObject>);
 
 Fetch::Infrastructure::RequestOrResponseBlocking should_fetching_request_be_blocked_as_mixed_content(Fetch::Infrastructure::Request&);
 
-Fetch::Infrastructure::RequestOrResponseBlocking should_response_to_request_be_blocked_as_mixed_content(Fetch::Infrastructure::Request&, JS::NonnullGCPtr<Fetch::Infrastructure::Response>&);
+Fetch::Infrastructure::RequestOrResponseBlocking should_response_to_request_be_blocked_as_mixed_content(Fetch::Infrastructure::Request&, GC::Ref<Fetch::Infrastructure::Response>&);
 
 }
diff --git a/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.cpp b/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.cpp
index cb41677bba5..fd3cef4379f 100644
--- a/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.cpp
+++ b/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::NavigationTiming {
 
-JS_DEFINE_ALLOCATOR(PerformanceNavigation);
+GC_DEFINE_ALLOCATOR(PerformanceNavigation);
 
 PerformanceNavigation::PerformanceNavigation(JS::Realm& realm, u16 type, u16 redirect_count)
     : PlatformObject(realm)
diff --git a/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.h b/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.h
index 50c4f4b347e..f7586edeca8 100644
--- a/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.h
+++ b/Libraries/LibWeb/NavigationTiming/PerformanceNavigation.h
@@ -12,7 +12,7 @@ namespace Web::NavigationTiming {
 
 class PerformanceNavigation final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PerformanceNavigation, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PerformanceNavigation);
+    GC_DECLARE_ALLOCATOR(PerformanceNavigation);
 
 public:
     ~PerformanceNavigation();
diff --git a/Libraries/LibWeb/NavigationTiming/PerformanceTiming.cpp b/Libraries/LibWeb/NavigationTiming/PerformanceTiming.cpp
index 0ad54b93178..6ddc2fd0210 100644
--- a/Libraries/LibWeb/NavigationTiming/PerformanceTiming.cpp
+++ b/Libraries/LibWeb/NavigationTiming/PerformanceTiming.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::NavigationTiming {
 
-JS_DEFINE_ALLOCATOR(PerformanceTiming);
+GC_DEFINE_ALLOCATOR(PerformanceTiming);
 
 PerformanceTiming::PerformanceTiming(JS::Realm& realm)
     : PlatformObject(realm)
diff --git a/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h b/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
index 73cdd056226..e5d01c7f8ff 100644
--- a/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
+++ b/Libraries/LibWeb/NavigationTiming/PerformanceTiming.h
@@ -12,7 +12,7 @@ namespace Web::NavigationTiming {
 
 class PerformanceTiming final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PerformanceTiming, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PerformanceTiming);
+    GC_DECLARE_ALLOCATOR(PerformanceTiming);
 
 public:
     using AllowOwnPtr = TrueType;
diff --git a/Libraries/LibWeb/Page/DragAndDropEventHandler.cpp b/Libraries/LibWeb/Page/DragAndDropEventHandler.cpp
index f829b7b33ec..92c919f0834 100644
--- a/Libraries/LibWeb/Page/DragAndDropEventHandler.cpp
+++ b/Libraries/LibWeb/Page/DragAndDropEventHandler.cpp
@@ -34,7 +34,7 @@ EventResult DragAndDropEventHandler::handle_drag_start(
     unsigned modifiers,
     Vector<HTML::SelectedFile> files)
 {
-    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {
+    auto fire_a_drag_and_drop_event = [&](GC::Ptr<DOM::EventTarget> target, FlyString const& name, GC::Ptr<DOM::EventTarget> related_target = nullptr) {
         return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);
     };
 
@@ -175,8 +175,8 @@ EventResult DragAndDropEventHandler::handle_drag_start(
 // https://html.spec.whatwg.org/multipage/dnd.html#drag-and-drop-processing-model:queue-a-task
 EventResult DragAndDropEventHandler::handle_drag_move(
     JS::Realm& realm,
-    JS::NonnullGCPtr<DOM::Document> document,
-    JS::NonnullGCPtr<DOM::Node> node,
+    GC::Ref<DOM::Document> document,
+    GC::Ref<DOM::Node> node,
     CSSPixelPoint screen_position,
     CSSPixelPoint page_offset,
     CSSPixelPoint client_offset,
@@ -188,7 +188,7 @@ EventResult DragAndDropEventHandler::handle_drag_move(
     if (!has_ongoing_drag_and_drop_operation())
         return EventResult::Cancelled;
 
-    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {
+    auto fire_a_drag_and_drop_event = [&](GC::Ptr<DOM::EventTarget> target, FlyString const& name, GC::Ptr<DOM::EventTarget> related_target = nullptr) {
         return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);
     };
 
@@ -204,7 +204,7 @@ EventResult DragAndDropEventHandler::handle_drag_move(
     // 3. If the drag event was not canceled and the user has not ended the drag-and-drop operation, check the state of
     //    the drag-and-drop operation, as follows:
     if (!drag_event->cancelled()) {
-        JS::GCPtr<DOM::Node> previous_target_element = m_current_target_element;
+        GC::Ptr<DOM::Node> previous_target_element = m_current_target_element;
 
         // 1. If the user is indicating a different immediate user selection than during the last iteration (or if this
         //    is the first iteration), and if this immediate user selection is not the same as the current target element,
@@ -364,7 +364,7 @@ EventResult DragAndDropEventHandler::handle_drag_end(
     if (!has_ongoing_drag_and_drop_operation())
         return EventResult::Cancelled;
 
-    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {
+    auto fire_a_drag_and_drop_event = [&](GC::Ptr<DOM::EventTarget> target, FlyString const& name, GC::Ptr<DOM::EventTarget> related_target = nullptr) {
         return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);
     };
 
@@ -396,7 +396,7 @@ EventResult DragAndDropEventHandler::handle_drag_end(
         }
         // Otherwise, the drag operation might be a success; run these substeps:
         else {
-            JS::GCPtr<HTML::DragEvent> drag_event;
+            GC::Ptr<HTML::DragEvent> drag_event;
 
             // 1. Let dropped be true.
             dropped = true;
@@ -468,9 +468,9 @@ EventResult DragAndDropEventHandler::handle_drag_end(
 }
 
 // https://html.spec.whatwg.org/multipage/dnd.html#fire-a-dnd-event
-JS::NonnullGCPtr<HTML::DragEvent> DragAndDropEventHandler::fire_a_drag_and_drop_event(
+GC::Ref<HTML::DragEvent> DragAndDropEventHandler::fire_a_drag_and_drop_event(
     JS::Realm& realm,
-    JS::GCPtr<DOM::EventTarget> target,
+    GC::Ptr<DOM::EventTarget> target,
     FlyString const& name,
     CSSPixelPoint screen_position,
     CSSPixelPoint page_offset,
@@ -479,7 +479,7 @@ JS::NonnullGCPtr<HTML::DragEvent> DragAndDropEventHandler::fire_a_drag_and_drop_
     unsigned button,
     unsigned buttons,
     unsigned modifiers,
-    JS::GCPtr<DOM::EventTarget> related_target)
+    GC::Ptr<DOM::EventTarget> related_target)
 {
     // NOTE: When the source node is determined above, the spec indicates we must follow platform-specific conventions
     //       for dispatching events at the source node if the source node is an out-of-document object. We currently
@@ -606,7 +606,7 @@ JS::NonnullGCPtr<HTML::DragEvent> DragAndDropEventHandler::fire_a_drag_and_drop_
     return event;
 }
 
-bool DragAndDropEventHandler::allow_text_drop(JS::NonnullGCPtr<DOM::Node> node) const
+bool DragAndDropEventHandler::allow_text_drop(GC::Ref<DOM::Node> node) const
 {
     if (!m_drag_data_store->has_text_item())
         return false;
diff --git a/Libraries/LibWeb/Page/DragAndDropEventHandler.h b/Libraries/LibWeb/Page/DragAndDropEventHandler.h
index c69cbd214de..76b6b46b0a1 100644
--- a/Libraries/LibWeb/Page/DragAndDropEventHandler.h
+++ b/Libraries/LibWeb/Page/DragAndDropEventHandler.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/DragDataStore.h>
 #include <LibWeb/Page/EventResult.h>
@@ -22,7 +22,7 @@ public:
     bool has_ongoing_drag_and_drop_operation() const { return !m_drag_data_store.is_null(); }
 
     EventResult handle_drag_start(JS::Realm&, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers, Vector<HTML::SelectedFile> files);
-    EventResult handle_drag_move(JS::Realm&, JS::NonnullGCPtr<DOM::Document>, JS::NonnullGCPtr<DOM::Node>, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers);
+    EventResult handle_drag_move(JS::Realm&, GC::Ref<DOM::Document>, GC::Ref<DOM::Node>, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers);
     EventResult handle_drag_leave(JS::Realm&, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers);
     EventResult handle_drop(JS::Realm&, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers);
 
@@ -33,9 +33,9 @@ private:
     };
     EventResult handle_drag_end(JS::Realm&, Cancelled, CSSPixelPoint screen_position, CSSPixelPoint page_offset, CSSPixelPoint client_offset, CSSPixelPoint offset, unsigned button, unsigned buttons, unsigned modifiers);
 
-    JS::NonnullGCPtr<HTML::DragEvent> fire_a_drag_and_drop_event(
+    GC::Ref<HTML::DragEvent> fire_a_drag_and_drop_event(
         JS::Realm&,
-        JS::GCPtr<DOM::EventTarget> target,
+        GC::Ptr<DOM::EventTarget> target,
         FlyString const& name,
         CSSPixelPoint screen_position,
         CSSPixelPoint page_offset,
@@ -44,22 +44,22 @@ private:
         unsigned button,
         unsigned buttons,
         unsigned modifiers,
-        JS::GCPtr<DOM::EventTarget> related_target = nullptr);
+        GC::Ptr<DOM::EventTarget> related_target = nullptr);
 
-    bool allow_text_drop(JS::NonnullGCPtr<DOM::Node>) const;
+    bool allow_text_drop(GC::Ref<DOM::Node>) const;
 
     void reset();
 
     RefPtr<HTML::DragDataStore> m_drag_data_store;
 
     // https://html.spec.whatwg.org/multipage/dnd.html#source-node
-    JS::GCPtr<DOM::EventTarget> m_source_node;
+    GC::Ptr<DOM::EventTarget> m_source_node;
 
     // https://html.spec.whatwg.org/multipage/dnd.html#immediate-user-selection
-    JS::GCPtr<DOM::Node> m_immediate_user_selection;
+    GC::Ptr<DOM::Node> m_immediate_user_selection;
 
     // https://html.spec.whatwg.org/multipage/dnd.html#current-target-element
-    JS::GCPtr<DOM::Node> m_current_target_element;
+    GC::Ptr<DOM::Node> m_current_target_element;
 
     // https://html.spec.whatwg.org/multipage/dnd.html#current-drag-operation
     FlyString m_current_drag_operation;
diff --git a/Libraries/LibWeb/Page/EventHandler.cpp b/Libraries/LibWeb/Page/EventHandler.cpp
index 6ccaa562b1e..4d3c5859de1 100644
--- a/Libraries/LibWeb/Page/EventHandler.cpp
+++ b/Libraries/LibWeb/Page/EventHandler.cpp
@@ -38,7 +38,7 @@ namespace Web {
     if (auto event_result = (expression); event_result == EventResult::Cancelled) \
         return event_result;
 
-static JS::GCPtr<DOM::Node> dom_node_for_event_dispatch(Painting::Paintable& paintable)
+static GC::Ptr<DOM::Node> dom_node_for_event_dispatch(Painting::Paintable& paintable)
 {
     if (auto node = paintable.mouse_event_target())
         return node;
@@ -53,7 +53,7 @@ static JS::GCPtr<DOM::Node> dom_node_for_event_dispatch(Painting::Paintable& pai
     return nullptr;
 }
 
-static bool parent_element_for_event_dispatch(Painting::Paintable& paintable, JS::GCPtr<DOM::Node>& node, Layout::Node*& layout_node)
+static bool parent_element_for_event_dispatch(Painting::Paintable& paintable, GC::Ptr<DOM::Node>& node, Layout::Node*& layout_node)
 {
     auto* current_ancestor_node = node.ptr();
     do {
@@ -189,7 +189,7 @@ EventResult EventHandler::handle_mousewheel(CSSPixelPoint viewport_position, CSS
 
     auto handled_event = EventResult::Dropped;
 
-    JS::GCPtr<Painting::Paintable> paintable;
+    GC::Ptr<Painting::Paintable> paintable;
     if (auto result = target_for_mouse_position(position); result.has_value())
         paintable = result->paintable;
 
@@ -253,7 +253,7 @@ EventResult EventHandler::handle_mouseup(CSSPixelPoint viewport_position, CSSPix
     if (!paint_root())
         return EventResult::Dropped;
 
-    JS::GCPtr<Painting::Paintable> paintable;
+    GC::Ptr<Painting::Paintable> paintable;
     if (auto result = target_for_mouse_position(position); result.has_value())
         paintable = result->paintable;
 
@@ -322,8 +322,8 @@ EventResult EventHandler::handle_mouseup(CSSPixelPoint viewport_position, CSSPix
                 //
                 //        https://html.spec.whatwg.org/multipage/document-sequences.html#the-rules-for-choosing-a-navigable
 
-                if (JS::GCPtr<HTML::HTMLAnchorElement const> link = node->enclosing_link_element()) {
-                    JS::NonnullGCPtr<DOM::Document> document = *m_navigable->active_document();
+                if (GC::Ptr<HTML::HTMLAnchorElement const> link = node->enclosing_link_element()) {
+                    GC::Ref<DOM::Document> document = *m_navigable->active_document();
                     auto href = link->href();
                     auto url = document->parse_url(href);
 
@@ -385,11 +385,11 @@ EventResult EventHandler::handle_mousedown(CSSPixelPoint viewport_position, CSSP
     if (!paint_root())
         return EventResult::Dropped;
 
-    JS::NonnullGCPtr<DOM::Document> document = *m_navigable->active_document();
-    JS::GCPtr<DOM::Node> node;
+    GC::Ref<DOM::Document> document = *m_navigable->active_document();
+    GC::Ptr<DOM::Node> node;
 
     {
-        JS::GCPtr<Painting::Paintable> paintable;
+        GC::Ptr<Painting::Paintable> paintable;
         if (auto result = target_for_mouse_position(position); result.has_value())
             paintable = result->paintable;
         else
@@ -442,7 +442,7 @@ EventResult EventHandler::handle_mousedown(CSSPixelPoint viewport_position, CSSP
             auto dom_node = paintable->dom_node();
             if (dom_node) {
                 // See if we want to focus something.
-                JS::GCPtr<DOM::Node> focus_candidate;
+                GC::Ptr<DOM::Node> focus_candidate;
                 for (auto candidate = node; candidate; candidate = candidate->parent_or_shadow_host()) {
                     if (candidate->is_focusable()) {
                         focus_candidate = candidate;
@@ -507,7 +507,7 @@ EventResult EventHandler::handle_mousemove(CSSPixelPoint viewport_position, CSSP
     bool is_hovering_link = false;
     Gfx::StandardCursor hovered_node_cursor = Gfx::StandardCursor::None;
 
-    JS::GCPtr<Painting::Paintable> paintable;
+    GC::Ptr<Painting::Paintable> paintable;
     Optional<int> start_index;
 
     if (auto result = target_for_mouse_position(position); result.has_value()) {
@@ -608,7 +608,7 @@ EventResult EventHandler::handle_mousemove(CSSPixelPoint viewport_position, CSSP
     page.client().page_did_request_cursor_change(hovered_node_cursor);
 
     if (hovered_node_changed) {
-        JS::GCPtr<HTML::HTMLElement const> hovered_html_element = document.hovered_node() ? document.hovered_node()->enclosing_html_element_with_attribute(HTML::AttributeNames::title) : nullptr;
+        GC::Ptr<HTML::HTMLElement const> hovered_html_element = document.hovered_node() ? document.hovered_node()->enclosing_html_element_with_attribute(HTML::AttributeNames::title) : nullptr;
         if (hovered_html_element && hovered_html_element->title().has_value()) {
             page.client().page_did_enter_tooltip_area(hovered_html_element->title()->to_byte_string());
         } else {
@@ -643,7 +643,7 @@ EventResult EventHandler::handle_doubleclick(CSSPixelPoint viewport_position, CS
     if (!paint_root())
         return EventResult::Dropped;
 
-    JS::GCPtr<Painting::Paintable> paintable;
+    GC::Ptr<Painting::Paintable> paintable;
     if (auto result = target_for_mouse_position(position); result.has_value())
         paintable = result->paintable;
     else
@@ -722,7 +722,7 @@ EventResult EventHandler::handle_drag_and_drop_event(DragEvent::Type type, CSSPi
     if (!paint_root())
         return EventResult::Dropped;
 
-    JS::GCPtr<Painting::Paintable> paintable;
+    GC::Ptr<Painting::Paintable> paintable;
     if (auto result = target_for_mouse_position(viewport_position); result.has_value())
         paintable = result->paintable;
     else
@@ -836,13 +836,13 @@ constexpr bool should_ignore_keydown_event(u32 code_point, u32 modifiers)
 
 EventResult EventHandler::fire_keyboard_event(FlyString const& event_name, HTML::Navigable& navigable, UIEvents::KeyCode key, u32 modifiers, u32 code_point, bool repeat)
 {
-    JS::GCPtr<DOM::Document> document = navigable.active_document();
+    GC::Ptr<DOM::Document> document = navigable.active_document();
     if (!document)
         return EventResult::Dropped;
     if (!document->is_fully_active())
         return EventResult::Dropped;
 
-    if (JS::GCPtr<DOM::Element> focused_element = document->focused_element()) {
+    if (GC::Ptr<DOM::Element> focused_element = document->focused_element()) {
         if (is<HTML::NavigableContainer>(*focused_element)) {
             auto& navigable_container = verify_cast<HTML::NavigableContainer>(*focused_element);
             if (navigable_container.content_navigable())
@@ -856,7 +856,7 @@ EventResult EventHandler::fire_keyboard_event(FlyString const& event_name, HTML:
     // FIXME: De-duplicate this. This is just to prevent wasting a KeyboardEvent allocation when recursing into an (i)frame.
     auto event = UIEvents::KeyboardEvent::create_from_platform_event(document->realm(), event_name, key, modifiers, code_point, repeat);
 
-    JS::GCPtr target = document->body() ?: &document->root();
+    GC::Ptr target = document->body() ?: &document->root();
     return target->dispatch_event(event) ? EventResult::Accepted : EventResult::Cancelled;
 }
 
@@ -925,7 +925,7 @@ EventResult EventHandler::handle_keydown(UIEvents::KeyCode key, u32 modifiers, u
             return dispatch_result;
     }
 
-    JS::NonnullGCPtr<DOM::Document> document = *m_navigable->active_document();
+    GC::Ref<DOM::Document> document = *m_navigable->active_document();
 
     if (key == UIEvents::KeyCode::Key_Tab) {
         if (modifiers & UIEvents::KeyModifier::Mod_Shift)
diff --git a/Libraries/LibWeb/Page/EventHandler.h b/Libraries/LibWeb/Page/EventHandler.h
index a9049204d23..ce2b067f82a 100644
--- a/Libraries/LibWeb/Page/EventHandler.h
+++ b/Libraries/LibWeb/Page/EventHandler.h
@@ -9,9 +9,9 @@
 #include <AK/Forward.h>
 #include <AK/NonnullOwnPtr.h>
 #include <AK/WeakPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibGfx/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibUnicode/Forward.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/Page/EventResult.h>
@@ -56,7 +56,7 @@ private:
     CSSPixelPoint compute_mouse_event_movement(CSSPixelPoint event_client_offset) const;
 
     struct Target {
-        JS::GCPtr<Painting::Paintable> paintable;
+        GC::Ptr<Painting::Paintable> paintable;
         Optional<int> index_in_node;
     };
     Optional<Target> target_for_mouse_position(CSSPixelPoint position);
@@ -66,12 +66,12 @@ private:
 
     bool should_ignore_device_input_event() const;
 
-    JS::NonnullGCPtr<HTML::Navigable> m_navigable;
+    GC::Ref<HTML::Navigable> m_navigable;
 
     bool m_in_mouse_selection { false };
     InputEventsTarget* m_mouse_selection_target { nullptr };
 
-    JS::GCPtr<Painting::Paintable> m_mouse_event_tracking_paintable;
+    GC::Ptr<Painting::Paintable> m_mouse_event_tracking_paintable;
 
     NonnullOwnPtr<DragAndDropEventHandler> m_drag_and_drop_event_handler;
 
diff --git a/Libraries/LibWeb/Page/Page.cpp b/Libraries/LibWeb/Page/Page.cpp
index c557739a576..768475e4bc3 100644
--- a/Libraries/LibWeb/Page/Page.cpp
+++ b/Libraries/LibWeb/Page/Page.cpp
@@ -28,14 +28,14 @@
 
 namespace Web {
 
-JS_DEFINE_ALLOCATOR(Page);
+GC_DEFINE_ALLOCATOR(Page);
 
-JS::NonnullGCPtr<Page> Page::create(JS::VM& vm, JS::NonnullGCPtr<PageClient> page_client)
+GC::Ref<Page> Page::create(JS::VM& vm, GC::Ref<PageClient> page_client)
 {
     return vm.heap().allocate<Page>(page_client);
 }
 
-Page::Page(JS::NonnullGCPtr<PageClient> client)
+Page::Page(GC::Ref<PageClient> client)
     : m_client(client)
 {
 }
@@ -227,7 +227,7 @@ EventResult Page::handle_keyup(UIEvents::KeyCode key, unsigned modifiers, u32 co
     return focused_navigable().event_handler().handle_keyup(key, modifiers, code_point, repeat);
 }
 
-void Page::set_top_level_traversable(JS::NonnullGCPtr<HTML::TraversableNavigable> navigable)
+void Page::set_top_level_traversable(GC::Ref<HTML::TraversableNavigable> navigable)
 {
     VERIFY(!m_top_level_traversable); // Replacement is not allowed!
     VERIFY(&navigable->page() == this);
@@ -249,7 +249,7 @@ HTML::BrowsingContext const& Page::top_level_browsing_context() const
     return *m_top_level_traversable->active_browsing_context();
 }
 
-JS::NonnullGCPtr<HTML::TraversableNavigable> Page::top_level_traversable() const
+GC::Ref<HTML::TraversableNavigable> Page::top_level_traversable() const
 {
     return *m_top_level_traversable;
 }
@@ -266,7 +266,7 @@ static ResponseType spin_event_loop_until_dialog_closed(PageClient& client, Opti
     auto& event_loop = Web::HTML::current_principal_settings_object().responsible_event_loop();
     auto pause_handle = event_loop.pause();
 
-    Web::Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(event_loop.heap(), [&]() {
+    Web::Platform::EventLoopPlugin::the().spin_until(GC::create_function(event_loop.heap(), [&]() {
         return response.has_value() || !client.is_connection_open();
     }));
 
@@ -335,7 +335,7 @@ void Page::prompt_closed(Optional<String> response)
     }
 }
 
-void Page::dismiss_dialog(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_dialog_closed)
+void Page::dismiss_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed)
 {
     m_on_pending_dialog_closed = on_dialog_closed;
 
@@ -352,7 +352,7 @@ void Page::dismiss_dialog(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_dialog_c
     }
 }
 
-void Page::accept_dialog(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_dialog_closed)
+void Page::accept_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed)
 {
     m_on_pending_dialog_closed = on_dialog_closed;
 
@@ -541,7 +541,7 @@ void Page::toggle_page_mute_state()
     }
 }
 
-JS::GCPtr<HTML::HTMLMediaElement> Page::media_context_menu_element()
+GC::Ptr<HTML::HTMLMediaElement> Page::media_context_menu_element()
 {
     if (!m_media_context_menu_element_id.has_value())
         return nullptr;
@@ -564,7 +564,7 @@ void Page::set_user_style(String source)
     }
 }
 
-Vector<JS::Handle<DOM::Document>> Page::documents_in_active_window() const
+Vector<GC::Root<DOM::Document>> Page::documents_in_active_window() const
 {
     if (!top_level_traversable_is_initialized())
         return {};
@@ -593,7 +593,7 @@ Page::FindInPageResult Page::perform_find_in_page_query(FindInPageQuery const& q
 {
     VERIFY(top_level_traversable_is_initialized());
 
-    Vector<JS::Handle<DOM::Range>> all_matches;
+    Vector<GC::Root<DOM::Range>> all_matches;
 
     auto find_current_match_index = [this, &direction](auto& document, auto& matches) -> size_t {
         // Always return the first match if there is no active query.
@@ -704,7 +704,7 @@ Page::FindInPageResult Page::find_in_page_previous_match()
     return result;
 }
 
-void Page::update_find_in_page_selection(Vector<JS::Handle<DOM::Range>> matches)
+void Page::update_find_in_page_selection(Vector<GC::Root<DOM::Range>> matches)
 {
     clear_selection();
 
diff --git a/Libraries/LibWeb/Page/Page.h b/Libraries/LibWeb/Page/Page.h
index 40d75b67d9b..5892ec90981 100644
--- a/Libraries/LibWeb/Page/Page.h
+++ b/Libraries/LibWeb/Page/Page.h
@@ -14,6 +14,8 @@
 #include <AK/RefPtr.h>
 #include <AK/WeakPtr.h>
 #include <AK/Weakable.h>
+#include <LibGC/Heap.h>
+#include <LibGC/Root.h>
 #include <LibGfx/Forward.h>
 #include <LibGfx/Palette.h>
 #include <LibGfx/Point.h>
@@ -22,8 +24,6 @@
 #include <LibGfx/Size.h>
 #include <LibGfx/StandardCursor.h>
 #include <LibIPC/Forward.h>
-#include <LibJS/Heap/Handle.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibURL/URL.h>
 #include <LibWeb/CSS/PreferredColorScheme.h>
 #include <LibWeb/CSS/PreferredContrast.h>
@@ -50,18 +50,18 @@ namespace Web {
 class PageClient;
 
 class Page final : public JS::Cell {
-    JS_CELL(Page, JS::Cell);
-    JS_DECLARE_ALLOCATOR(Page);
+    GC_CELL(Page, JS::Cell);
+    GC_DECLARE_ALLOCATOR(Page);
 
 public:
-    static JS::NonnullGCPtr<Page> create(JS::VM&, JS::NonnullGCPtr<PageClient>);
+    static GC::Ref<Page> create(JS::VM&, GC::Ref<PageClient>);
 
     ~Page();
 
     PageClient& client() { return m_client; }
     PageClient const& client() const { return m_client; }
 
-    void set_top_level_traversable(JS::NonnullGCPtr<HTML::TraversableNavigable>);
+    void set_top_level_traversable(GC::Ref<HTML::TraversableNavigable>);
 
     // FIXME: This is a hack.
     bool top_level_traversable_is_initialized() const;
@@ -69,7 +69,7 @@ public:
     HTML::BrowsingContext& top_level_browsing_context();
     HTML::BrowsingContext const& top_level_browsing_context() const;
 
-    JS::NonnullGCPtr<HTML::TraversableNavigable> top_level_traversable() const;
+    GC::Ref<HTML::TraversableNavigable> top_level_traversable() const;
 
     HTML::Navigable& focused_navigable();
     HTML::Navigable const& focused_navigable() const { return const_cast<Page*>(this)->focused_navigable(); }
@@ -128,7 +128,7 @@ public:
     void set_window_size(DevicePixelSize size) { m_window_size = size; }
 
     void did_update_window_rect();
-    void set_window_rect_observer(JS::GCPtr<JS::HeapFunction<void(DevicePixelRect)>> window_rect_observer) { m_window_rect_observer = window_rect_observer; }
+    void set_window_rect_observer(GC::Ptr<GC::Function<void(DevicePixelRect)>> window_rect_observer) { m_window_rect_observer = window_rect_observer; }
 
     void did_request_alert(String const& message);
     void alert_closed();
@@ -148,8 +148,8 @@ public:
     bool has_pending_dialog() const { return m_pending_dialog != PendingDialog::None; }
     PendingDialog pending_dialog() const { return m_pending_dialog; }
     Optional<String> const& pending_dialog_text() const { return m_pending_dialog_text; }
-    void dismiss_dialog(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_dialog_closed);
-    void accept_dialog(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_dialog_closed);
+    void dismiss_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed);
+    void accept_dialog(GC::Ref<GC::Function<void()>> on_dialog_closed);
 
     void did_request_color_picker(WeakPtr<HTML::HTMLInputElement> target, Color current_color);
     void color_picker_update(Optional<Color> picked_color, HTML::ColorPickerUpdateState state);
@@ -213,27 +213,27 @@ public:
     Optional<FindInPageQuery> last_find_in_page_query() const { return m_last_find_in_page_query; }
 
 private:
-    explicit Page(JS::NonnullGCPtr<PageClient>);
+    explicit Page(GC::Ref<PageClient>);
     virtual void visit_edges(Visitor&) override;
 
-    JS::GCPtr<HTML::HTMLMediaElement> media_context_menu_element();
+    GC::Ptr<HTML::HTMLMediaElement> media_context_menu_element();
 
-    Vector<JS::Handle<DOM::Document>> documents_in_active_window() const;
+    Vector<GC::Root<DOM::Document>> documents_in_active_window() const;
 
     enum class SearchDirection {
         Forward,
         Backward,
     };
     FindInPageResult perform_find_in_page_query(FindInPageQuery const&, Optional<SearchDirection> = {});
-    void update_find_in_page_selection(Vector<JS::Handle<DOM::Range>> matches);
+    void update_find_in_page_selection(Vector<GC::Root<DOM::Range>> matches);
 
     void on_pending_dialog_closed();
 
-    JS::NonnullGCPtr<PageClient> m_client;
+    GC::Ref<PageClient> m_client;
 
     WeakPtr<HTML::Navigable> m_focused_navigable;
 
-    JS::GCPtr<HTML::TraversableNavigable> m_top_level_traversable;
+    GC::Ptr<HTML::TraversableNavigable> m_top_level_traversable;
 
     // FIXME: Enable this by default once CORS preflight checks are supported.
     bool m_same_origin_policy_enabled { false };
@@ -248,14 +248,14 @@ private:
 
     DevicePixelPoint m_window_position {};
     DevicePixelSize m_window_size {};
-    JS::GCPtr<JS::HeapFunction<void(DevicePixelRect)>> m_window_rect_observer;
+    GC::Ptr<GC::Function<void(DevicePixelRect)>> m_window_rect_observer;
 
     PendingDialog m_pending_dialog { PendingDialog::None };
     Optional<String> m_pending_dialog_text;
     Optional<Empty> m_pending_alert_response;
     Optional<bool> m_pending_confirm_response;
     Optional<Optional<String>> m_pending_prompt_response;
-    JS::GCPtr<JS::HeapFunction<void()>> m_on_pending_dialog_closed;
+    GC::Ptr<GC::Function<void()>> m_on_pending_dialog_closed;
 
     PendingNonBlockingDialog m_pending_non_blocking_dialog { PendingNonBlockingDialog::None };
     WeakPtr<HTML::HTMLElement> m_pending_non_blocking_dialog_target;
@@ -294,7 +294,7 @@ enum class DisplayListPlayerType {
 };
 
 class PageClient : public JS::Cell {
-    JS_CELL(PageClient, JS::Cell);
+    GC_CELL(PageClient, JS::Cell);
 
 public:
     virtual Page& page() = 0;
@@ -351,7 +351,7 @@ public:
     virtual void page_did_expire_cookies_with_time_offset(AK::Duration) { }
     virtual void page_did_update_resource_count(i32) { }
     struct NewWebViewResult {
-        JS::GCPtr<Page> page;
+        GC::Ptr<Page> page;
         String window_handle;
     };
     virtual NewWebViewResult page_did_request_new_web_view(HTML::ActivateTab, HTML::WebViewHints, HTML::TokenizedFeature::NoOpener) { return {}; }
@@ -381,8 +381,8 @@ public:
     virtual void inspector_did_select_dom_node([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] Optional<CSS::Selector::PseudoElement::Type> const& pseudo_element) { }
     virtual void inspector_did_set_dom_node_text([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] String const& text) { }
     virtual void inspector_did_set_dom_node_tag([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] String const& tag) { }
-    virtual void inspector_did_add_dom_node_attributes([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] JS::NonnullGCPtr<DOM::NamedNodeMap> attributes) { }
-    virtual void inspector_did_replace_dom_node_attribute([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] size_t attribute_index, [[maybe_unused]] JS::NonnullGCPtr<DOM::NamedNodeMap> replacement_attributes) { }
+    virtual void inspector_did_add_dom_node_attributes([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] GC::Ref<DOM::NamedNodeMap> attributes) { }
+    virtual void inspector_did_replace_dom_node_attribute([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] size_t attribute_index, [[maybe_unused]] GC::Ref<DOM::NamedNodeMap> replacement_attributes) { }
     virtual void inspector_did_request_dom_tree_context_menu([[maybe_unused]] UniqueNodeID node_id, [[maybe_unused]] CSSPixelPoint position, [[maybe_unused]] String const& type, [[maybe_unused]] Optional<String> const& tag, [[maybe_unused]] Optional<size_t> const& attribute_index) { }
     virtual void inspector_did_request_cookie_context_menu([[maybe_unused]] size_t cookie_index, [[maybe_unused]] CSSPixelPoint position) { }
     virtual void inspector_did_request_style_sheet_source([[maybe_unused]] CSS::StyleSheetIdentifier const& identifier) { }
diff --git a/Libraries/LibWeb/Painting/AudioPaintable.cpp b/Libraries/LibWeb/Painting/AudioPaintable.cpp
index 9e1a163bac4..de42238e31c 100644
--- a/Libraries/LibWeb/Painting/AudioPaintable.cpp
+++ b/Libraries/LibWeb/Painting/AudioPaintable.cpp
@@ -17,9 +17,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(AudioPaintable);
+GC_DEFINE_ALLOCATOR(AudioPaintable);
 
-JS::NonnullGCPtr<AudioPaintable> AudioPaintable::create(Layout::AudioBox const& layout_box)
+GC::Ref<AudioPaintable> AudioPaintable::create(Layout::AudioBox const& layout_box)
 {
     return layout_box.heap().allocate<AudioPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/AudioPaintable.h b/Libraries/LibWeb/Painting/AudioPaintable.h
index e82dc356c21..2b712d3280c 100644
--- a/Libraries/LibWeb/Painting/AudioPaintable.h
+++ b/Libraries/LibWeb/Painting/AudioPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class AudioPaintable final : public MediaPaintable {
-    JS_CELL(AudioPaintable, MediaPaintable);
-    JS_DECLARE_ALLOCATOR(AudioPaintable);
+    GC_CELL(AudioPaintable, MediaPaintable);
+    GC_DECLARE_ALLOCATOR(AudioPaintable);
 
 public:
-    static JS::NonnullGCPtr<AudioPaintable> create(Layout::AudioBox const&);
+    static GC::Ref<AudioPaintable> create(Layout::AudioBox const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/CanvasPaintable.cpp b/Libraries/LibWeb/Painting/CanvasPaintable.cpp
index d407a03d8f9..2d655b23cba 100644
--- a/Libraries/LibWeb/Painting/CanvasPaintable.cpp
+++ b/Libraries/LibWeb/Painting/CanvasPaintable.cpp
@@ -9,9 +9,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(CanvasPaintable);
+GC_DEFINE_ALLOCATOR(CanvasPaintable);
 
-JS::NonnullGCPtr<CanvasPaintable> CanvasPaintable::create(Layout::CanvasBox const& layout_box)
+GC::Ref<CanvasPaintable> CanvasPaintable::create(Layout::CanvasBox const& layout_box)
 {
     return layout_box.heap().allocate<CanvasPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/CanvasPaintable.h b/Libraries/LibWeb/Painting/CanvasPaintable.h
index b9c5c427382..37b9ecf7b43 100644
--- a/Libraries/LibWeb/Painting/CanvasPaintable.h
+++ b/Libraries/LibWeb/Painting/CanvasPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class CanvasPaintable final : public PaintableBox {
-    JS_CELL(CanvasPaintable, PaintableBox);
-    JS_DECLARE_ALLOCATOR(CanvasPaintable);
+    GC_CELL(CanvasPaintable, PaintableBox);
+    GC_DECLARE_ALLOCATOR(CanvasPaintable);
 
 public:
-    static JS::NonnullGCPtr<CanvasPaintable> create(Layout::CanvasBox const&);
+    static GC::Ref<CanvasPaintable> create(Layout::CanvasBox const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/CheckBoxPaintable.cpp b/Libraries/LibWeb/Painting/CheckBoxPaintable.cpp
index a380402c378..bad5d9c7510 100644
--- a/Libraries/LibWeb/Painting/CheckBoxPaintable.cpp
+++ b/Libraries/LibWeb/Painting/CheckBoxPaintable.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(CheckBoxPaintable);
+GC_DEFINE_ALLOCATOR(CheckBoxPaintable);
 
 static Gfx::Path check_mark_path(Gfx::IntRect checkbox_rect)
 {
@@ -37,7 +37,7 @@ static Gfx::Path check_mark_path(Gfx::IntRect checkbox_rect)
     return path.copy_transformed(scale_checkmark_to_fit);
 }
 
-JS::NonnullGCPtr<CheckBoxPaintable>
+GC::Ref<CheckBoxPaintable>
 CheckBoxPaintable::create(Layout::CheckBox const& layout_box)
 {
     return layout_box.heap().allocate<CheckBoxPaintable>(layout_box);
diff --git a/Libraries/LibWeb/Painting/CheckBoxPaintable.h b/Libraries/LibWeb/Painting/CheckBoxPaintable.h
index 424003919bf..9fdf824c019 100644
--- a/Libraries/LibWeb/Painting/CheckBoxPaintable.h
+++ b/Libraries/LibWeb/Painting/CheckBoxPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class CheckBoxPaintable final : public LabelablePaintable {
-    JS_CELL(CheckBoxPaintable, LabelablePaintable);
-    JS_DECLARE_ALLOCATOR(CheckBoxPaintable);
+    GC_CELL(CheckBoxPaintable, LabelablePaintable);
+    GC_DECLARE_ALLOCATOR(CheckBoxPaintable);
 
 public:
-    static JS::NonnullGCPtr<CheckBoxPaintable> create(Layout::CheckBox const&);
+    static GC::Ref<CheckBoxPaintable> create(Layout::CheckBox const&);
 
     Layout::CheckBox const& layout_box() const;
     Layout::CheckBox& layout_box();
diff --git a/Libraries/LibWeb/Painting/ImagePaintable.cpp b/Libraries/LibWeb/Painting/ImagePaintable.cpp
index 3e05f2edc1e..b888011d092 100644
--- a/Libraries/LibWeb/Painting/ImagePaintable.cpp
+++ b/Libraries/LibWeb/Painting/ImagePaintable.cpp
@@ -16,14 +16,14 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(ImagePaintable);
+GC_DEFINE_ALLOCATOR(ImagePaintable);
 
-JS::NonnullGCPtr<ImagePaintable> ImagePaintable::create(Layout::SVGImageBox const& layout_box)
+GC::Ref<ImagePaintable> ImagePaintable::create(Layout::SVGImageBox const& layout_box)
 {
     return layout_box.heap().allocate<ImagePaintable>(layout_box, layout_box.dom_node(), false, String {}, true);
 }
 
-JS::NonnullGCPtr<ImagePaintable> ImagePaintable::create(Layout::ImageBox const& layout_box)
+GC::Ref<ImagePaintable> ImagePaintable::create(Layout::ImageBox const& layout_box)
 {
     auto alt = layout_box.dom_node().get_attribute_value(HTML::AttributeNames::alt);
     return layout_box.heap().allocate<ImagePaintable>(layout_box, layout_box.image_provider(), layout_box.renders_as_alt_text(), move(alt), false);
diff --git a/Libraries/LibWeb/Painting/ImagePaintable.h b/Libraries/LibWeb/Painting/ImagePaintable.h
index c510f6bcb9e..f7c3508208f 100644
--- a/Libraries/LibWeb/Painting/ImagePaintable.h
+++ b/Libraries/LibWeb/Painting/ImagePaintable.h
@@ -15,12 +15,12 @@ namespace Web::Painting {
 class ImagePaintable final
     : public PaintableBox
     , public DOM::Document::ViewportClient {
-    JS_CELL(ImagePaintable, PaintableBox);
-    JS_DECLARE_ALLOCATOR(ImagePaintable);
+    GC_CELL(ImagePaintable, PaintableBox);
+    GC_DECLARE_ALLOCATOR(ImagePaintable);
 
 public:
-    static JS::NonnullGCPtr<ImagePaintable> create(Layout::ImageBox const& layout_box);
-    static JS::NonnullGCPtr<ImagePaintable> create(Layout::SVGImageBox const& layout_box);
+    static GC::Ref<ImagePaintable> create(Layout::ImageBox const& layout_box);
+    static GC::Ref<ImagePaintable> create(Layout::SVGImageBox const& layout_box);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/LabelablePaintable.h b/Libraries/LibWeb/Painting/LabelablePaintable.h
index f248a5461c3..90fb0852cae 100644
--- a/Libraries/LibWeb/Painting/LabelablePaintable.h
+++ b/Libraries/LibWeb/Painting/LabelablePaintable.h
@@ -16,7 +16,7 @@ namespace Web::Painting {
 // FIXME: Splinter this into FormAssociatedLabelablePaintable once
 //        ProgressPaintable switches over to this.
 class LabelablePaintable : public PaintableBox {
-    JS_CELL(LabelablePaintable, PaintableBox);
+    GC_CELL(LabelablePaintable, PaintableBox);
 
 public:
     Layout::FormAssociatedLabelableNode const& layout_box() const;
diff --git a/Libraries/LibWeb/Painting/MarkerPaintable.cpp b/Libraries/LibWeb/Painting/MarkerPaintable.cpp
index f4da4202dd0..6498a9f340b 100644
--- a/Libraries/LibWeb/Painting/MarkerPaintable.cpp
+++ b/Libraries/LibWeb/Painting/MarkerPaintable.cpp
@@ -4,16 +4,16 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <LibGC/Heap.h>
 #include <LibGfx/AntiAliasingPainter.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibWeb/Layout/ListItemMarkerBox.h>
 #include <LibWeb/Painting/MarkerPaintable.h>
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(MarkerPaintable);
+GC_DEFINE_ALLOCATOR(MarkerPaintable);
 
-JS::NonnullGCPtr<MarkerPaintable> MarkerPaintable::create(Layout::ListItemMarkerBox const& layout_box)
+GC::Ref<MarkerPaintable> MarkerPaintable::create(Layout::ListItemMarkerBox const& layout_box)
 {
     return layout_box.heap().allocate<MarkerPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/MarkerPaintable.h b/Libraries/LibWeb/Painting/MarkerPaintable.h
index 08778447de5..f50b2515c88 100644
--- a/Libraries/LibWeb/Painting/MarkerPaintable.h
+++ b/Libraries/LibWeb/Painting/MarkerPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class MarkerPaintable final : public PaintableBox {
-    JS_CELL(MarkerPaintable, PaintableBox);
-    JS_DECLARE_ALLOCATOR(MarkerPaintable);
+    GC_CELL(MarkerPaintable, PaintableBox);
+    GC_DECLARE_ALLOCATOR(MarkerPaintable);
 
 public:
-    static JS::NonnullGCPtr<MarkerPaintable> create(Layout::ListItemMarkerBox const&);
+    static GC::Ref<MarkerPaintable> create(Layout::ListItemMarkerBox const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/MediaPaintable.h b/Libraries/LibWeb/Painting/MediaPaintable.h
index d4efc4eb973..08d5b2dfd68 100644
--- a/Libraries/LibWeb/Painting/MediaPaintable.h
+++ b/Libraries/LibWeb/Painting/MediaPaintable.h
@@ -14,7 +14,7 @@
 namespace Web::Painting {
 
 class MediaPaintable : public PaintableBox {
-    JS_CELL(MediaPaintable, PaintableBox);
+    GC_CELL(MediaPaintable, PaintableBox);
 
 protected:
     explicit MediaPaintable(Layout::ReplacedBox const&);
diff --git a/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.cpp b/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.cpp
index 6580d3b250b..3dd520c8d27 100644
--- a/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.cpp
+++ b/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(NestedBrowsingContextPaintable);
+GC_DEFINE_ALLOCATOR(NestedBrowsingContextPaintable);
 
-JS::NonnullGCPtr<NestedBrowsingContextPaintable> NestedBrowsingContextPaintable::create(Layout::FrameBox const& layout_box)
+GC::Ref<NestedBrowsingContextPaintable> NestedBrowsingContextPaintable::create(Layout::FrameBox const& layout_box)
 {
     return layout_box.heap().allocate<NestedBrowsingContextPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.h b/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.h
index ddd15a38239..d966c205acd 100644
--- a/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.h
+++ b/Libraries/LibWeb/Painting/NestedBrowsingContextPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class NestedBrowsingContextPaintable final : public PaintableBox {
-    JS_CELL(NestedBrowsingContextPaintable, PaintableBox);
-    JS_DECLARE_ALLOCATOR(NestedBrowsingContextPaintable);
+    GC_CELL(NestedBrowsingContextPaintable, PaintableBox);
+    GC_DECLARE_ALLOCATOR(NestedBrowsingContextPaintable);
 
 public:
-    static JS::NonnullGCPtr<NestedBrowsingContextPaintable> create(Layout::FrameBox const&);
+    static GC::Ref<NestedBrowsingContextPaintable> create(Layout::FrameBox const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/Paintable.cpp b/Libraries/LibWeb/Painting/Paintable.cpp
index 7c093f96365..63b03c74259 100644
--- a/Libraries/LibWeb/Painting/Paintable.cpp
+++ b/Libraries/LibWeb/Painting/Paintable.cpp
@@ -83,22 +83,22 @@ CSS::ImmutableComputedValues const& Paintable::computed_values() const
     return m_layout_node->computed_values();
 }
 
-void Paintable::set_dom_node(JS::GCPtr<DOM::Node> dom_node)
+void Paintable::set_dom_node(GC::Ptr<DOM::Node> dom_node)
 {
     m_dom_node = dom_node;
 }
 
-JS::GCPtr<DOM::Node> Paintable::dom_node()
+GC::Ptr<DOM::Node> Paintable::dom_node()
 {
     return m_dom_node;
 }
 
-JS::GCPtr<DOM::Node const> Paintable::dom_node() const
+GC::Ptr<DOM::Node const> Paintable::dom_node() const
 {
     return m_dom_node;
 }
 
-JS::GCPtr<HTML::Navigable> Paintable::navigable() const
+GC::Ptr<HTML::Navigable> Paintable::navigable() const
 {
     return document().navigable();
 }
diff --git a/Libraries/LibWeb/Painting/Paintable.h b/Libraries/LibWeb/Painting/Paintable.h
index 5f1884b5169..5df02d83d0f 100644
--- a/Libraries/LibWeb/Painting/Paintable.h
+++ b/Libraries/LibWeb/Painting/Paintable.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/NonnullOwnPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/InvalidateDisplayList.h>
 #include <LibWeb/Layout/LineBox.h>
 #include <LibWeb/TraversalDecision.h>
@@ -25,7 +25,7 @@ enum class PaintPhase {
 };
 
 struct HitTestResult {
-    JS::Handle<Paintable> paintable;
+    GC::Root<Paintable> paintable;
     int index_in_node { 0 };
     Optional<CSSPixels> vertical_distance {};
     Optional<CSSPixels> horizontal_distance {};
@@ -50,7 +50,7 @@ enum class HitTestType {
 class Paintable
     : public JS::Cell
     , public TreeNode<Paintable> {
-    JS_CELL(Paintable, JS::Cell);
+    GC_CELL(Paintable, JS::Cell);
 
 public:
     virtual ~Paintable();
@@ -190,15 +190,15 @@ public:
     Layout::Node const& layout_node() const { return m_layout_node; }
     Layout::Node& layout_node() { return const_cast<Layout::Node&>(*m_layout_node); }
 
-    [[nodiscard]] JS::GCPtr<DOM::Node> dom_node();
-    [[nodiscard]] JS::GCPtr<DOM::Node const> dom_node() const;
-    void set_dom_node(JS::GCPtr<DOM::Node>);
+    [[nodiscard]] GC::Ptr<DOM::Node> dom_node();
+    [[nodiscard]] GC::Ptr<DOM::Node const> dom_node() const;
+    void set_dom_node(GC::Ptr<DOM::Node>);
 
     CSS::ImmutableComputedValues const& computed_values() const;
 
     bool visible_for_hit_testing() const { return computed_values().pointer_events() != CSS::PointerEvents::None; }
 
-    JS::GCPtr<HTML::Navigable> navigable() const;
+    GC::Ptr<HTML::Navigable> navigable() const;
 
     virtual void set_needs_display(InvalidateDisplayList = InvalidateDisplayList::Yes);
 
@@ -247,9 +247,9 @@ protected:
 
 private:
     IntrusiveListNode<Paintable> m_list_node;
-    JS::GCPtr<DOM::Node> m_dom_node;
-    JS::NonnullGCPtr<Layout::Node const> m_layout_node;
-    Optional<JS::GCPtr<PaintableBox>> mutable m_containing_block;
+    GC::Ptr<DOM::Node> m_dom_node;
+    GC::Ref<Layout::Node const> m_layout_node;
+    Optional<GC::Ptr<PaintableBox>> mutable m_containing_block;
 
     OwnPtr<StackingContext> m_stacking_context;
 
diff --git a/Libraries/LibWeb/Painting/PaintableBox.cpp b/Libraries/LibWeb/Painting/PaintableBox.cpp
index 8e112f2a106..b08792a1800 100644
--- a/Libraries/LibWeb/Painting/PaintableBox.cpp
+++ b/Libraries/LibWeb/Painting/PaintableBox.cpp
@@ -32,22 +32,22 @@
 
 namespace Web::Painting {
 
-JS::NonnullGCPtr<PaintableWithLines> PaintableWithLines::create(Layout::BlockContainer const& block_container)
+GC::Ref<PaintableWithLines> PaintableWithLines::create(Layout::BlockContainer const& block_container)
 {
     return block_container.heap().allocate<PaintableWithLines>(block_container);
 }
 
-JS::NonnullGCPtr<PaintableWithLines> PaintableWithLines::create(Layout::InlineNode const& inline_node, size_t line_index)
+GC::Ref<PaintableWithLines> PaintableWithLines::create(Layout::InlineNode const& inline_node, size_t line_index)
 {
     return inline_node.heap().allocate<PaintableWithLines>(inline_node, line_index);
 }
 
-JS::NonnullGCPtr<PaintableBox> PaintableBox::create(Layout::Box const& layout_box)
+GC::Ref<PaintableBox> PaintableBox::create(Layout::Box const& layout_box)
 {
     return layout_box.heap().allocate<PaintableBox>(layout_box);
 }
 
-JS::NonnullGCPtr<PaintableBox> PaintableBox::create(Layout::InlineNode const& layout_box)
+GC::Ref<PaintableBox> PaintableBox::create(Layout::InlineNode const& layout_box)
 {
     return layout_box.heap().allocate<PaintableBox>(layout_box);
 }
@@ -142,7 +142,7 @@ void PaintableBox::set_scroll_offset(CSSPixelPoint offset)
     //           the element’s eventual snap target in the block axis as newBlockTarget and the element’s eventual snap
     //           target in the inline axis as newInlineTarget.
 
-    JS::NonnullGCPtr<DOM::EventTarget> const event_target = *dom_node();
+    GC::Ref<DOM::EventTarget> const event_target = *dom_node();
 
     // 3. If the element is already in doc’s pending scroll event targets, abort these steps.
     if (document.pending_scroll_event_targets().contains_slow(event_target))
diff --git a/Libraries/LibWeb/Painting/PaintableBox.h b/Libraries/LibWeb/Painting/PaintableBox.h
index 53db1b4185a..c81e9358498 100644
--- a/Libraries/LibWeb/Painting/PaintableBox.h
+++ b/Libraries/LibWeb/Painting/PaintableBox.h
@@ -23,11 +23,11 @@ namespace Web::Painting {
 
 class PaintableBox : public Paintable
     , public ClippableAndScrollable {
-    JS_CELL(PaintableBox, Paintable);
+    GC_CELL(PaintableBox, Paintable);
 
 public:
-    static JS::NonnullGCPtr<PaintableBox> create(Layout::Box const&);
-    static JS::NonnullGCPtr<PaintableBox> create(Layout::InlineNode const&);
+    static GC::Ref<PaintableBox> create(Layout::Box const&);
+    static GC::Ref<PaintableBox> create(Layout::InlineNode const&);
     virtual ~PaintableBox();
 
     virtual void before_paint(PaintContext&, PaintPhase) const override;
@@ -310,11 +310,11 @@ private:
 };
 
 class PaintableWithLines : public PaintableBox {
-    JS_CELL(PaintableWithLines, PaintableBox);
+    GC_CELL(PaintableWithLines, PaintableBox);
 
 public:
-    static JS::NonnullGCPtr<PaintableWithLines> create(Layout::BlockContainer const&);
-    static JS::NonnullGCPtr<PaintableWithLines> create(Layout::InlineNode const&, size_t line_index);
+    static GC::Ref<PaintableWithLines> create(Layout::BlockContainer const&);
+    static GC::Ref<PaintableWithLines> create(Layout::InlineNode const&, size_t line_index);
     virtual ~PaintableWithLines() override;
 
     Layout::NodeWithStyleAndBoxModelMetrics const& layout_node_with_style_and_box_metrics() const;
@@ -347,7 +347,7 @@ public:
     {
         Base::visit_edges(visitor);
         for (auto& fragment : m_fragments)
-            visitor.visit(JS::NonnullGCPtr { fragment.layout_node() });
+            visitor.visit(GC::Ref { fragment.layout_node() });
     }
 
     virtual void resolve_paint_properties() override;
diff --git a/Libraries/LibWeb/Painting/PaintableFragment.h b/Libraries/LibWeb/Painting/PaintableFragment.h
index 5fef570a073..313a51a353b 100644
--- a/Libraries/LibWeb/Painting/PaintableFragment.h
+++ b/Libraries/LibWeb/Painting/PaintableFragment.h
@@ -50,7 +50,7 @@ public:
     StringView string_view() const;
 
 private:
-    JS::NonnullGCPtr<Layout::Node const> m_layout_node;
+    GC::Ref<Layout::Node const> m_layout_node;
     CSSPixelPoint m_offset;
     CSSPixelSize m_size;
     CSSPixels m_baseline;
diff --git a/Libraries/LibWeb/Painting/RadioButtonPaintable.cpp b/Libraries/LibWeb/Painting/RadioButtonPaintable.cpp
index d33395a086d..7dff2a815b9 100644
--- a/Libraries/LibWeb/Painting/RadioButtonPaintable.cpp
+++ b/Libraries/LibWeb/Painting/RadioButtonPaintable.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(RadioButtonPaintable);
+GC_DEFINE_ALLOCATOR(RadioButtonPaintable);
 
-JS::NonnullGCPtr<RadioButtonPaintable> RadioButtonPaintable::create(Layout::RadioButton const& layout_box)
+GC::Ref<RadioButtonPaintable> RadioButtonPaintable::create(Layout::RadioButton const& layout_box)
 {
     return layout_box.heap().allocate<RadioButtonPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/RadioButtonPaintable.h b/Libraries/LibWeb/Painting/RadioButtonPaintable.h
index 0a262ec5b9f..ffba3107dcf 100644
--- a/Libraries/LibWeb/Painting/RadioButtonPaintable.h
+++ b/Libraries/LibWeb/Painting/RadioButtonPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class RadioButtonPaintable final : public LabelablePaintable {
-    JS_CELL(RadioButtonPaintable, LabelablePaintable);
-    JS_DECLARE_ALLOCATOR(RadioButtonPaintable);
+    GC_CELL(RadioButtonPaintable, LabelablePaintable);
+    GC_DECLARE_ALLOCATOR(RadioButtonPaintable);
 
 public:
-    static JS::NonnullGCPtr<RadioButtonPaintable> create(Layout::RadioButton const&);
+    static GC::Ref<RadioButtonPaintable> create(Layout::RadioButton const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/SVGClipPaintable.cpp b/Libraries/LibWeb/Painting/SVGClipPaintable.cpp
index 50c00950f17..676858f95b0 100644
--- a/Libraries/LibWeb/Painting/SVGClipPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGClipPaintable.cpp
@@ -8,9 +8,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(SVGClipPaintable);
+GC_DEFINE_ALLOCATOR(SVGClipPaintable);
 
-JS::NonnullGCPtr<SVGClipPaintable> SVGClipPaintable::create(Layout::SVGClipBox const& layout_box)
+GC::Ref<SVGClipPaintable> SVGClipPaintable::create(Layout::SVGClipBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGClipPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGClipPaintable.h b/Libraries/LibWeb/Painting/SVGClipPaintable.h
index 198172a4afb..7aa2ae14ef1 100644
--- a/Libraries/LibWeb/Painting/SVGClipPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGClipPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class SVGClipPaintable : public SVGPaintable {
-    JS_CELL(SVGClipPaintable, SVGPaintable);
-    JS_DECLARE_ALLOCATOR(SVGClipPaintable);
+    GC_CELL(SVGClipPaintable, SVGPaintable);
+    GC_DECLARE_ALLOCATOR(SVGClipPaintable);
 
 public:
-    static JS::NonnullGCPtr<SVGClipPaintable> create(Layout::SVGClipBox const&);
+    static GC::Ref<SVGClipPaintable> create(Layout::SVGClipBox const&);
 
     bool forms_unconnected_subtree() const override
     {
diff --git a/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.cpp b/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.cpp
index d8919f31662..5e92358ac1a 100644
--- a/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.cpp
@@ -9,9 +9,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(SVGForeignObjectPaintable);
+GC_DEFINE_ALLOCATOR(SVGForeignObjectPaintable);
 
-JS::NonnullGCPtr<SVGForeignObjectPaintable> SVGForeignObjectPaintable::create(Layout::SVGForeignObjectBox const& layout_box)
+GC::Ref<SVGForeignObjectPaintable> SVGForeignObjectPaintable::create(Layout::SVGForeignObjectBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGForeignObjectPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.h b/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.h
index 6272882a9f3..3bae86b19b1 100644
--- a/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGForeignObjectPaintable.h
@@ -14,11 +14,11 @@ namespace Web::Painting {
 
 class SVGForeignObjectPaintable final : public PaintableWithLines
     , public SVGMaskable {
-    JS_CELL(SVGForeignObjectPaintable, PaintableWithLines);
-    JS_DECLARE_ALLOCATOR(SVGForeignObjectPaintable);
+    GC_CELL(SVGForeignObjectPaintable, PaintableWithLines);
+    GC_DECLARE_ALLOCATOR(SVGForeignObjectPaintable);
 
 public:
-    static JS::NonnullGCPtr<SVGForeignObjectPaintable> create(Layout::SVGForeignObjectBox const&);
+    static GC::Ref<SVGForeignObjectPaintable> create(Layout::SVGForeignObjectBox const&);
 
     virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override;
 
@@ -26,7 +26,7 @@ public:
 
     Layout::SVGForeignObjectBox const& layout_box() const;
 
-    virtual JS::GCPtr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
+    virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
     virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); }
     virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); }
     virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(PaintContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); }
diff --git a/Libraries/LibWeb/Painting/SVGGraphicsPaintable.cpp b/Libraries/LibWeb/Painting/SVGGraphicsPaintable.cpp
index 160adfd633d..f1980ebc7e2 100644
--- a/Libraries/LibWeb/Painting/SVGGraphicsPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGGraphicsPaintable.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::Painting {
 
-JS::NonnullGCPtr<SVGGraphicsPaintable> SVGGraphicsPaintable::create(Layout::SVGGraphicsBox const& layout_box)
+GC::Ref<SVGGraphicsPaintable> SVGGraphicsPaintable::create(Layout::SVGGraphicsBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGGraphicsPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGGraphicsPaintable.h b/Libraries/LibWeb/Painting/SVGGraphicsPaintable.h
index b45b69fac3a..cfa9f459f27 100644
--- a/Libraries/LibWeb/Painting/SVGGraphicsPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGGraphicsPaintable.h
@@ -14,7 +14,7 @@ namespace Web::Painting {
 
 class SVGGraphicsPaintable : public SVGPaintable
     , public SVGMaskable {
-    JS_CELL(SVGGraphicsPaintable, SVGPaintable);
+    GC_CELL(SVGGraphicsPaintable, SVGPaintable);
 
 public:
     class ComputedTransforms {
@@ -47,11 +47,11 @@ public:
         Gfx::AffineTransform m_svg_transform {};
     };
 
-    static JS::NonnullGCPtr<SVGGraphicsPaintable> create(Layout::SVGGraphicsBox const&);
+    static GC::Ref<SVGGraphicsPaintable> create(Layout::SVGGraphicsBox const&);
 
     Layout::SVGGraphicsBox const& layout_box() const;
 
-    virtual JS::GCPtr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
+    virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
     virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); }
     virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); }
     virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(PaintContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); }
diff --git a/Libraries/LibWeb/Painting/SVGMaskPaintable.cpp b/Libraries/LibWeb/Painting/SVGMaskPaintable.cpp
index 190b78ab535..cb4c367113c 100644
--- a/Libraries/LibWeb/Painting/SVGMaskPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGMaskPaintable.cpp
@@ -8,9 +8,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(SVGMaskPaintable);
+GC_DEFINE_ALLOCATOR(SVGMaskPaintable);
 
-JS::NonnullGCPtr<SVGMaskPaintable> SVGMaskPaintable::create(Layout::SVGMaskBox const& layout_box)
+GC::Ref<SVGMaskPaintable> SVGMaskPaintable::create(Layout::SVGMaskBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGMaskPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGMaskPaintable.h b/Libraries/LibWeb/Painting/SVGMaskPaintable.h
index c048d9ccfbf..253fe35bdfa 100644
--- a/Libraries/LibWeb/Painting/SVGMaskPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGMaskPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class SVGMaskPaintable : public SVGGraphicsPaintable {
-    JS_CELL(SVGMaskPaintable, SVGGraphicsPaintable);
-    JS_DECLARE_ALLOCATOR(SVGMaskPaintable);
+    GC_CELL(SVGMaskPaintable, SVGGraphicsPaintable);
+    GC_DECLARE_ALLOCATOR(SVGMaskPaintable);
 
 public:
-    static JS::NonnullGCPtr<SVGMaskPaintable> create(Layout::SVGMaskBox const&);
+    static GC::Ref<SVGMaskPaintable> create(Layout::SVGMaskBox const&);
 
     bool forms_unconnected_subtree() const override
     {
diff --git a/Libraries/LibWeb/Painting/SVGMaskable.h b/Libraries/LibWeb/Painting/SVGMaskable.h
index 22a16cebf41..ed69616503e 100644
--- a/Libraries/LibWeb/Painting/SVGMaskable.h
+++ b/Libraries/LibWeb/Painting/SVGMaskable.h
@@ -15,7 +15,7 @@ class SVGMaskable {
 public:
     virtual ~SVGMaskable() = default;
 
-    virtual JS::GCPtr<DOM::Node const> dom_node_of_svg() const = 0;
+    virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const = 0;
 
     Optional<CSSPixelRect> get_masking_area_of_svg() const;
     Optional<Gfx::Bitmap::MaskKind> get_mask_type_of_svg() const;
diff --git a/Libraries/LibWeb/Painting/SVGPaintable.h b/Libraries/LibWeb/Painting/SVGPaintable.h
index c514197d506..2d592947755 100644
--- a/Libraries/LibWeb/Painting/SVGPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGPaintable.h
@@ -12,7 +12,7 @@
 namespace Web::Painting {
 
 class SVGPaintable : public PaintableBox {
-    JS_CELL(SVGPaintable, PaintableBox);
+    GC_CELL(SVGPaintable, PaintableBox);
 
 public:
     Layout::SVGBox const& layout_box() const;
diff --git a/Libraries/LibWeb/Painting/SVGPathPaintable.cpp b/Libraries/LibWeb/Painting/SVGPathPaintable.cpp
index c1cbdba147c..40eeb529748 100644
--- a/Libraries/LibWeb/Painting/SVGPathPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGPathPaintable.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(SVGPathPaintable);
+GC_DEFINE_ALLOCATOR(SVGPathPaintable);
 
-JS::NonnullGCPtr<SVGPathPaintable> SVGPathPaintable::create(Layout::SVGGraphicsBox const& layout_box)
+GC::Ref<SVGPathPaintable> SVGPathPaintable::create(Layout::SVGGraphicsBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGPathPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGPathPaintable.h b/Libraries/LibWeb/Painting/SVGPathPaintable.h
index 0b4cd4ba967..d5f9679c41e 100644
--- a/Libraries/LibWeb/Painting/SVGPathPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGPathPaintable.h
@@ -13,11 +13,11 @@
 namespace Web::Painting {
 
 class SVGPathPaintable final : public SVGGraphicsPaintable {
-    JS_CELL(SVGPathPaintable, SVGGraphicsPaintable);
-    JS_DECLARE_ALLOCATOR(SVGPathPaintable);
+    GC_CELL(SVGPathPaintable, SVGGraphicsPaintable);
+    GC_DECLARE_ALLOCATOR(SVGPathPaintable);
 
 public:
-    static JS::NonnullGCPtr<SVGPathPaintable> create(Layout::SVGGraphicsBox const&);
+    static GC::Ref<SVGPathPaintable> create(Layout::SVGGraphicsBox const&);
 
     virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override;
 
diff --git a/Libraries/LibWeb/Painting/SVGSVGPaintable.cpp b/Libraries/LibWeb/Painting/SVGSVGPaintable.cpp
index 4e3c500b185..1020b57c12d 100644
--- a/Libraries/LibWeb/Painting/SVGSVGPaintable.cpp
+++ b/Libraries/LibWeb/Painting/SVGSVGPaintable.cpp
@@ -9,9 +9,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(SVGSVGPaintable);
+GC_DEFINE_ALLOCATOR(SVGSVGPaintable);
 
-JS::NonnullGCPtr<SVGSVGPaintable> SVGSVGPaintable::create(Layout::SVGSVGBox const& layout_box)
+GC::Ref<SVGSVGPaintable> SVGSVGPaintable::create(Layout::SVGSVGBox const& layout_box)
 {
     return layout_box.heap().allocate<SVGSVGPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/SVGSVGPaintable.h b/Libraries/LibWeb/Painting/SVGSVGPaintable.h
index a8697b13523..cc364b7f989 100644
--- a/Libraries/LibWeb/Painting/SVGSVGPaintable.h
+++ b/Libraries/LibWeb/Painting/SVGSVGPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class SVGSVGPaintable final : public PaintableBox {
-    JS_CELL(SVGSVGPaintable, PaintableBox);
-    JS_DECLARE_ALLOCATOR(SVGSVGPaintable);
+    GC_CELL(SVGSVGPaintable, PaintableBox);
+    GC_DECLARE_ALLOCATOR(SVGSVGPaintable);
 
 public:
-    static JS::NonnullGCPtr<SVGSVGPaintable> create(Layout::SVGSVGBox const&);
+    static GC::Ref<SVGSVGPaintable> create(Layout::SVGSVGBox const&);
 
     virtual void before_children_paint(PaintContext&, PaintPhase) const override;
     virtual void after_children_paint(PaintContext&, PaintPhase) const override;
diff --git a/Libraries/LibWeb/Painting/StackingContext.h b/Libraries/LibWeb/Painting/StackingContext.h
index 64832b0e813..41c9c0843a3 100644
--- a/Libraries/LibWeb/Painting/StackingContext.h
+++ b/Libraries/LibWeb/Painting/StackingContext.h
@@ -48,14 +48,14 @@ public:
     void set_last_paint_generation_id(u64 generation_id);
 
 private:
-    JS::NonnullGCPtr<Paintable> m_paintable;
+    GC::Ref<Paintable> m_paintable;
     StackingContext* const m_parent { nullptr };
     Vector<StackingContext*> m_children;
     size_t m_index_in_tree_order { 0 };
     Optional<u64> m_last_paint_generation_id;
 
-    Vector<JS::NonnullGCPtr<Paintable const>> m_positioned_descendants_and_stacking_contexts_with_stack_level_0;
-    Vector<JS::NonnullGCPtr<Paintable const>> m_non_positioned_floating_descendants;
+    Vector<GC::Ref<Paintable const>> m_positioned_descendants_and_stacking_contexts_with_stack_level_0;
+    Vector<GC::Ref<Paintable const>> m_non_positioned_floating_descendants;
 
     static void paint_child(PaintContext&, StackingContext const&);
     void paint_internal(PaintContext&) const;
diff --git a/Libraries/LibWeb/Painting/TextPaintable.cpp b/Libraries/LibWeb/Painting/TextPaintable.cpp
index 148bd9e93b9..8f01aadfdc1 100644
--- a/Libraries/LibWeb/Painting/TextPaintable.cpp
+++ b/Libraries/LibWeb/Painting/TextPaintable.cpp
@@ -12,9 +12,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(TextPaintable);
+GC_DEFINE_ALLOCATOR(TextPaintable);
 
-JS::NonnullGCPtr<TextPaintable> TextPaintable::create(Layout::TextNode const& layout_node, String const& text_for_rendering)
+GC::Ref<TextPaintable> TextPaintable::create(Layout::TextNode const& layout_node, String const& text_for_rendering)
 {
     return layout_node.heap().allocate<TextPaintable>(layout_node, text_for_rendering);
 }
diff --git a/Libraries/LibWeb/Painting/TextPaintable.h b/Libraries/LibWeb/Painting/TextPaintable.h
index 647b0ccbf50..8db7af67b1b 100644
--- a/Libraries/LibWeb/Painting/TextPaintable.h
+++ b/Libraries/LibWeb/Painting/TextPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class TextPaintable final : public Paintable {
-    JS_CELL(TextPaintable, Paintable);
-    JS_DECLARE_ALLOCATOR(TextPaintable);
+    GC_CELL(TextPaintable, Paintable);
+    GC_DECLARE_ALLOCATOR(TextPaintable);
 
 public:
-    static JS::NonnullGCPtr<TextPaintable> create(Layout::TextNode const&, String const& text_for_rendering);
+    static GC::Ref<TextPaintable> create(Layout::TextNode const&, String const& text_for_rendering);
 
     Layout::TextNode const& layout_node() const { return static_cast<Layout::TextNode const&>(Paintable::layout_node()); }
 
diff --git a/Libraries/LibWeb/Painting/VideoPaintable.cpp b/Libraries/LibWeb/Painting/VideoPaintable.cpp
index f735492abd9..9e823a9942a 100644
--- a/Libraries/LibWeb/Painting/VideoPaintable.cpp
+++ b/Libraries/LibWeb/Painting/VideoPaintable.cpp
@@ -19,7 +19,7 @@ namespace Web::Painting {
 static constexpr auto control_box_color = Gfx::Color::from_rgb(0x26'26'26);
 static constexpr auto control_highlight_color = Gfx::Color::from_rgb(0x1d'99'f3);
 
-JS_DEFINE_ALLOCATOR(VideoPaintable);
+GC_DEFINE_ALLOCATOR(VideoPaintable);
 
 static constexpr Gfx::Color control_button_color(bool is_hovered)
 {
@@ -28,7 +28,7 @@ static constexpr Gfx::Color control_button_color(bool is_hovered)
     return control_highlight_color;
 }
 
-JS::NonnullGCPtr<VideoPaintable> VideoPaintable::create(Layout::VideoBox const& layout_box)
+GC::Ref<VideoPaintable> VideoPaintable::create(Layout::VideoBox const& layout_box)
 {
     return layout_box.heap().allocate<VideoPaintable>(layout_box);
 }
diff --git a/Libraries/LibWeb/Painting/VideoPaintable.h b/Libraries/LibWeb/Painting/VideoPaintable.h
index 4406db734d9..73f0b21ec42 100644
--- a/Libraries/LibWeb/Painting/VideoPaintable.h
+++ b/Libraries/LibWeb/Painting/VideoPaintable.h
@@ -12,11 +12,11 @@
 namespace Web::Painting {
 
 class VideoPaintable final : public MediaPaintable {
-    JS_CELL(VideoPaintable, MediaPaintable);
-    JS_DECLARE_ALLOCATOR(VideoPaintable);
+    GC_CELL(VideoPaintable, MediaPaintable);
+    GC_DECLARE_ALLOCATOR(VideoPaintable);
 
 public:
-    static JS::NonnullGCPtr<VideoPaintable> create(Layout::VideoBox const&);
+    static GC::Ref<VideoPaintable> create(Layout::VideoBox const&);
 
     virtual void paint(PaintContext&, PaintPhase) const override;
 
diff --git a/Libraries/LibWeb/Painting/ViewportPaintable.cpp b/Libraries/LibWeb/Painting/ViewportPaintable.cpp
index 1b8e5279153..cfe92552ea9 100644
--- a/Libraries/LibWeb/Painting/ViewportPaintable.cpp
+++ b/Libraries/LibWeb/Painting/ViewportPaintable.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::Painting {
 
-JS_DEFINE_ALLOCATOR(ViewportPaintable);
+GC_DEFINE_ALLOCATOR(ViewportPaintable);
 
-JS::NonnullGCPtr<ViewportPaintable> ViewportPaintable::create(Layout::Viewport const& layout_viewport)
+GC::Ref<ViewportPaintable> ViewportPaintable::create(Layout::Viewport const& layout_viewport)
 {
     return layout_viewport.heap().allocate<ViewportPaintable>(layout_viewport);
 }
@@ -273,7 +273,7 @@ void ViewportPaintable::resolve_paint_only_properties()
     });
 }
 
-JS::GCPtr<Selection::Selection> ViewportPaintable::selection() const
+GC::Ptr<Selection::Selection> ViewportPaintable::selection() const
 {
     return const_cast<DOM::Document&>(document()).get_selection();
 }
diff --git a/Libraries/LibWeb/Painting/ViewportPaintable.h b/Libraries/LibWeb/Painting/ViewportPaintable.h
index 5a81b123c41..4e569c365db 100644
--- a/Libraries/LibWeb/Painting/ViewportPaintable.h
+++ b/Libraries/LibWeb/Painting/ViewportPaintable.h
@@ -13,11 +13,11 @@
 namespace Web::Painting {
 
 class ViewportPaintable final : public PaintableWithLines {
-    JS_CELL(ViewportPaintable, PaintableWithLines);
-    JS_DECLARE_ALLOCATOR(ViewportPaintable);
+    GC_CELL(ViewportPaintable, PaintableWithLines);
+    GC_DECLARE_ALLOCATOR(ViewportPaintable);
 
 public:
-    static JS::NonnullGCPtr<ViewportPaintable> create(Layout::Viewport const&);
+    static GC::Ref<ViewportPaintable> create(Layout::Viewport const&);
     virtual ~ViewportPaintable() override;
 
     void paint_all_phases(PaintContext&);
@@ -26,12 +26,12 @@ public:
     void assign_scroll_frames();
     void refresh_scroll_state();
 
-    HashMap<JS::GCPtr<PaintableBox const>, RefPtr<ClipFrame>> clip_state;
+    HashMap<GC::Ptr<PaintableBox const>, RefPtr<ClipFrame>> clip_state;
     void assign_clip_frames();
 
     void resolve_paint_only_properties();
 
-    JS::GCPtr<Selection::Selection> selection() const;
+    GC::Ptr<Selection::Selection> selection() const;
     void recompute_selection_states(DOM::Range&);
 
     bool handle_mousewheel(Badge<EventHandler>, CSSPixelPoint, unsigned, unsigned, int wheel_delta_x, int wheel_delta_y) override;
diff --git a/Libraries/LibWeb/PerformanceTimeline/PerformanceEntryTuple.h b/Libraries/LibWeb/PerformanceTimeline/PerformanceEntryTuple.h
index e2ecaee1c62..be61d1a59b3 100644
--- a/Libraries/LibWeb/PerformanceTimeline/PerformanceEntryTuple.h
+++ b/Libraries/LibWeb/PerformanceTimeline/PerformanceEntryTuple.h
@@ -14,7 +14,7 @@ namespace Web::PerformanceTimeline {
 struct PerformanceEntryTuple {
     // https://www.w3.org/TR/performance-timeline/#dfn-performance-entry-buffer
     // A performance entry buffer to store PerformanceEntry objects, that is initially empty.
-    Vector<JS::NonnullGCPtr<PerformanceEntry>> performance_entry_buffer;
+    Vector<GC::Ref<PerformanceEntry>> performance_entry_buffer;
 
     // https://www.w3.org/TR/performance-timeline/#dfn-maxbuffersize
     // An integer maxBufferSize, initialized to the registry value for this entry type.
diff --git a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.cpp b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.cpp
index a61b589fda7..6d0269b9277 100644
--- a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.cpp
+++ b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.cpp
@@ -16,14 +16,14 @@
 
 namespace Web::PerformanceTimeline {
 
-JS_DEFINE_ALLOCATOR(PerformanceObserver);
+GC_DEFINE_ALLOCATOR(PerformanceObserver);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PerformanceObserver>> PerformanceObserver::construct_impl(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback)
+WebIDL::ExceptionOr<GC::Ref<PerformanceObserver>> PerformanceObserver::construct_impl(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback)
 {
     return realm.create<PerformanceObserver>(realm, callback);
 }
 
-PerformanceObserver::PerformanceObserver(JS::Realm& realm, JS::GCPtr<WebIDL::CallbackType> callback)
+PerformanceObserver::PerformanceObserver(JS::Realm& realm, GC::Ptr<WebIDL::CallbackType> callback)
     : Bindings::PlatformObject(realm)
     , m_callback(move(callback))
 {
@@ -207,10 +207,10 @@ void PerformanceObserver::disconnect()
 }
 
 // https://w3c.github.io/performance-timeline/#dom-performanceobserver-takerecords
-Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> PerformanceObserver::take_records()
+Vector<GC::Root<PerformanceTimeline::PerformanceEntry>> PerformanceObserver::take_records()
 {
     // The takeRecords() method must return a copy of this's observer buffer, and also empty this's observer buffer.
-    Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> records;
+    Vector<GC::Root<PerformanceTimeline::PerformanceEntry>> records;
     for (auto& record : m_observer_buffer)
         records.append(*record);
     m_observer_buffer.clear();
@@ -218,7 +218,7 @@ Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> PerformanceObserver::t
 }
 
 // https://w3c.github.io/performance-timeline/#dom-performanceobserver-supportedentrytypes
-JS::NonnullGCPtr<JS::Object> PerformanceObserver::supported_entry_types(JS::VM& vm)
+GC::Ref<JS::Object> PerformanceObserver::supported_entry_types(JS::VM& vm)
 {
     // 1. Let globalObject be the environment settings object's global object.
     auto* window_or_worker = dynamic_cast<HTML::WindowOrWorkerGlobalScopeMixin*>(&vm.get_global_object());
@@ -233,7 +233,7 @@ void PerformanceObserver::unset_requires_dropped_entries(Badge<HTML::WindowOrWor
     m_requires_dropped_entries = false;
 }
 
-void PerformanceObserver::append_to_observer_buffer(Badge<HTML::WindowOrWorkerGlobalScopeMixin>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry> entry)
+void PerformanceObserver::append_to_observer_buffer(Badge<HTML::WindowOrWorkerGlobalScopeMixin>, GC::Ref<PerformanceTimeline::PerformanceEntry> entry)
 {
     m_observer_buffer.append(entry);
 }
diff --git a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.h b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.h
index 3e440133612..b012a3802a7 100644
--- a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.h
+++ b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserver.h
@@ -21,7 +21,7 @@ struct PerformanceObserverInit {
 // https://w3c.github.io/performance-timeline/#dom-performanceobserver
 class PerformanceObserver final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PerformanceObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PerformanceObserver);
+    GC_DECLARE_ALLOCATOR(PerformanceObserver);
 
 public:
     enum class ObserverType {
@@ -30,12 +30,12 @@ public:
         Multiple,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PerformanceObserver>> construct_impl(JS::Realm&, JS::GCPtr<WebIDL::CallbackType>);
+    static WebIDL::ExceptionOr<GC::Ref<PerformanceObserver>> construct_impl(JS::Realm&, GC::Ptr<WebIDL::CallbackType>);
     virtual ~PerformanceObserver() override;
 
     WebIDL::ExceptionOr<void> observe(PerformanceObserverInit& options);
     void disconnect();
-    Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> take_records();
+    Vector<GC::Root<PerformanceTimeline::PerformanceEntry>> take_records();
 
     bool requires_dropped_entries() const { return m_requires_dropped_entries; }
     void unset_requires_dropped_entries(Badge<HTML::WindowOrWorkerGlobalScopeMixin>);
@@ -44,23 +44,23 @@ public:
 
     WebIDL::CallbackType& callback() { return *m_callback; }
 
-    void append_to_observer_buffer(Badge<HTML::WindowOrWorkerGlobalScopeMixin>, JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>);
+    void append_to_observer_buffer(Badge<HTML::WindowOrWorkerGlobalScopeMixin>, GC::Ref<PerformanceTimeline::PerformanceEntry>);
 
-    static JS::NonnullGCPtr<JS::Object> supported_entry_types(JS::VM&);
+    static GC::Ref<JS::Object> supported_entry_types(JS::VM&);
 
 private:
-    PerformanceObserver(JS::Realm&, JS::GCPtr<WebIDL::CallbackType>);
+    PerformanceObserver(JS::Realm&, GC::Ptr<WebIDL::CallbackType>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://w3c.github.io/performance-timeline/#dfn-observer-callback
     // A PerformanceObserverCallback observer callback set on creation.
-    JS::GCPtr<WebIDL::CallbackType> m_callback;
+    GC::Ptr<WebIDL::CallbackType> m_callback;
 
     // https://w3c.github.io/performance-timeline/#dfn-observer-buffer
     // A PerformanceEntryList object called the observer buffer that is initially empty.
-    Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>> m_observer_buffer;
+    Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>> m_observer_buffer;
 
     // https://w3c.github.io/performance-timeline/#dfn-observer-type
     // A DOMString observer type which is initially "undefined".
diff --git a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.cpp b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.cpp
index 21c7ea27b18..f6695084bf8 100644
--- a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.cpp
+++ b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::PerformanceTimeline {
 
-JS_DEFINE_ALLOCATOR(PerformanceObserverEntryList);
+GC_DEFINE_ALLOCATOR(PerformanceObserverEntryList);
 
-PerformanceObserverEntryList::PerformanceObserverEntryList(JS::Realm& realm, Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>>&& entry_list)
+PerformanceObserverEntryList::PerformanceObserverEntryList(JS::Realm& realm, Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>>&& entry_list)
     : Bindings::PlatformObject(realm)
     , m_entry_list(move(entry_list))
 {
@@ -36,10 +36,10 @@ void PerformanceObserverEntryList::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://www.w3.org/TR/performance-timeline/#dfn-filter-buffer-by-name-and-type
-ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> filter_buffer_by_name_and_type(Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>> const& buffer, Optional<String> name, Optional<String> type)
+ErrorOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> filter_buffer_by_name_and_type(Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>> const& buffer, Optional<String> name, Optional<String> type)
 {
     // 1. Let result be an initially empty list.
-    Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>> result;
+    Vector<GC::Root<PerformanceTimeline::PerformanceEntry>> result;
 
     // 2. For each PerformanceEntry entry in buffer, run the following steps:
     for (auto const& entry : buffer) {
@@ -65,7 +65,7 @@ ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> filter_buffer
 }
 
 // https://w3c.github.io/performance-timeline/#dom-performanceobserverentrylist-getentries
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries() const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries() const
 {
     // Returns a PerformanceEntryList object returned by filter buffer by name and type algorithm with this's entry list,
     // name and type set to null.
@@ -73,7 +73,7 @@ WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> P
 }
 
 // https://w3c.github.io/performance-timeline/#dom-performanceobserverentrylist-getentriesbytype
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries_by_type(String const& type) const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries_by_type(String const& type) const
 {
     // Returns a PerformanceEntryList object returned by filter buffer by name and type algorithm with this's entry list,
     // name set to null, and type set to the method's input type parameter.
@@ -81,7 +81,7 @@ WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> P
 }
 
 // https://w3c.github.io/performance-timeline/#dom-performanceobserverentrylist-getentriesbyname
-WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries_by_name(String const& name, Optional<String> type) const
+WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> PerformanceObserverEntryList::get_entries_by_name(String const& name, Optional<String> type) const
 {
     // Returns a PerformanceEntryList object returned by filter buffer by name and type algorithm with this's entry list,
     // name set to the method input name parameter, and type set to null if optional entryType is omitted, or set to the
diff --git a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.h b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.h
index 8aa66939ad9..6fe51cccf16 100644
--- a/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.h
+++ b/Libraries/LibWeb/PerformanceTimeline/PerformanceObserverEntryList.h
@@ -13,17 +13,17 @@ namespace Web::PerformanceTimeline {
 // https://w3c.github.io/performance-timeline/#performanceobserverentrylist-interface
 class PerformanceObserverEntryList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PerformanceObserverEntryList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PerformanceObserverEntryList);
+    GC_DECLARE_ALLOCATOR(PerformanceObserverEntryList);
 
 public:
     virtual ~PerformanceObserverEntryList() override;
 
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries() const;
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries_by_type(String const& type) const;
-    WebIDL::ExceptionOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> get_entries_by_name(String const& name, Optional<String> type) const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries() const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries_by_type(String const& type) const;
+    WebIDL::ExceptionOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> get_entries_by_name(String const& name, Optional<String> type) const;
 
 private:
-    PerformanceObserverEntryList(JS::Realm&, Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>>&&);
+    PerformanceObserverEntryList(JS::Realm&, Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>>&&);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -31,9 +31,9 @@ private:
     // https://w3c.github.io/performance-timeline/#dfn-entry-list
     // Returns a PerformanceEntryList object returned by filter buffer by name and type algorithm with this's entry list,
     // name and type set to null.
-    Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>> m_entry_list;
+    Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>> m_entry_list;
 };
 
-ErrorOr<Vector<JS::Handle<PerformanceTimeline::PerformanceEntry>>> filter_buffer_by_name_and_type(Vector<JS::NonnullGCPtr<PerformanceTimeline::PerformanceEntry>> const& buffer, Optional<String> name, Optional<String> type);
+ErrorOr<Vector<GC::Root<PerformanceTimeline::PerformanceEntry>>> filter_buffer_by_name_and_type(Vector<GC::Ref<PerformanceTimeline::PerformanceEntry>> const& buffer, Optional<String> name, Optional<String> type);
 
 }
diff --git a/Libraries/LibWeb/Platform/EventLoopPlugin.h b/Libraries/LibWeb/Platform/EventLoopPlugin.h
index 0ab9dc8f44e..4ec72a17d9c 100644
--- a/Libraries/LibWeb/Platform/EventLoopPlugin.h
+++ b/Libraries/LibWeb/Platform/EventLoopPlugin.h
@@ -7,8 +7,8 @@
 #pragma once
 
 #include <AK/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Platform {
@@ -20,9 +20,9 @@ public:
 
     virtual ~EventLoopPlugin();
 
-    virtual void spin_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition) = 0;
-    virtual void deferred_invoke(ESCAPING JS::Handle<JS::HeapFunction<void()>>) = 0;
-    virtual JS::NonnullGCPtr<Timer> create_timer(JS::Heap&) = 0;
+    virtual void spin_until(GC::Root<GC::Function<bool()>> goal_condition) = 0;
+    virtual void deferred_invoke(ESCAPING GC::Root<GC::Function<void()>>) = 0;
+    virtual GC::Ref<Timer> create_timer(GC::Heap&) = 0;
     virtual void quit() = 0;
 };
 
diff --git a/Libraries/LibWeb/Platform/EventLoopPluginSerenity.cpp b/Libraries/LibWeb/Platform/EventLoopPluginSerenity.cpp
index 721712bf98a..78ae1f550b9 100644
--- a/Libraries/LibWeb/Platform/EventLoopPluginSerenity.cpp
+++ b/Libraries/LibWeb/Platform/EventLoopPluginSerenity.cpp
@@ -14,14 +14,14 @@ namespace Web::Platform {
 EventLoopPluginSerenity::EventLoopPluginSerenity() = default;
 EventLoopPluginSerenity::~EventLoopPluginSerenity() = default;
 
-void EventLoopPluginSerenity::spin_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition)
+void EventLoopPluginSerenity::spin_until(GC::Root<GC::Function<bool()>> goal_condition)
 {
     Core::EventLoop::current().spin_until([goal_condition = move(goal_condition)]() {
         return goal_condition->function()();
     });
 }
 
-void EventLoopPluginSerenity::deferred_invoke(JS::Handle<JS::HeapFunction<void()>> function)
+void EventLoopPluginSerenity::deferred_invoke(GC::Root<GC::Function<void()>> function)
 {
     VERIFY(function);
     Core::deferred_invoke([function = move(function)]() {
@@ -29,7 +29,7 @@ void EventLoopPluginSerenity::deferred_invoke(JS::Handle<JS::HeapFunction<void()
     });
 }
 
-JS::NonnullGCPtr<Timer> EventLoopPluginSerenity::create_timer(JS::Heap& heap)
+GC::Ref<Timer> EventLoopPluginSerenity::create_timer(GC::Heap& heap)
 {
     return TimerSerenity::create(heap);
 }
diff --git a/Libraries/LibWeb/Platform/EventLoopPluginSerenity.h b/Libraries/LibWeb/Platform/EventLoopPluginSerenity.h
index 94b9048b402..0a88669a04b 100644
--- a/Libraries/LibWeb/Platform/EventLoopPluginSerenity.h
+++ b/Libraries/LibWeb/Platform/EventLoopPluginSerenity.h
@@ -15,9 +15,9 @@ public:
     EventLoopPluginSerenity();
     virtual ~EventLoopPluginSerenity() override;
 
-    virtual void spin_until(JS::Handle<JS::HeapFunction<bool()>> goal_condition) override;
-    virtual void deferred_invoke(JS::Handle<JS::HeapFunction<void()>>) override;
-    virtual JS::NonnullGCPtr<Timer> create_timer(JS::Heap&) override;
+    virtual void spin_until(GC::Root<GC::Function<bool()>> goal_condition) override;
+    virtual void deferred_invoke(GC::Root<GC::Function<void()>>) override;
+    virtual GC::Ref<Timer> create_timer(GC::Heap&) override;
     virtual void quit() override;
 };
 
diff --git a/Libraries/LibWeb/Platform/Timer.cpp b/Libraries/LibWeb/Platform/Timer.cpp
index 5f7c05f2666..8ec7758daa5 100644
--- a/Libraries/LibWeb/Platform/Timer.cpp
+++ b/Libraries/LibWeb/Platform/Timer.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibWeb/Platform/EventLoopPlugin.h>
 #include <LibWeb/Platform/Timer.h>
 
@@ -18,12 +18,12 @@ void Timer::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(on_timeout);
 }
 
-JS::NonnullGCPtr<Timer> Timer::create(JS::Heap& heap)
+GC::Ref<Timer> Timer::create(GC::Heap& heap)
 {
     return EventLoopPlugin::the().create_timer(heap);
 }
 
-JS::NonnullGCPtr<Timer> Timer::create_repeating(JS::Heap& heap, int interval_ms, JS::GCPtr<JS::HeapFunction<void()>> timeout_handler)
+GC::Ref<Timer> Timer::create_repeating(GC::Heap& heap, int interval_ms, GC::Ptr<GC::Function<void()>> timeout_handler)
 {
     auto timer = EventLoopPlugin::the().create_timer(heap);
     timer->set_single_shot(false);
@@ -32,7 +32,7 @@ JS::NonnullGCPtr<Timer> Timer::create_repeating(JS::Heap& heap, int interval_ms,
     return timer;
 }
 
-JS::NonnullGCPtr<Timer> Timer::create_single_shot(JS::Heap& heap, int interval_ms, JS::GCPtr<JS::HeapFunction<void()>> timeout_handler)
+GC::Ref<Timer> Timer::create_single_shot(GC::Heap& heap, int interval_ms, GC::Ptr<GC::Function<void()>> timeout_handler)
 {
     auto timer = EventLoopPlugin::the().create_timer(heap);
     timer->set_single_shot(true);
diff --git a/Libraries/LibWeb/Platform/Timer.h b/Libraries/LibWeb/Platform/Timer.h
index 502420a8557..9e1d974f8a1 100644
--- a/Libraries/LibWeb/Platform/Timer.h
+++ b/Libraries/LibWeb/Platform/Timer.h
@@ -12,12 +12,12 @@
 namespace Web::Platform {
 
 class Timer : public JS::Cell {
-    JS_CELL(Timer, JS::Cell);
+    GC_CELL(Timer, JS::Cell);
 
 public:
-    static JS::NonnullGCPtr<Timer> create(JS::Heap&);
-    static JS::NonnullGCPtr<Timer> create_repeating(JS::Heap&, int interval_ms, JS::GCPtr<JS::HeapFunction<void()>> timeout_handler);
-    static JS::NonnullGCPtr<Timer> create_single_shot(JS::Heap&, int interval_ms, JS::GCPtr<JS::HeapFunction<void()>> timeout_handler);
+    static GC::Ref<Timer> create(GC::Heap&);
+    static GC::Ref<Timer> create_repeating(GC::Heap&, int interval_ms, GC::Ptr<GC::Function<void()>> timeout_handler);
+    static GC::Ref<Timer> create_single_shot(GC::Heap&, int interval_ms, GC::Ptr<GC::Function<void()>> timeout_handler);
 
     virtual ~Timer();
 
@@ -36,7 +36,7 @@ public:
     virtual bool is_single_shot() const = 0;
     virtual void set_single_shot(bool) = 0;
 
-    JS::GCPtr<JS::HeapFunction<void()>> on_timeout;
+    GC::Ptr<GC::Function<void()>> on_timeout;
 
 protected:
     virtual void visit_edges(JS::Cell::Visitor&) override;
diff --git a/Libraries/LibWeb/Platform/TimerSerenity.cpp b/Libraries/LibWeb/Platform/TimerSerenity.cpp
index cd0d08025de..e72cb3bc86f 100644
--- a/Libraries/LibWeb/Platform/TimerSerenity.cpp
+++ b/Libraries/LibWeb/Platform/TimerSerenity.cpp
@@ -6,12 +6,12 @@
 
 #include "TimerSerenity.h"
 #include <LibCore/Timer.h>
-#include <LibJS/Heap/Heap.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
+#include <LibGC/Heap.h>
 
 namespace Web::Platform {
 
-JS::NonnullGCPtr<TimerSerenity> TimerSerenity::create(JS::Heap& heap)
+GC::Ref<TimerSerenity> TimerSerenity::create(GC::Heap& heap)
 {
     return heap.allocate<TimerSerenity>();
 }
diff --git a/Libraries/LibWeb/Platform/TimerSerenity.h b/Libraries/LibWeb/Platform/TimerSerenity.h
index 01fb83802e5..fe30e5fc155 100644
--- a/Libraries/LibWeb/Platform/TimerSerenity.h
+++ b/Libraries/LibWeb/Platform/TimerSerenity.h
@@ -12,10 +12,10 @@
 namespace Web::Platform {
 
 class TimerSerenity final : public Timer {
-    JS_CELL(TimerSerenity, Timer);
+    GC_CELL(TimerSerenity, Timer);
 
 public:
-    static JS::NonnullGCPtr<TimerSerenity> create(JS::Heap&);
+    static GC::Ref<TimerSerenity> create(GC::Heap&);
 
     virtual ~TimerSerenity();
 
diff --git a/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.cpp b/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.cpp
index 3e6b97bad4d..1b198bd39b8 100644
--- a/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.cpp
+++ b/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::RequestIdleCallback {
 
-JS_DEFINE_ALLOCATOR(IdleDeadline);
+GC_DEFINE_ALLOCATOR(IdleDeadline);
 
-JS::NonnullGCPtr<IdleDeadline> IdleDeadline::create(JS::Realm& realm, bool did_timeout)
+GC::Ref<IdleDeadline> IdleDeadline::create(JS::Realm& realm, bool did_timeout)
 {
     return realm.create<IdleDeadline>(realm, did_timeout);
 }
diff --git a/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.h b/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.h
index fb0772e2998..1521efa095f 100644
--- a/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.h
+++ b/Libraries/LibWeb/RequestIdleCallback/IdleDeadline.h
@@ -13,10 +13,10 @@ namespace Web::RequestIdleCallback {
 
 class IdleDeadline final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(IdleDeadline, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(IdleDeadline);
+    GC_DECLARE_ALLOCATOR(IdleDeadline);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<IdleDeadline> create(JS::Realm&, bool did_timeout = false);
+    [[nodiscard]] static GC::Ref<IdleDeadline> create(JS::Realm&, bool did_timeout = false);
     virtual ~IdleDeadline() override;
 
     double time_remaining() const;
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObservation.cpp b/Libraries/LibWeb/ResizeObserver/ResizeObservation.cpp
index 598598518fc..f312f7402ec 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObservation.cpp
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObservation.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/DOM/Element.h>
 #include <LibWeb/Painting/PaintableBox.h>
@@ -12,9 +12,9 @@
 
 namespace Web::ResizeObserver {
 
-JS_DEFINE_ALLOCATOR(ResizeObservation);
+GC_DEFINE_ALLOCATOR(ResizeObservation);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObservation>> ResizeObservation::create(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box)
+WebIDL::ExceptionOr<GC::Ref<ResizeObservation>> ResizeObservation::create(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box)
 {
     return realm.create<ResizeObservation>(realm, target, observed_box);
 }
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObservation.h b/Libraries/LibWeb/ResizeObserver/ResizeObservation.h
index 0beeb82ddc2..294aa4e9784 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObservation.h
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObservation.h
@@ -14,28 +14,28 @@ namespace Web::ResizeObserver {
 
 // https://drafts.csswg.org/resize-observer-1/#resize-observation-interface
 class ResizeObservation : public JS::Cell {
-    JS_CELL(ResizeObservation, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ResizeObservation);
+    GC_CELL(ResizeObservation, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ResizeObservation);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObservation>> create(JS::Realm&, DOM::Element&, Bindings::ResizeObserverBoxOptions);
+    static WebIDL::ExceptionOr<GC::Ref<ResizeObservation>> create(JS::Realm&, DOM::Element&, Bindings::ResizeObserverBoxOptions);
 
     bool is_active();
 
-    JS::NonnullGCPtr<DOM::Element> target() const { return m_target; }
+    GC::Ref<DOM::Element> target() const { return m_target; }
     Bindings::ResizeObserverBoxOptions observed_box() const { return m_observed_box; }
 
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>>& last_reported_sizes() { return m_last_reported_sizes; }
+    Vector<GC::Ref<ResizeObserverSize>>& last_reported_sizes() { return m_last_reported_sizes; }
 
     explicit ResizeObservation(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box);
 
 private:
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<DOM::Element> m_target;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<DOM::Element> m_target;
     Bindings::ResizeObserverBoxOptions m_observed_box;
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> m_last_reported_sizes;
+    Vector<GC::Ref<ResizeObserverSize>> m_last_reported_sizes;
 };
 
 }
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserver.cpp b/Libraries/LibWeb/ResizeObserver/ResizeObserver.cpp
index 4864922ff42..77bfc0aecc4 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserver.cpp
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserver.cpp
@@ -15,10 +15,10 @@
 
 namespace Web::ResizeObserver {
 
-JS_DEFINE_ALLOCATOR(ResizeObserver);
+GC_DEFINE_ALLOCATOR(ResizeObserver);
 
 // https://drafts.csswg.org/resize-observer/#dom-resizeobserver-resizeobserver
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObserver>> ResizeObserver::construct_impl(JS::Realm& realm, WebIDL::CallbackType* callback)
+WebIDL::ExceptionOr<GC::Ref<ResizeObserver>> ResizeObserver::construct_impl(JS::Realm& realm, WebIDL::CallbackType* callback)
 {
     return realm.create<ResizeObserver>(realm, callback);
 }
@@ -97,7 +97,7 @@ void ResizeObserver::disconnect()
     m_active_targets.clear();
 }
 
-void ResizeObserver::invoke_callback(ReadonlySpan<JS::NonnullGCPtr<ResizeObserverEntry>> entries) const
+void ResizeObserver::invoke_callback(ReadonlySpan<GC::Ref<ResizeObserverEntry>> entries) const
 {
     auto& callback = *m_callback;
     auto& realm = callback.callback_context->realm();
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserver.h b/Libraries/LibWeb/ResizeObserver/ResizeObserver.h
index 5eaa3132efb..b991c257ad6 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserver.h
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserver.h
@@ -20,10 +20,10 @@ struct ResizeObserverOptions {
 // https://drafts.csswg.org/resize-observer-1/#resize-observer-interface
 class ResizeObserver : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ResizeObserver, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ResizeObserver);
+    GC_DECLARE_ALLOCATOR(ResizeObserver);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObserver>> construct_impl(JS::Realm&, WebIDL::CallbackType* callback);
+    static WebIDL::ExceptionOr<GC::Ref<ResizeObserver>> construct_impl(JS::Realm&, WebIDL::CallbackType* callback);
 
     virtual ~ResizeObserver() override;
 
@@ -31,11 +31,11 @@ public:
     void unobserve(DOM::Element& target);
     void disconnect();
 
-    void invoke_callback(ReadonlySpan<JS::NonnullGCPtr<ResizeObserverEntry>> entries) const;
+    void invoke_callback(ReadonlySpan<GC::Ref<ResizeObserverEntry>> entries) const;
 
-    Vector<JS::NonnullGCPtr<ResizeObservation>>& observation_targets() { return m_observation_targets; }
-    Vector<JS::NonnullGCPtr<ResizeObservation>>& active_targets() { return m_active_targets; }
-    Vector<JS::NonnullGCPtr<ResizeObservation>>& skipped_targets() { return m_skipped_targets; }
+    Vector<GC::Ref<ResizeObservation>>& observation_targets() { return m_observation_targets; }
+    Vector<GC::Ref<ResizeObservation>>& active_targets() { return m_active_targets; }
+    Vector<GC::Ref<ResizeObservation>>& skipped_targets() { return m_skipped_targets; }
 
 private:
     explicit ResizeObserver(JS::Realm&, WebIDL::CallbackType* callback);
@@ -44,10 +44,10 @@ private:
     virtual void visit_edges(JS::Cell::Visitor&) override;
     virtual void finalize() override;
 
-    JS::GCPtr<WebIDL::CallbackType> m_callback;
-    Vector<JS::NonnullGCPtr<ResizeObservation>> m_observation_targets;
-    Vector<JS::NonnullGCPtr<ResizeObservation>> m_active_targets;
-    Vector<JS::NonnullGCPtr<ResizeObservation>> m_skipped_targets;
+    GC::Ptr<WebIDL::CallbackType> m_callback;
+    Vector<GC::Ref<ResizeObservation>> m_observation_targets;
+    Vector<GC::Ref<ResizeObservation>> m_active_targets;
+    Vector<GC::Ref<ResizeObservation>> m_skipped_targets;
 
     // AD-HOC: This is the document where we've registered the observer.
     WeakPtr<DOM::Document> m_document;
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.cpp b/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.cpp
index d2729978b17..504a3a9acdc 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.cpp
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/ResizeObserverEntryPrototype.h>
@@ -13,10 +13,10 @@
 
 namespace Web::ResizeObserver {
 
-JS_DEFINE_ALLOCATOR(ResizeObserverEntry);
+GC_DEFINE_ALLOCATOR(ResizeObserverEntry);
 
 // https://drafts.csswg.org/resize-observer-1/#create-and-populate-resizeobserverentry-h
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObserverEntry>> ResizeObserverEntry::create_and_populate(JS::Realm& realm, DOM::Element& target)
+WebIDL::ExceptionOr<GC::Ref<ResizeObserverEntry>> ResizeObserverEntry::create_and_populate(JS::Realm& realm, DOM::Element& target)
 {
     // 1. Let this be a new ResizeObserverEntry.
     // 2. Set this.target slot to target.
@@ -74,9 +74,9 @@ void ResizeObserverEntry::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_content_rect);
 }
 
-static JS::NonnullGCPtr<JS::Object> to_js_array(JS::Realm& realm, Vector<JS::NonnullGCPtr<ResizeObserverSize>> const& sizes)
+static GC::Ref<JS::Object> to_js_array(JS::Realm& realm, Vector<GC::Ref<ResizeObserverSize>> const& sizes)
 {
-    JS::MarkedVector<JS::Value> vector(realm.heap());
+    GC::MarkedVector<JS::Value> vector(realm.heap());
     for (auto const& size : sizes)
         vector.append(JS::Value(size.ptr()));
 
@@ -85,17 +85,17 @@ static JS::NonnullGCPtr<JS::Object> to_js_array(JS::Realm& realm, Vector<JS::Non
     return array;
 }
 
-JS::NonnullGCPtr<JS::Object> ResizeObserverEntry::border_box_size_js_array() const
+GC::Ref<JS::Object> ResizeObserverEntry::border_box_size_js_array() const
 {
     return to_js_array(realm(), m_border_box_size);
 }
 
-JS::NonnullGCPtr<JS::Object> ResizeObserverEntry::content_box_size_js_array() const
+GC::Ref<JS::Object> ResizeObserverEntry::content_box_size_js_array() const
 {
     return to_js_array(realm(), m_content_box_size);
 }
 
-JS::NonnullGCPtr<JS::Object> ResizeObserverEntry::device_pixel_content_box_size_js_array() const
+GC::Ref<JS::Object> ResizeObserverEntry::device_pixel_content_box_size_js_array() const
 {
     return to_js_array(realm(), m_device_pixel_content_box_size);
 }
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.h b/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.h
index 12aa1f80161..2070424872b 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.h
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserverEntry.h
@@ -18,21 +18,21 @@ namespace Web::ResizeObserver {
 // https://drafts.csswg.org/resize-observer-1/#resize-observer-entry-interface
 class ResizeObserverEntry : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ResizeObserverEntry, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ResizeObserverEntry);
+    GC_DECLARE_ALLOCATOR(ResizeObserverEntry);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ResizeObserverEntry>> create_and_populate(JS::Realm&, DOM::Element& target);
+    static WebIDL::ExceptionOr<GC::Ref<ResizeObserverEntry>> create_and_populate(JS::Realm&, DOM::Element& target);
 
-    JS::NonnullGCPtr<Geometry::DOMRectReadOnly> content_rect() const { return *m_content_rect; }
-    JS::NonnullGCPtr<DOM::Element> target() const { return m_target; }
+    GC::Ref<Geometry::DOMRectReadOnly> content_rect() const { return *m_content_rect; }
+    GC::Ref<DOM::Element> target() const { return m_target; }
 
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> const& border_box_size() const { return m_border_box_size; }
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> const& content_box_size() const { return m_content_box_size; }
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> const& device_pixel_content_box_size() const { return m_device_pixel_content_box_size; }
+    Vector<GC::Ref<ResizeObserverSize>> const& border_box_size() const { return m_border_box_size; }
+    Vector<GC::Ref<ResizeObserverSize>> const& content_box_size() const { return m_content_box_size; }
+    Vector<GC::Ref<ResizeObserverSize>> const& device_pixel_content_box_size() const { return m_device_pixel_content_box_size; }
 
-    JS::NonnullGCPtr<JS::Object> border_box_size_js_array() const;
-    JS::NonnullGCPtr<JS::Object> content_box_size_js_array() const;
-    JS::NonnullGCPtr<JS::Object> device_pixel_content_box_size_js_array() const;
+    GC::Ref<JS::Object> border_box_size_js_array() const;
+    GC::Ref<JS::Object> content_box_size_js_array() const;
+    GC::Ref<JS::Object> device_pixel_content_box_size_js_array() const;
 
 private:
     explicit ResizeObserverEntry(JS::Realm& realm, DOM::Element& target)
@@ -44,13 +44,13 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<DOM::Element> m_target;
+    GC::Ref<DOM::Element> m_target;
 
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> m_content_box_size;
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> m_border_box_size;
-    Vector<JS::NonnullGCPtr<ResizeObserverSize>> m_device_pixel_content_box_size;
+    Vector<GC::Ref<ResizeObserverSize>> m_content_box_size;
+    Vector<GC::Ref<ResizeObserverSize>> m_border_box_size;
+    Vector<GC::Ref<ResizeObserverSize>> m_device_pixel_content_box_size;
 
-    JS::GCPtr<Geometry::DOMRectReadOnly> m_content_rect;
+    GC::Ptr<Geometry::DOMRectReadOnly> m_content_rect;
 };
 
 }
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.cpp b/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.cpp
index 7e164e7dde5..cefb64bc2f0 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.cpp
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/Bindings/ResizeObserverSizePrototype.h>
 #include <LibWeb/HTML/Window.h>
 #include <LibWeb/Painting/PaintableBox.h>
@@ -12,7 +12,7 @@
 
 namespace Web::ResizeObserver {
 
-JS_DEFINE_ALLOCATOR(ResizeObserverSize);
+GC_DEFINE_ALLOCATOR(ResizeObserverSize);
 
 void ResizeObserverSize::initialize(JS::Realm& realm)
 {
@@ -21,7 +21,7 @@ void ResizeObserverSize::initialize(JS::Realm& realm)
 }
 
 // https://drafts.csswg.org/resize-observer-1/#calculate-box-size
-JS::NonnullGCPtr<ResizeObserverSize> ResizeObserverSize::calculate_box_size(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box)
+GC::Ref<ResizeObserverSize> ResizeObserverSize::calculate_box_size(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box)
 {
     // 1. Let computedSize be a new ResizeObserverSize object.
     auto computed_size = realm.create<ResizeObserverSize>(realm);
diff --git a/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.h b/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.h
index 3fa74feece1..f5f20a331c5 100644
--- a/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.h
+++ b/Libraries/LibWeb/ResizeObserver/ResizeObserverSize.h
@@ -14,10 +14,10 @@ namespace Web::ResizeObserver {
 // https://drafts.csswg.org/resize-observer-1/#resizeobserversize
 class ResizeObserverSize : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ResizeObserverSize, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ResizeObserverSize);
+    GC_DECLARE_ALLOCATOR(ResizeObserverSize);
 
 public:
-    static JS::NonnullGCPtr<ResizeObserverSize> calculate_box_size(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box);
+    static GC::Ref<ResizeObserverSize> calculate_box_size(JS::Realm& realm, DOM::Element& target, Bindings::ResizeObserverBoxOptions observed_box);
 
     double inline_size() const { return m_inline_size; }
     void set_inline_size(double inline_size) { m_inline_size = inline_size; }
diff --git a/Libraries/LibWeb/SVG/SVGAElement.cpp b/Libraries/LibWeb/SVG/SVGAElement.cpp
index 9afd2437545..dde6689671c 100644
--- a/Libraries/LibWeb/SVG/SVGAElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGAElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAElement);
+GC_DEFINE_ALLOCATOR(SVGAElement);
 
 SVGAElement::SVGAElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, move(qualified_name))
@@ -55,7 +55,7 @@ i32 SVGAElement::default_tab_index_value() const
 }
 
 // https://svgwg.org/svg2-draft/linking.html#__svg__SVGAElement__relList
-JS::NonnullGCPtr<DOM::DOMTokenList> SVGAElement::rel_list()
+GC::Ref<DOM::DOMTokenList> SVGAElement::rel_list()
 {
     // The relList IDL attribute reflects the ‘rel’ content attribute.
     if (!m_rel_list)
@@ -63,7 +63,7 @@ JS::NonnullGCPtr<DOM::DOMTokenList> SVGAElement::rel_list()
     return *m_rel_list;
 }
 
-JS::GCPtr<Layout::Node> SVGAElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGAElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGGraphicsBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGAElement.h b/Libraries/LibWeb/SVG/SVGAElement.h
index c0ea3160934..90f1b35c6ca 100644
--- a/Libraries/LibWeb/SVG/SVGAElement.h
+++ b/Libraries/LibWeb/SVG/SVGAElement.h
@@ -16,14 +16,14 @@ class SVGAElement final
     : public SVGGraphicsElement
     , public SVGURIReferenceMixin<SupportsXLinkHref::Yes> {
     WEB_PLATFORM_OBJECT(SVGAElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGAElement);
+    GC_DECLARE_ALLOCATOR(SVGAElement);
 
 public:
     virtual ~SVGAElement() override;
 
-    JS::NonnullGCPtr<DOM::DOMTokenList> rel_list();
+    GC::Ref<DOM::DOMTokenList> rel_list();
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
 private:
     SVGAElement(DOM::Document&, DOM::QualifiedName);
@@ -35,7 +35,7 @@ private:
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
     virtual i32 default_tab_index_value() const override;
 
-    JS::GCPtr<DOM::DOMTokenList> m_rel_list;
+    GC::Ptr<DOM::DOMTokenList> m_rel_list;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedLength.cpp b/Libraries/LibWeb/SVG/SVGAnimatedLength.cpp
index faeba958e8c..2f8e2487264 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedLength.cpp
+++ b/Libraries/LibWeb/SVG/SVGAnimatedLength.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAnimatedLength);
+GC_DEFINE_ALLOCATOR(SVGAnimatedLength);
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGAnimatedLength::create(JS::Realm& realm, JS::NonnullGCPtr<SVGLength> base_val, JS::NonnullGCPtr<SVGLength> anim_val)
+GC::Ref<SVGAnimatedLength> SVGAnimatedLength::create(JS::Realm& realm, GC::Ref<SVGLength> base_val, GC::Ref<SVGLength> anim_val)
 {
     return realm.create<SVGAnimatedLength>(realm, move(base_val), move(anim_val));
 }
 
-SVGAnimatedLength::SVGAnimatedLength(JS::Realm& realm, JS::NonnullGCPtr<SVGLength> base_val, JS::NonnullGCPtr<SVGLength> anim_val)
+SVGAnimatedLength::SVGAnimatedLength(JS::Realm& realm, GC::Ref<SVGLength> base_val, GC::Ref<SVGLength> anim_val)
     : PlatformObject(realm)
     , m_base_val(move(base_val))
     , m_anim_val(move(anim_val))
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedLength.h b/Libraries/LibWeb/SVG/SVGAnimatedLength.h
index 75f6f35895f..e1d269e1598 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedLength.h
+++ b/Libraries/LibWeb/SVG/SVGAnimatedLength.h
@@ -14,23 +14,23 @@ namespace Web::SVG {
 // https://www.w3.org/TR/SVG11/types.html#InterfaceSVGAnimatedLength
 class SVGAnimatedLength final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGAnimatedLength, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGAnimatedLength);
+    GC_DECLARE_ALLOCATOR(SVGAnimatedLength);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGAnimatedLength> create(JS::Realm&, JS::NonnullGCPtr<SVGLength> base_val, JS::NonnullGCPtr<SVGLength> anim_val);
+    [[nodiscard]] static GC::Ref<SVGAnimatedLength> create(JS::Realm&, GC::Ref<SVGLength> base_val, GC::Ref<SVGLength> anim_val);
     virtual ~SVGAnimatedLength() override;
 
-    JS::NonnullGCPtr<SVGLength> base_val() const { return m_base_val; }
-    JS::NonnullGCPtr<SVGLength> anim_val() const { return m_anim_val; }
+    GC::Ref<SVGLength> base_val() const { return m_base_val; }
+    GC::Ref<SVGLength> anim_val() const { return m_anim_val; }
 
 private:
-    SVGAnimatedLength(JS::Realm&, JS::NonnullGCPtr<SVGLength> base_val, JS::NonnullGCPtr<SVGLength> anim_val);
+    SVGAnimatedLength(JS::Realm&, GC::Ref<SVGLength> base_val, GC::Ref<SVGLength> anim_val);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<SVGLength> m_base_val;
-    JS::NonnullGCPtr<SVGLength> m_anim_val;
+    GC::Ref<SVGLength> m_base_val;
+    GC::Ref<SVGLength> m_anim_val;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedNumber.cpp b/Libraries/LibWeb/SVG/SVGAnimatedNumber.cpp
index 5196dbeaa10..8fff1c7a714 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedNumber.cpp
+++ b/Libraries/LibWeb/SVG/SVGAnimatedNumber.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAnimatedNumber);
+GC_DEFINE_ALLOCATOR(SVGAnimatedNumber);
 
-JS::NonnullGCPtr<SVGAnimatedNumber> SVGAnimatedNumber::create(JS::Realm& realm, float base_val, float anim_val)
+GC::Ref<SVGAnimatedNumber> SVGAnimatedNumber::create(JS::Realm& realm, float base_val, float anim_val)
 {
     return realm.create<SVGAnimatedNumber>(realm, base_val, anim_val);
 }
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedNumber.h b/Libraries/LibWeb/SVG/SVGAnimatedNumber.h
index f3f84161f06..8d29ad31a67 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedNumber.h
+++ b/Libraries/LibWeb/SVG/SVGAnimatedNumber.h
@@ -14,10 +14,10 @@ namespace Web::SVG {
 // https://www.w3.org/TR/SVG11/types.html#InterfaceSVGAnimatedNumber
 class SVGAnimatedNumber final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGAnimatedNumber, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGAnimatedNumber);
+    GC_DECLARE_ALLOCATOR(SVGAnimatedNumber);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGAnimatedNumber> create(JS::Realm&, float base_val, float anim_val);
+    [[nodiscard]] static GC::Ref<SVGAnimatedNumber> create(JS::Realm&, float base_val, float anim_val);
     virtual ~SVGAnimatedNumber() override;
 
     float base_val() const { return m_base_val; }
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedRect.cpp b/Libraries/LibWeb/SVG/SVGAnimatedRect.cpp
index e689fe197c6..a3396d9a5bb 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedRect.cpp
+++ b/Libraries/LibWeb/SVG/SVGAnimatedRect.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAnimatedRect);
+GC_DEFINE_ALLOCATOR(SVGAnimatedRect);
 
 SVGAnimatedRect::SVGAnimatedRect(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -35,14 +35,14 @@ void SVGAnimatedRect::visit_edges(Visitor& visitor)
     visitor.visit(m_anim_val);
 }
 
-JS::GCPtr<Geometry::DOMRect> SVGAnimatedRect::base_val() const
+GC::Ptr<Geometry::DOMRect> SVGAnimatedRect::base_val() const
 {
     if (m_nulled)
         return nullptr;
     return m_base_val;
 }
 
-JS::GCPtr<Geometry::DOMRect> SVGAnimatedRect::anim_val() const
+GC::Ptr<Geometry::DOMRect> SVGAnimatedRect::anim_val() const
 {
     if (m_nulled)
         return nullptr;
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedRect.h b/Libraries/LibWeb/SVG/SVGAnimatedRect.h
index 7dfe86ce179..28e20055da6 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedRect.h
+++ b/Libraries/LibWeb/SVG/SVGAnimatedRect.h
@@ -13,13 +13,13 @@ namespace Web::SVG {
 
 class SVGAnimatedRect final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGAnimatedRect, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGAnimatedRect);
+    GC_DECLARE_ALLOCATOR(SVGAnimatedRect);
 
 public:
     virtual ~SVGAnimatedRect();
 
-    JS::GCPtr<Geometry::DOMRect> base_val() const;
-    JS::GCPtr<Geometry::DOMRect> anim_val() const;
+    GC::Ptr<Geometry::DOMRect> base_val() const;
+    GC::Ptr<Geometry::DOMRect> anim_val() const;
 
     void set_base_val(Gfx::DoubleRect const&);
     void set_anim_val(Gfx::DoubleRect const&);
@@ -32,8 +32,8 @@ private:
 
     explicit SVGAnimatedRect(JS::Realm&);
 
-    JS::GCPtr<Geometry::DOMRect> m_base_val;
-    JS::GCPtr<Geometry::DOMRect> m_anim_val;
+    GC::Ptr<Geometry::DOMRect> m_base_val;
+    GC::Ptr<Geometry::DOMRect> m_anim_val;
 
     bool m_nulled { true };
 };
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedString.cpp b/Libraries/LibWeb/SVG/SVGAnimatedString.cpp
index 5949b0dbb1e..d4e64a11919 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedString.cpp
+++ b/Libraries/LibWeb/SVG/SVGAnimatedString.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/Realm.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/Bindings/SVGAnimatedStringPrototype.h>
@@ -13,14 +13,14 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAnimatedString);
+GC_DEFINE_ALLOCATOR(SVGAnimatedString);
 
-JS::NonnullGCPtr<SVGAnimatedString> SVGAnimatedString::create(JS::Realm& realm, JS::NonnullGCPtr<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value)
+GC::Ref<SVGAnimatedString> SVGAnimatedString::create(JS::Realm& realm, GC::Ref<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value)
 {
     return realm.create<SVGAnimatedString>(realm, element, move(reflected_attribute), move(deprecated_reflected_attribute), move(initial_value));
 }
 
-SVGAnimatedString::SVGAnimatedString(JS::Realm& realm, JS::NonnullGCPtr<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value)
+SVGAnimatedString::SVGAnimatedString(JS::Realm& realm, GC::Ref<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value)
     : Bindings::PlatformObject(realm)
     , m_element(element)
     , m_reflected_attribute(move(reflected_attribute))
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedString.h b/Libraries/LibWeb/SVG/SVGAnimatedString.h
index b64777d27b1..eb365f7faea 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedString.h
+++ b/Libraries/LibWeb/SVG/SVGAnimatedString.h
@@ -14,22 +14,22 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/types.html#InterfaceSVGAnimatedString
 class SVGAnimatedString final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGAnimatedString, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGAnimatedString);
+    GC_DECLARE_ALLOCATOR(SVGAnimatedString);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGAnimatedString> create(JS::Realm&, JS::NonnullGCPtr<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute = {}, Optional<FlyString> initial_value = {});
+    [[nodiscard]] static GC::Ref<SVGAnimatedString> create(JS::Realm&, GC::Ref<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute = {}, Optional<FlyString> initial_value = {});
     virtual ~SVGAnimatedString() override;
 
     String base_val() const;
     void set_base_val(String const& base_val);
 
 private:
-    SVGAnimatedString(JS::Realm&, JS::NonnullGCPtr<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value);
+    SVGAnimatedString(JS::Realm&, GC::Ref<SVGElement> element, FlyString reflected_attribute, Optional<FlyString> deprecated_reflected_attribute, Optional<FlyString> initial_value);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<SVGElement> m_element;
+    GC::Ref<SVGElement> m_element;
     FlyString m_reflected_attribute;
     Optional<FlyString> m_deprecated_reflected_attribute;
     Optional<FlyString> m_initial_value;
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedTransformList.cpp b/Libraries/LibWeb/SVG/SVGAnimatedTransformList.cpp
index 012a5e7e352..89a07fd9c49 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedTransformList.cpp
+++ b/Libraries/LibWeb/SVG/SVGAnimatedTransformList.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGAnimatedTransformList);
+GC_DEFINE_ALLOCATOR(SVGAnimatedTransformList);
 
-JS::NonnullGCPtr<SVGAnimatedTransformList> SVGAnimatedTransformList::create(JS::Realm& realm, JS::NonnullGCPtr<SVGTransformList> base_val, JS::NonnullGCPtr<SVGTransformList> anim_val)
+GC::Ref<SVGAnimatedTransformList> SVGAnimatedTransformList::create(JS::Realm& realm, GC::Ref<SVGTransformList> base_val, GC::Ref<SVGTransformList> anim_val)
 {
     return realm.create<SVGAnimatedTransformList>(realm, base_val, anim_val);
 }
 
-SVGAnimatedTransformList::SVGAnimatedTransformList(JS::Realm& realm, JS::NonnullGCPtr<SVGTransformList> base_val, JS::NonnullGCPtr<SVGTransformList> anim_val)
+SVGAnimatedTransformList::SVGAnimatedTransformList(JS::Realm& realm, GC::Ref<SVGTransformList> base_val, GC::Ref<SVGTransformList> anim_val)
     : PlatformObject(realm)
     , m_base_val(base_val)
     , m_anim_val(anim_val) {};
diff --git a/Libraries/LibWeb/SVG/SVGAnimatedTransformList.h b/Libraries/LibWeb/SVG/SVGAnimatedTransformList.h
index c3aa4c1e91f..cc96559606c 100644
--- a/Libraries/LibWeb/SVG/SVGAnimatedTransformList.h
+++ b/Libraries/LibWeb/SVG/SVGAnimatedTransformList.h
@@ -14,30 +14,30 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/single-page.html#coords-InterfaceSVGTransformList
 class SVGAnimatedTransformList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGAnimatedTransformList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGAnimatedTransformList);
+    GC_DECLARE_ALLOCATOR(SVGAnimatedTransformList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGAnimatedTransformList> create(JS::Realm& realm, JS::NonnullGCPtr<SVGTransformList> base_val, JS::NonnullGCPtr<SVGTransformList> anim_val);
+    [[nodiscard]] static GC::Ref<SVGAnimatedTransformList> create(JS::Realm& realm, GC::Ref<SVGTransformList> base_val, GC::Ref<SVGTransformList> anim_val);
     virtual ~SVGAnimatedTransformList() override;
 
-    JS::NonnullGCPtr<SVGTransformList> base_val() const
+    GC::Ref<SVGTransformList> base_val() const
     {
         return m_anim_val;
     }
 
-    JS::NonnullGCPtr<SVGTransformList> anim_val() const
+    GC::Ref<SVGTransformList> anim_val() const
     {
         return m_anim_val;
     }
 
 private:
-    SVGAnimatedTransformList(JS::Realm& realm, JS::NonnullGCPtr<SVGTransformList> base_val, JS::NonnullGCPtr<SVGTransformList> anim_val);
+    SVGAnimatedTransformList(JS::Realm& realm, GC::Ref<SVGTransformList> base_val, GC::Ref<SVGTransformList> anim_val);
 
     virtual void initialize(JS::Realm& realm) override;
     virtual void visit_edges(Cell::Visitor& visitor) override;
 
-    JS::NonnullGCPtr<SVGTransformList> m_base_val;
-    JS::NonnullGCPtr<SVGTransformList> m_anim_val;
+    GC::Ref<SVGTransformList> m_base_val;
+    GC::Ref<SVGTransformList> m_anim_val;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGCircleElement.cpp b/Libraries/LibWeb/SVG/SVGCircleElement.cpp
index 64a6c5087e8..f0224371eb7 100644
--- a/Libraries/LibWeb/SVG/SVGCircleElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGCircleElement.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGCircleElement);
+GC_DEFINE_ALLOCATOR(SVGCircleElement);
 
 SVGCircleElement::SVGCircleElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
@@ -83,19 +83,19 @@ Gfx::Path SVGCircleElement::get_path(CSSPixelSize viewport_size)
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#CircleElementCXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGCircleElement::cx() const
+GC::Ref<SVGAnimatedLength> SVGCircleElement::cx() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::Cx);
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#CircleElementCYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGCircleElement::cy() const
+GC::Ref<SVGAnimatedLength> SVGCircleElement::cy() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::Cy);
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#CircleElementRAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGCircleElement::r() const
+GC::Ref<SVGAnimatedLength> SVGCircleElement::r() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::R);
 }
diff --git a/Libraries/LibWeb/SVG/SVGCircleElement.h b/Libraries/LibWeb/SVG/SVGCircleElement.h
index d8c3e0af9b7..f734f15c08c 100644
--- a/Libraries/LibWeb/SVG/SVGCircleElement.h
+++ b/Libraries/LibWeb/SVG/SVGCircleElement.h
@@ -13,7 +13,7 @@ namespace Web::SVG {
 
 class SVGCircleElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGCircleElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGCircleElement);
+    GC_DECLARE_ALLOCATOR(SVGCircleElement);
 
 public:
     virtual ~SVGCircleElement() override = default;
@@ -22,9 +22,9 @@ public:
 
     virtual Gfx::Path get_path(CSSPixelSize viewport_size) override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> cx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> cy() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> r() const;
+    GC::Ref<SVGAnimatedLength> cx() const;
+    GC::Ref<SVGAnimatedLength> cy() const;
+    GC::Ref<SVGAnimatedLength> r() const;
 
 private:
     SVGCircleElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGClipPathElement.cpp b/Libraries/LibWeb/SVG/SVGClipPathElement.cpp
index 532c0e21092..15c0700cbf8 100644
--- a/Libraries/LibWeb/SVG/SVGClipPathElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGClipPathElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGClipPathElement);
+GC_DEFINE_ALLOCATOR(SVGClipPathElement);
 
 SVGClipPathElement::SVGClipPathElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
@@ -36,7 +36,7 @@ void SVGClipPathElement::attribute_changed(FlyString const& name, Optional<Strin
         m_clip_path_units = AttributeParser::parse_units(value.value_or(String {}));
 }
 
-JS::GCPtr<Layout::Node> SVGClipPathElement::create_layout_node(CSS::StyleProperties)
+GC::Ptr<Layout::Node> SVGClipPathElement::create_layout_node(CSS::StyleProperties)
 {
     // Clip paths are handled as a special case in the TreeBuilder.
     return nullptr;
diff --git a/Libraries/LibWeb/SVG/SVGClipPathElement.h b/Libraries/LibWeb/SVG/SVGClipPathElement.h
index e56faf087fa..cbf8817fe3b 100644
--- a/Libraries/LibWeb/SVG/SVGClipPathElement.h
+++ b/Libraries/LibWeb/SVG/SVGClipPathElement.h
@@ -15,7 +15,7 @@ namespace Web::SVG {
 class SVGClipPathElement final : public SVGElement
     , public SVGViewport {
     WEB_PLATFORM_OBJECT(SVGClipPathElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGClipPathElement);
+    GC_DECLARE_ALLOCATOR(SVGClipPathElement);
 
 public:
     virtual ~SVGClipPathElement();
@@ -40,7 +40,7 @@ public:
         return m_clip_path_units.value_or(ClipPathUnits::UserSpaceOnUse);
     }
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
 private:
     SVGClipPathElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGDecodedImageData.cpp b/Libraries/LibWeb/SVG/SVGDecodedImageData.cpp
index bda3aa5d447..03fbc209156 100644
--- a/Libraries/LibWeb/SVG/SVGDecodedImageData.cpp
+++ b/Libraries/LibWeb/SVG/SVGDecodedImageData.cpp
@@ -23,16 +23,16 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGDecodedImageData);
-JS_DEFINE_ALLOCATOR(SVGDecodedImageData::SVGPageClient);
+GC_DEFINE_ALLOCATOR(SVGDecodedImageData);
+GC_DEFINE_ALLOCATOR(SVGDecodedImageData::SVGPageClient);
 
-ErrorOr<JS::NonnullGCPtr<SVGDecodedImageData>> SVGDecodedImageData::create(JS::Realm& realm, JS::NonnullGCPtr<Page> host_page, URL::URL const& url, ByteBuffer data)
+ErrorOr<GC::Ref<SVGDecodedImageData>> SVGDecodedImageData::create(JS::Realm& realm, GC::Ref<Page> host_page, URL::URL const& url, ByteBuffer data)
 {
     auto page_client = SVGPageClient::create(Bindings::main_thread_vm(), host_page);
     auto page = Page::create(Bindings::main_thread_vm(), *page_client);
     page_client->m_svg_page = page.ptr();
     page->set_top_level_traversable(MUST(Web::HTML::TraversableNavigable::create_a_new_top_level_traversable(*page, nullptr, {})));
-    JS::NonnullGCPtr<HTML::Navigable> navigable = page->top_level_traversable();
+    GC::Ref<HTML::Navigable> navigable = page->top_level_traversable();
     auto response = Fetch::Infrastructure::Response::create(navigable->vm());
     response->url_list().append(url);
     auto navigation_params = navigable->heap().allocate<HTML::NavigationParams>();
@@ -66,7 +66,7 @@ ErrorOr<JS::NonnullGCPtr<SVGDecodedImageData>> SVGDecodedImageData::create(JS::R
     return realm.create<SVGDecodedImageData>(page, page_client, document, *svg_root);
 }
 
-SVGDecodedImageData::SVGDecodedImageData(JS::NonnullGCPtr<Page> page, JS::NonnullGCPtr<SVGPageClient> page_client, JS::NonnullGCPtr<DOM::Document> document, JS::NonnullGCPtr<SVG::SVGSVGElement> root_element)
+SVGDecodedImageData::SVGDecodedImageData(GC::Ref<Page> page, GC::Ref<SVGPageClient> page_client, GC::Ref<DOM::Document> document, GC::Ref<SVG::SVGSVGElement> root_element)
     : m_page(page)
     , m_page_client(page_client)
     , m_document(document)
diff --git a/Libraries/LibWeb/SVG/SVGDecodedImageData.h b/Libraries/LibWeb/SVG/SVGDecodedImageData.h
index ceabca2d1ed..cabe0683739 100644
--- a/Libraries/LibWeb/SVG/SVGDecodedImageData.h
+++ b/Libraries/LibWeb/SVG/SVGDecodedImageData.h
@@ -13,12 +13,12 @@
 namespace Web::SVG {
 
 class SVGDecodedImageData final : public HTML::DecodedImageData {
-    JS_CELL(SVGDecodedImageData, HTML::DecodedImageData);
-    JS_DECLARE_ALLOCATOR(SVGDecodedImageData);
+    GC_CELL(SVGDecodedImageData, HTML::DecodedImageData);
+    GC_DECLARE_ALLOCATOR(SVGDecodedImageData);
 
 public:
     class SVGPageClient;
-    static ErrorOr<JS::NonnullGCPtr<SVGDecodedImageData>> create(JS::Realm&, JS::NonnullGCPtr<Page>, URL::URL const&, ByteBuffer encoded_svg);
+    static ErrorOr<GC::Ref<SVGDecodedImageData>> create(JS::Realm&, GC::Ref<Page>, URL::URL const&, ByteBuffer encoded_svg);
     virtual ~SVGDecodedImageData() override;
 
     virtual RefPtr<Gfx::ImmutableBitmap> bitmap(size_t frame_index, Gfx::IntSize) const override;
@@ -38,33 +38,33 @@ public:
     virtual void visit_edges(Cell::Visitor& visitor) override;
 
 private:
-    SVGDecodedImageData(JS::NonnullGCPtr<Page>, JS::NonnullGCPtr<SVGPageClient>, JS::NonnullGCPtr<DOM::Document>, JS::NonnullGCPtr<SVG::SVGSVGElement>);
+    SVGDecodedImageData(GC::Ref<Page>, GC::Ref<SVGPageClient>, GC::Ref<DOM::Document>, GC::Ref<SVG::SVGSVGElement>);
 
     RefPtr<Gfx::Bitmap> render(Gfx::IntSize) const;
 
     mutable HashMap<Gfx::IntSize, NonnullRefPtr<Gfx::ImmutableBitmap>> m_cached_rendered_bitmaps;
 
-    JS::NonnullGCPtr<Page> m_page;
-    JS::NonnullGCPtr<SVGPageClient> m_page_client;
+    GC::Ref<Page> m_page;
+    GC::Ref<SVGPageClient> m_page_client;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
-    JS::NonnullGCPtr<SVG::SVGSVGElement> m_root_element;
+    GC::Ref<DOM::Document> m_document;
+    GC::Ref<SVG::SVGSVGElement> m_root_element;
 };
 
 class SVGDecodedImageData::SVGPageClient final : public PageClient {
-    JS_CELL(SVGDecodedImageData::SVGPageClient, PageClient);
-    JS_DECLARE_ALLOCATOR(SVGDecodedImageData::SVGPageClient);
+    GC_CELL(SVGDecodedImageData::SVGPageClient, PageClient);
+    GC_DECLARE_ALLOCATOR(SVGDecodedImageData::SVGPageClient);
 
 public:
-    static JS::NonnullGCPtr<SVGPageClient> create(JS::VM& vm, Page& page)
+    static GC::Ref<SVGPageClient> create(JS::VM& vm, Page& page)
     {
         return vm.heap().allocate<SVGPageClient>(page);
     }
 
     virtual ~SVGPageClient() override = default;
 
-    JS::NonnullGCPtr<Page> m_host_page;
-    JS::GCPtr<Page> m_svg_page;
+    GC::Ref<Page> m_host_page;
+    GC::Ptr<Page> m_svg_page;
 
     virtual Page& page() override { return *m_svg_page; }
     virtual Page const& page() const override { return *m_svg_page; }
diff --git a/Libraries/LibWeb/SVG/SVGDefsElement.cpp b/Libraries/LibWeb/SVG/SVGDefsElement.cpp
index db7e9cfa1dd..3aacff4cb52 100644
--- a/Libraries/LibWeb/SVG/SVGDefsElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGDefsElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGDefsElement);
+GC_DEFINE_ALLOCATOR(SVGDefsElement);
 
 SVGDefsElement::SVGDefsElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/SVG/SVGDefsElement.h b/Libraries/LibWeb/SVG/SVGDefsElement.h
index e23149d081e..718f4ad05eb 100644
--- a/Libraries/LibWeb/SVG/SVGDefsElement.h
+++ b/Libraries/LibWeb/SVG/SVGDefsElement.h
@@ -12,12 +12,12 @@ namespace Web::SVG {
 
 class SVGDefsElement final : public SVGGraphicsElement {
     WEB_PLATFORM_OBJECT(SVGDefsElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGDefsElement);
+    GC_DECLARE_ALLOCATOR(SVGDefsElement);
 
 public:
     virtual ~SVGDefsElement();
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override
     {
         return nullptr;
     }
diff --git a/Libraries/LibWeb/SVG/SVGDescElement.cpp b/Libraries/LibWeb/SVG/SVGDescElement.cpp
index 827d9f20903..ad9fcc64afb 100644
--- a/Libraries/LibWeb/SVG/SVGDescElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGDescElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGDescElement);
+GC_DEFINE_ALLOCATOR(SVGDescElement);
 
 SVGDescElement::SVGDescElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
@@ -25,7 +25,7 @@ void SVGDescElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGDescElement);
 }
 
-JS::GCPtr<Layout::Node> SVGDescElement::create_layout_node(CSS::StyleProperties)
+GC::Ptr<Layout::Node> SVGDescElement::create_layout_node(CSS::StyleProperties)
 {
     return nullptr;
 }
diff --git a/Libraries/LibWeb/SVG/SVGDescElement.h b/Libraries/LibWeb/SVG/SVGDescElement.h
index a818fb46c55..8f5985ab801 100644
--- a/Libraries/LibWeb/SVG/SVGDescElement.h
+++ b/Libraries/LibWeb/SVG/SVGDescElement.h
@@ -12,14 +12,14 @@ namespace Web::SVG {
 
 class SVGDescElement final : public SVGElement {
     WEB_PLATFORM_OBJECT(SVGDescElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGDescElement);
+    GC_DECLARE_ALLOCATOR(SVGDescElement);
 
 private:
     SVGDescElement(DOM::Document&, DOM::QualifiedName);
 
     virtual void initialize(JS::Realm&) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGElement.cpp b/Libraries/LibWeb/SVG/SVGElement.cpp
index ee395b3bfa8..46b8f32c5c4 100644
--- a/Libraries/LibWeb/SVG/SVGElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGElement.cpp
@@ -108,7 +108,7 @@ void SVGElement::remove_from_use_element_that_reference_this()
 }
 
 // https://svgwg.org/svg2-draft/types.html#__svg__SVGElement__classNames
-JS::NonnullGCPtr<SVGAnimatedString> SVGElement::class_name()
+GC::Ref<SVGAnimatedString> SVGElement::class_name()
 {
     // The className IDL attribute reflects the ‘class’ attribute.
     if (!m_class_name_animated_string)
@@ -118,7 +118,7 @@ JS::NonnullGCPtr<SVGAnimatedString> SVGElement::class_name()
 }
 
 // https://svgwg.org/svg2-draft/types.html#__svg__SVGElement__ownerSVGElement
-JS::GCPtr<SVGSVGElement> SVGElement::owner_svg_element()
+GC::Ptr<SVGSVGElement> SVGElement::owner_svg_element()
 {
     // The ownerSVGElement IDL attribute represents the nearest ancestor ‘svg’ element.
     // On getting ownerSVGElement, the nearest ancestor ‘svg’ element is returned;
@@ -126,7 +126,7 @@ JS::GCPtr<SVGSVGElement> SVGElement::owner_svg_element()
     return shadow_including_first_ancestor_of_type<SVGSVGElement>();
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGElement::svg_animated_length_for_property(CSS::PropertyID property) const
+GC::Ref<SVGAnimatedLength> SVGElement::svg_animated_length_for_property(CSS::PropertyID property) const
 {
     // FIXME: Create a proper animated value when animations are supported.
     auto make_length = [&] {
diff --git a/Libraries/LibWeb/SVG/SVGElement.h b/Libraries/LibWeb/SVG/SVGElement.h
index 952e71b99c4..357a041b4ff 100644
--- a/Libraries/LibWeb/SVG/SVGElement.h
+++ b/Libraries/LibWeb/SVG/SVGElement.h
@@ -22,8 +22,8 @@ class SVGElement
 public:
     virtual bool requires_svg_container() const override { return true; }
 
-    JS::NonnullGCPtr<SVGAnimatedString> class_name();
-    JS::GCPtr<SVGSVGElement> owner_svg_element();
+    GC::Ref<SVGAnimatedString> class_name();
+    GC::Ptr<SVGSVGElement> owner_svg_element();
 
 protected:
     SVGElement(DOM::Document&, DOM::QualifiedName);
@@ -40,15 +40,15 @@ protected:
     void update_use_elements_that_reference_this();
     void remove_from_use_element_that_reference_this();
 
-    JS::NonnullGCPtr<SVGAnimatedLength> svg_animated_length_for_property(CSS::PropertyID) const;
+    GC::Ref<SVGAnimatedLength> svg_animated_length_for_property(CSS::PropertyID) const;
 
 private:
     // ^HTML::GlobalEventHandlers
-    virtual JS::GCPtr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
+    virtual GC::Ptr<DOM::EventTarget> global_event_handlers_to_event_target(FlyString const&) override { return *this; }
 
     virtual bool is_svg_element() const final { return true; }
 
-    JS::GCPtr<SVGAnimatedString> m_class_name_animated_string;
+    GC::Ptr<SVGAnimatedString> m_class_name_animated_string;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGEllipseElement.cpp b/Libraries/LibWeb/SVG/SVGEllipseElement.cpp
index 4d07d7858b8..9cc75806648 100644
--- a/Libraries/LibWeb/SVG/SVGEllipseElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGEllipseElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGEllipseElement);
+GC_DEFINE_ALLOCATOR(SVGEllipseElement);
 
 SVGEllipseElement::SVGEllipseElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
@@ -77,7 +77,7 @@ Gfx::Path SVGEllipseElement::get_path(CSSPixelSize)
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#EllipseElementCXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::cx() const
+GC::Ref<SVGAnimatedLength> SVGEllipseElement::cx() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -87,7 +87,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::cx() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#EllipseElementCYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::cy() const
+GC::Ref<SVGAnimatedLength> SVGEllipseElement::cy() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -97,7 +97,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::cy() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#EllipseElementRXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::rx() const
+GC::Ref<SVGAnimatedLength> SVGEllipseElement::rx() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -107,7 +107,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::rx() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#EllipseElementRYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGEllipseElement::ry() const
+GC::Ref<SVGAnimatedLength> SVGEllipseElement::ry() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
diff --git a/Libraries/LibWeb/SVG/SVGEllipseElement.h b/Libraries/LibWeb/SVG/SVGEllipseElement.h
index 54e3cfe7e09..58aaa4a6428 100644
--- a/Libraries/LibWeb/SVG/SVGEllipseElement.h
+++ b/Libraries/LibWeb/SVG/SVGEllipseElement.h
@@ -13,7 +13,7 @@ namespace Web::SVG {
 
 class SVGEllipseElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGEllipseElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGEllipseElement);
+    GC_DECLARE_ALLOCATOR(SVGEllipseElement);
 
 public:
     virtual ~SVGEllipseElement() override = default;
@@ -22,10 +22,10 @@ public:
 
     virtual Gfx::Path get_path(CSSPixelSize viewport_size) override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> cx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> cy() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> rx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> ry() const;
+    GC::Ref<SVGAnimatedLength> cx() const;
+    GC::Ref<SVGAnimatedLength> cy() const;
+    GC::Ref<SVGAnimatedLength> rx() const;
+    GC::Ref<SVGAnimatedLength> ry() const;
 
 private:
     SVGEllipseElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGForeignObjectElement.cpp b/Libraries/LibWeb/SVG/SVGForeignObjectElement.cpp
index fa7186eff31..8c1364bd530 100644
--- a/Libraries/LibWeb/SVG/SVGForeignObjectElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGForeignObjectElement.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGForeignObjectElement);
+GC_DEFINE_ALLOCATOR(SVGForeignObjectElement);
 
 SVGForeignObjectElement::SVGForeignObjectElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, move(qualified_name))
@@ -47,7 +47,7 @@ void SVGForeignObjectElement::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_height);
 }
 
-JS::GCPtr<Layout::Node> SVGForeignObjectElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGForeignObjectElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGForeignObjectBox>(document(), *this, move(style));
 }
@@ -63,22 +63,22 @@ void SVGForeignObjectElement::apply_presentational_hints(CSS::StyleProperties& s
         style.set_property(CSS::PropertyID::Height, height_value.release_nonnull());
 }
 
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGForeignObjectElement::x()
+GC::Ref<SVG::SVGAnimatedLength> SVGForeignObjectElement::x()
 {
     return *m_x;
 }
 
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGForeignObjectElement::y()
+GC::Ref<SVG::SVGAnimatedLength> SVGForeignObjectElement::y()
 {
     return *m_y;
 }
 
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGForeignObjectElement::width()
+GC::Ref<SVG::SVGAnimatedLength> SVGForeignObjectElement::width()
 {
     return *m_width;
 }
 
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGForeignObjectElement::height()
+GC::Ref<SVG::SVGAnimatedLength> SVGForeignObjectElement::height()
 {
     return *m_height;
 }
diff --git a/Libraries/LibWeb/SVG/SVGForeignObjectElement.h b/Libraries/LibWeb/SVG/SVGForeignObjectElement.h
index af26d27a7f3..ddf952b9c25 100644
--- a/Libraries/LibWeb/SVG/SVGForeignObjectElement.h
+++ b/Libraries/LibWeb/SVG/SVGForeignObjectElement.h
@@ -13,17 +13,17 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/embedded.html#InterfaceSVGForeignObjectElement
 class SVGForeignObjectElement final : public SVGGraphicsElement {
     WEB_PLATFORM_OBJECT(SVGForeignObjectElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGForeignObjectElement);
+    GC_DECLARE_ALLOCATOR(SVGForeignObjectElement);
 
 public:
     virtual ~SVGForeignObjectElement() override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> x();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> y();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> width();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> height();
+    GC::Ref<SVG::SVGAnimatedLength> x();
+    GC::Ref<SVG::SVGAnimatedLength> y();
+    GC::Ref<SVG::SVGAnimatedLength> width();
+    GC::Ref<SVG::SVGAnimatedLength> height();
 
 private:
     SVGForeignObjectElement(DOM::Document& document, DOM::QualifiedName qualified_name);
@@ -33,10 +33,10 @@ private:
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
-    JS::GCPtr<SVG::SVGAnimatedLength> m_x;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_y;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_width;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_height;
+    GC::Ptr<SVG::SVGAnimatedLength> m_x;
+    GC::Ptr<SVG::SVGAnimatedLength> m_y;
+    GC::Ptr<SVG::SVGAnimatedLength> m_width;
+    GC::Ptr<SVG::SVGAnimatedLength> m_height;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGGElement.cpp b/Libraries/LibWeb/SVG/SVGGElement.cpp
index f59a616c57b..9bcadfd024f 100644
--- a/Libraries/LibWeb/SVG/SVGGElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGGElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGGElement);
+GC_DEFINE_ALLOCATOR(SVGGElement);
 
 SVGGElement::SVGGElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, move(qualified_name))
@@ -26,7 +26,7 @@ void SVGGElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGGElement);
 }
 
-JS::GCPtr<Layout::Node> SVGGElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGGElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGGraphicsBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGGElement.h b/Libraries/LibWeb/SVG/SVGGElement.h
index 72be16dbfed..e969fcf35e4 100644
--- a/Libraries/LibWeb/SVG/SVGGElement.h
+++ b/Libraries/LibWeb/SVG/SVGGElement.h
@@ -12,12 +12,12 @@ namespace Web::SVG {
 
 class SVGGElement final : public SVGGraphicsElement {
     WEB_PLATFORM_OBJECT(SVGGElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGGElement);
+    GC_DECLARE_ALLOCATOR(SVGGElement);
 
 public:
     virtual ~SVGGElement() override = default;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
 private:
     SVGGElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGGeometryElement.cpp b/Libraries/LibWeb/SVG/SVGGeometryElement.cpp
index 50cfce176c4..61f27c023e2 100644
--- a/Libraries/LibWeb/SVG/SVGGeometryElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGGeometryElement.cpp
@@ -22,7 +22,7 @@ void SVGGeometryElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGGeometryElement);
 }
 
-JS::GCPtr<Layout::Node> SVGGeometryElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGGeometryElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGGeometryBox>(document(), *this, move(style));
 }
@@ -32,7 +32,7 @@ float SVGGeometryElement::get_total_length()
     return 0;
 }
 
-JS::NonnullGCPtr<Geometry::DOMPoint> SVGGeometryElement::get_point_at_length(float distance)
+GC::Ref<Geometry::DOMPoint> SVGGeometryElement::get_point_at_length(float distance)
 {
     (void)distance;
     return Geometry::DOMPoint::construct_impl(realm(), 0, 0, 0, 0);
diff --git a/Libraries/LibWeb/SVG/SVGGeometryElement.h b/Libraries/LibWeb/SVG/SVGGeometryElement.h
index 23bbb06eb52..fd6552604f5 100644
--- a/Libraries/LibWeb/SVG/SVGGeometryElement.h
+++ b/Libraries/LibWeb/SVG/SVGGeometryElement.h
@@ -16,12 +16,12 @@ class SVGGeometryElement : public SVGGraphicsElement {
     WEB_PLATFORM_OBJECT(SVGGeometryElement, SVGGraphicsElement);
 
 public:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     virtual Gfx::Path get_path(CSSPixelSize viewport_size) = 0;
 
     float get_total_length();
-    JS::NonnullGCPtr<Geometry::DOMPoint> get_point_at_length(float distance);
+    GC::Ref<Geometry::DOMPoint> get_point_at_length(float distance);
 
 protected:
     SVGGeometryElement(DOM::Document& document, DOM::QualifiedName qualified_name);
diff --git a/Libraries/LibWeb/SVG/SVGGradientElement.cpp b/Libraries/LibWeb/SVG/SVGGradientElement.cpp
index 6ab5fd7668c..e65766a86da 100644
--- a/Libraries/LibWeb/SVG/SVGGradientElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGGradientElement.cpp
@@ -121,7 +121,7 @@ void SVGGradientElement::add_color_stops(Painting::SVGGradientPaintStyle& paint_
     });
 }
 
-JS::GCPtr<SVGGradientElement const> SVGGradientElement::linked_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
+GC::Ptr<SVGGradientElement const> SVGGradientElement::linked_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
 {
     // FIXME: This entire function is an ad-hoc hack!
     // It can only resolve #<ids> in the same document.
diff --git a/Libraries/LibWeb/SVG/SVGGradientElement.h b/Libraries/LibWeb/SVG/SVGGradientElement.h
index 46e44197bca..bfd860ee2bd 100644
--- a/Libraries/LibWeb/SVG/SVGGradientElement.h
+++ b/Libraries/LibWeb/SVG/SVGGradientElement.h
@@ -59,7 +59,7 @@ protected:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<SVGGradientElement const> linked_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const;
+    GC::Ptr<SVGGradientElement const> linked_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const;
 
     Gfx::AffineTransform gradient_paint_transform(SVGPaintContext const&) const;
 
diff --git a/Libraries/LibWeb/SVG/SVGGraphicsElement.cpp b/Libraries/LibWeb/SVG/SVGGraphicsElement.cpp
index 1464dd7ad2e..a643fa535bb 100644
--- a/Libraries/LibWeb/SVG/SVGGraphicsElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGGraphicsElement.cpp
@@ -74,7 +74,7 @@ Optional<Painting::PaintStyle> SVGGraphicsElement::stroke_paint_style(SVGPaintCo
     return svg_paint_computed_value_to_gfx_paint_style(paint_context, layout_node()->computed_values().stroke());
 }
 
-JS::GCPtr<SVG::SVGMaskElement const> SVGGraphicsElement::mask() const
+GC::Ptr<SVG::SVGMaskElement const> SVGGraphicsElement::mask() const
 {
     auto const& mask_reference = layout_node()->computed_values().mask();
     if (!mask_reference.has_value())
@@ -82,7 +82,7 @@ JS::GCPtr<SVG::SVGMaskElement const> SVGGraphicsElement::mask() const
     return try_resolve_url_to<SVG::SVGMaskElement const>(mask_reference->url());
 }
 
-JS::GCPtr<SVG::SVGClipPathElement const> SVGGraphicsElement::clip_path() const
+GC::Ptr<SVG::SVGClipPathElement const> SVGGraphicsElement::clip_path() const
 {
     auto const& clip_path_reference = layout_node()->computed_values().clip_path();
     if (!clip_path_reference.has_value() || !clip_path_reference->is_url())
@@ -288,7 +288,7 @@ Optional<float> SVGGraphicsElement::stroke_width() const
 }
 
 // https://svgwg.org/svg2-draft/types.html#__svg__SVGGraphicsElement__getBBox
-JS::NonnullGCPtr<Geometry::DOMRect> SVGGraphicsElement::get_b_box(Optional<SVGBoundingBoxOptions>)
+GC::Ref<Geometry::DOMRect> SVGGraphicsElement::get_b_box(Optional<SVGBoundingBoxOptions>)
 {
     // FIXME: It should be possible to compute this without layout updates. The bounding box is within the
     // SVG coordinate space (before any viewbox or other transformations), so it should be possible to
@@ -309,7 +309,7 @@ JS::NonnullGCPtr<Geometry::DOMRect> SVGGraphicsElement::get_b_box(Optional<SVGBo
     return Geometry::DOMRect::create(realm(), translated_rect);
 }
 
-JS::NonnullGCPtr<SVGAnimatedTransformList> SVGGraphicsElement::transform() const
+GC::Ref<SVGAnimatedTransformList> SVGGraphicsElement::transform() const
 {
     dbgln("(STUBBED) SVGGraphicsElement::transform(). Called on: {}", debug_description());
     auto base_val = SVGTransformList::create(realm());
@@ -317,7 +317,7 @@ JS::NonnullGCPtr<SVGAnimatedTransformList> SVGGraphicsElement::transform() const
     return SVGAnimatedTransformList::create(realm(), base_val, anim_val);
 }
 
-JS::GCPtr<Geometry::DOMMatrix> SVGGraphicsElement::get_screen_ctm()
+GC::Ptr<Geometry::DOMMatrix> SVGGraphicsElement::get_screen_ctm()
 {
     dbgln("(STUBBED) SVGGraphicsElement::get_screen_ctm(). Called on: {}", debug_description());
     return Geometry::DOMMatrix::create(realm());
diff --git a/Libraries/LibWeb/SVG/SVGGraphicsElement.h b/Libraries/LibWeb/SVG/SVGGraphicsElement.h
index 5436e117625..f0ee21261d6 100644
--- a/Libraries/LibWeb/SVG/SVGGraphicsElement.h
+++ b/Libraries/LibWeb/SVG/SVGGraphicsElement.h
@@ -57,13 +57,13 @@ public:
     Optional<Painting::PaintStyle> fill_paint_style(SVGPaintContext const&) const;
     Optional<Painting::PaintStyle> stroke_paint_style(SVGPaintContext const&) const;
 
-    JS::GCPtr<SVG::SVGMaskElement const> mask() const;
-    JS::GCPtr<SVG::SVGClipPathElement const> clip_path() const;
+    GC::Ptr<SVG::SVGMaskElement const> mask() const;
+    GC::Ptr<SVG::SVGClipPathElement const> clip_path() const;
 
-    JS::NonnullGCPtr<Geometry::DOMRect> get_b_box(Optional<SVGBoundingBoxOptions>);
-    JS::NonnullGCPtr<SVGAnimatedTransformList> transform() const;
+    GC::Ref<Geometry::DOMRect> get_b_box(Optional<SVGBoundingBoxOptions>);
+    GC::Ref<SVGAnimatedTransformList> transform() const;
 
-    JS::GCPtr<Geometry::DOMMatrix> get_screen_ctm();
+    GC::Ptr<Geometry::DOMMatrix> get_screen_ctm();
 
 protected:
     SVGGraphicsElement(DOM::Document&, DOM::QualifiedName);
@@ -80,7 +80,7 @@ protected:
     Gfx::AffineTransform m_transform = {};
 
     template<typename T>
-    JS::GCPtr<T> try_resolve_url_to(URL::URL const& url) const
+    GC::Ptr<T> try_resolve_url_to(URL::URL const& url) const
     {
         if (!url.fragment().has_value())
             return {};
diff --git a/Libraries/LibWeb/SVG/SVGImageElement.cpp b/Libraries/LibWeb/SVG/SVGImageElement.cpp
index 632917f57d6..a3f2d6d6743 100644
--- a/Libraries/LibWeb/SVG/SVGImageElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGImageElement.cpp
@@ -6,7 +6,7 @@
 
 #include "SVGImageElement.h"
 #include <LibCore/Timer.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibWeb/Bindings/SVGImageElementPrototype.h>
 #include <LibWeb/DOM/DocumentObserver.h>
 #include <LibWeb/DOM/Event.h>
@@ -64,7 +64,7 @@ void SVGImageElement::attribute_changed(FlyString const& name, Optional<String>
 }
 
 // https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__x
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::x()
+GC::Ref<SVG::SVGAnimatedLength> SVGImageElement::x()
 {
     if (!m_x) {
         auto& realm = this->realm();
@@ -75,7 +75,7 @@ JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::x()
 }
 
 // https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__y
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::y()
+GC::Ref<SVG::SVGAnimatedLength> SVGImageElement::y()
 {
     if (!m_y) {
         auto& realm = this->realm();
@@ -86,7 +86,7 @@ JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::y()
 }
 
 // https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__width
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::width()
+GC::Ref<SVG::SVGAnimatedLength> SVGImageElement::width()
 {
     if (!m_width) {
         auto& realm = this->realm();
@@ -97,7 +97,7 @@ JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::width()
 }
 
 // https://svgwg.org/svg2-draft/embedded.html#__svg__SVGImageElement__height
-JS::NonnullGCPtr<SVG::SVGAnimatedLength> SVGImageElement::height()
+GC::Ref<SVG::SVGAnimatedLength> SVGImageElement::height()
 {
     if (!m_height) {
         auto& realm = this->realm();
@@ -179,7 +179,7 @@ void SVGImageElement::fetch_the_document(URL::URL const& url)
     }
 }
 
-JS::GCPtr<Layout::Node> SVGImageElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGImageElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGImageBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGImageElement.h b/Libraries/LibWeb/SVG/SVGImageElement.h
index a079335c7a5..52c8eb4c607 100644
--- a/Libraries/LibWeb/SVG/SVGImageElement.h
+++ b/Libraries/LibWeb/SVG/SVGImageElement.h
@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Layout/ImageProvider.h>
 #include <LibWeb/SVG/SVGAnimatedLength.h>
 #include <LibWeb/SVG/SVGGraphicsElement.h>
@@ -22,10 +22,10 @@ class SVGImageElement
 public:
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> x();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> y();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> width();
-    JS::NonnullGCPtr<SVG::SVGAnimatedLength> height();
+    GC::Ref<SVG::SVGAnimatedLength> x();
+    GC::Ref<SVG::SVGAnimatedLength> y();
+    GC::Ref<SVG::SVGAnimatedLength> width();
+    GC::Ref<SVG::SVGAnimatedLength> height();
 
     Gfx::Rect<CSSPixels> bounding_box() const;
 
@@ -36,7 +36,7 @@ public:
     virtual Optional<CSSPixelFraction> intrinsic_aspect_ratio() const override;
     virtual RefPtr<Gfx::ImmutableBitmap> current_image_bitmap(Gfx::IntSize = {}) const override;
     virtual void set_visible_in_viewport(bool) override { }
-    virtual JS::NonnullGCPtr<DOM::Element const> to_html_element() const override { return *this; }
+    virtual GC::Ref<DOM::Element const> to_html_element() const override { return *this; }
 
 protected:
     SVGImageElement(DOM::Document&, DOM::QualifiedName);
@@ -48,13 +48,13 @@ protected:
     void fetch_the_document(URL::URL const& url);
 
 private:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     void animate();
 
-    JS::GCPtr<SVG::SVGAnimatedLength> m_x;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_y;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_width;
-    JS::GCPtr<SVG::SVGAnimatedLength> m_height;
+    GC::Ptr<SVG::SVGAnimatedLength> m_x;
+    GC::Ptr<SVG::SVGAnimatedLength> m_y;
+    GC::Ptr<SVG::SVGAnimatedLength> m_width;
+    GC::Ptr<SVG::SVGAnimatedLength> m_height;
 
     RefPtr<Core::Timer> m_animation_timer;
     size_t m_current_frame_index { 0 };
@@ -62,7 +62,7 @@ private:
 
     URL::URL m_href;
 
-    JS::GCPtr<HTML::SharedResourceRequest> m_resource_request;
+    GC::Ptr<HTML::SharedResourceRequest> m_resource_request;
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
 };
 
diff --git a/Libraries/LibWeb/SVG/SVGLength.cpp b/Libraries/LibWeb/SVG/SVGLength.cpp
index cb9253625c0..3f1b5682186 100644
--- a/Libraries/LibWeb/SVG/SVGLength.cpp
+++ b/Libraries/LibWeb/SVG/SVGLength.cpp
@@ -11,14 +11,14 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGLength);
+GC_DEFINE_ALLOCATOR(SVGLength);
 
-JS::NonnullGCPtr<SVGLength> SVGLength::create(JS::Realm& realm, u8 unit_type, float value)
+GC::Ref<SVGLength> SVGLength::create(JS::Realm& realm, u8 unit_type, float value)
 {
     return realm.create<SVGLength>(realm, unit_type, value);
 }
 
-JS::NonnullGCPtr<SVGLength> SVGLength::from_length_percentage(JS::Realm& realm, CSS::LengthPercentage const& length_percentage)
+GC::Ref<SVGLength> SVGLength::from_length_percentage(JS::Realm& realm, CSS::LengthPercentage const& length_percentage)
 {
     // FIXME: We can't tell if a CSS::LengthPercentage was a unitless length.
     (void)SVG_LENGTHTYPE_NUMBER;
diff --git a/Libraries/LibWeb/SVG/SVGLength.h b/Libraries/LibWeb/SVG/SVGLength.h
index 5d65104df2b..2bba7f89096 100644
--- a/Libraries/LibWeb/SVG/SVGLength.h
+++ b/Libraries/LibWeb/SVG/SVGLength.h
@@ -14,7 +14,7 @@ namespace Web::SVG {
 // https://www.w3.org/TR/SVG11/types.html#InterfaceSVGLength
 class SVGLength : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGLength, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGLength);
+    GC_DECLARE_ALLOCATOR(SVGLength);
 
 public:
     // Same as SVGLength.idl
@@ -30,7 +30,7 @@ public:
     static constexpr unsigned short SVG_LENGTHTYPE_PT = 9;
     static constexpr unsigned short SVG_LENGTHTYPE_PC = 10;
 
-    [[nodiscard]] static JS::NonnullGCPtr<SVGLength> create(JS::Realm&, u8 unit_type, float value);
+    [[nodiscard]] static GC::Ref<SVGLength> create(JS::Realm&, u8 unit_type, float value);
     virtual ~SVGLength() override;
 
     u8 unit_type() const { return m_unit_type; }
@@ -38,7 +38,7 @@ public:
     float value() const { return m_value; }
     WebIDL::ExceptionOr<void> set_value(float value);
 
-    [[nodiscard]] static JS::NonnullGCPtr<SVGLength> from_length_percentage(JS::Realm&, CSS::LengthPercentage const&);
+    [[nodiscard]] static GC::Ref<SVGLength> from_length_percentage(JS::Realm&, CSS::LengthPercentage const&);
 
 private:
     SVGLength(JS::Realm&, u8 unit_type, float value);
diff --git a/Libraries/LibWeb/SVG/SVGLineElement.cpp b/Libraries/LibWeb/SVG/SVGLineElement.cpp
index 3b89c411c8f..dde1b788962 100644
--- a/Libraries/LibWeb/SVG/SVGLineElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGLineElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGLineElement);
+GC_DEFINE_ALLOCATOR(SVGLineElement);
 
 SVGLineElement::SVGLineElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
@@ -62,7 +62,7 @@ Gfx::Path SVGLineElement::get_path(CSSPixelSize viewport_size)
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#LineElementX1Attribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::x1() const
+GC::Ref<SVGAnimatedLength> SVGLineElement::x1() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -72,7 +72,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::x1() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#LineElementY1Attribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::y1() const
+GC::Ref<SVGAnimatedLength> SVGLineElement::y1() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -82,7 +82,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::y1() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#LineElementX2Attribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::x2() const
+GC::Ref<SVGAnimatedLength> SVGLineElement::x2() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -92,7 +92,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::x2() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#LineElementY2Attribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLineElement::y2() const
+GC::Ref<SVGAnimatedLength> SVGLineElement::y2() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
diff --git a/Libraries/LibWeb/SVG/SVGLineElement.h b/Libraries/LibWeb/SVG/SVGLineElement.h
index 56ab7c217e6..cddd988f882 100644
--- a/Libraries/LibWeb/SVG/SVGLineElement.h
+++ b/Libraries/LibWeb/SVG/SVGLineElement.h
@@ -13,7 +13,7 @@ namespace Web::SVG {
 
 class SVGLineElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGLineElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGLineElement);
+    GC_DECLARE_ALLOCATOR(SVGLineElement);
 
 public:
     virtual ~SVGLineElement() override = default;
@@ -22,10 +22,10 @@ public:
 
     virtual Gfx::Path get_path(CSSPixelSize viewport_size) override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x1() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y1() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> x2() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y2() const;
+    GC::Ref<SVGAnimatedLength> x1() const;
+    GC::Ref<SVGAnimatedLength> y1() const;
+    GC::Ref<SVGAnimatedLength> x2() const;
+    GC::Ref<SVGAnimatedLength> y2() const;
 
 private:
     SVGLineElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGLinearGradientElement.cpp b/Libraries/LibWeb/SVG/SVGLinearGradientElement.cpp
index 2ffb11188e9..ab62cadb06a 100644
--- a/Libraries/LibWeb/SVG/SVGLinearGradientElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGLinearGradientElement.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGLinearGradientElement);
+GC_DEFINE_ALLOCATOR(SVGLinearGradientElement);
 
 SVGLinearGradientElement::SVGLinearGradientElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGradientElement(document, qualified_name)
@@ -159,25 +159,25 @@ Optional<Painting::PaintStyle> SVGLinearGradientElement::to_gfx_paint_style(SVGP
     return *m_paint_style;
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLinearGradientElement::x1() const
+GC::Ref<SVGAnimatedLength> SVGLinearGradientElement::x1() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLinearGradientElement::y1() const
+GC::Ref<SVGAnimatedLength> SVGLinearGradientElement::y1() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLinearGradientElement::x2() const
+GC::Ref<SVGAnimatedLength> SVGLinearGradientElement::x2() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGLinearGradientElement::y2() const
+GC::Ref<SVGAnimatedLength> SVGLinearGradientElement::y2() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
diff --git a/Libraries/LibWeb/SVG/SVGLinearGradientElement.h b/Libraries/LibWeb/SVG/SVGLinearGradientElement.h
index dfd84949329..4f346c6d138 100644
--- a/Libraries/LibWeb/SVG/SVGLinearGradientElement.h
+++ b/Libraries/LibWeb/SVG/SVGLinearGradientElement.h
@@ -14,7 +14,7 @@ namespace Web::SVG {
 
 class SVGLinearGradientElement : public SVGGradientElement {
     WEB_PLATFORM_OBJECT(SVGLinearGradientElement, SVGGradientElement);
-    JS_DECLARE_ALLOCATOR(SVGLinearGradientElement);
+    GC_DECLARE_ALLOCATOR(SVGLinearGradientElement);
 
 public:
     virtual ~SVGLinearGradientElement() override = default;
@@ -23,10 +23,10 @@ public:
 
     virtual Optional<Painting::PaintStyle> to_gfx_paint_style(SVGPaintContext const&) const override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x1() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y1() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> x2() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y2() const;
+    GC::Ref<SVGAnimatedLength> x1() const;
+    GC::Ref<SVGAnimatedLength> y1() const;
+    GC::Ref<SVGAnimatedLength> x2() const;
+    GC::Ref<SVGAnimatedLength> y2() const;
 
 protected:
     SVGLinearGradientElement(DOM::Document&, DOM::QualifiedName);
@@ -34,7 +34,7 @@ protected:
     virtual void initialize(JS::Realm&) override;
 
 private:
-    JS::GCPtr<SVGLinearGradientElement const> linked_linear_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
+    GC::Ptr<SVGLinearGradientElement const> linked_linear_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
     {
         if (auto gradient = linked_gradient(seen_gradients); gradient && is<SVGLinearGradientElement>(*gradient))
             return &verify_cast<SVGLinearGradientElement>(*gradient);
diff --git a/Libraries/LibWeb/SVG/SVGMaskElement.cpp b/Libraries/LibWeb/SVG/SVGMaskElement.cpp
index 644d987255e..7674e389419 100644
--- a/Libraries/LibWeb/SVG/SVGMaskElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGMaskElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGMaskElement);
+GC_DEFINE_ALLOCATOR(SVGMaskElement);
 
 SVGMaskElement::SVGMaskElement(DOM::Document& document, DOM::QualifiedName tag_name)
     : SVGGraphicsElement(document, move(tag_name))
@@ -27,7 +27,7 @@ void SVGMaskElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGMaskElement);
 }
 
-JS::GCPtr<Layout::Node> SVGMaskElement::create_layout_node(CSS::StyleProperties)
+GC::Ptr<Layout::Node> SVGMaskElement::create_layout_node(CSS::StyleProperties)
 {
     // Masks are handled as a special case in the TreeBuilder.
     return nullptr;
diff --git a/Libraries/LibWeb/SVG/SVGMaskElement.h b/Libraries/LibWeb/SVG/SVGMaskElement.h
index 5d5df12ce7f..6b4461ac4a5 100644
--- a/Libraries/LibWeb/SVG/SVGMaskElement.h
+++ b/Libraries/LibWeb/SVG/SVGMaskElement.h
@@ -16,7 +16,7 @@ class SVGMaskElement final : public SVGGraphicsElement
     , public SVGViewport {
 
     WEB_PLATFORM_OBJECT(SVGMaskElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGMaskElement);
+    GC_DECLARE_ALLOCATOR(SVGMaskElement);
 
 public:
     virtual ~SVGMaskElement() override;
@@ -38,7 +38,7 @@ public:
 
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     CSSPixelRect resolve_masking_area(CSSPixelRect const& mask_target) const;
 
diff --git a/Libraries/LibWeb/SVG/SVGMetadataElement.cpp b/Libraries/LibWeb/SVG/SVGMetadataElement.cpp
index 253668d056b..fc4d1b8d187 100644
--- a/Libraries/LibWeb/SVG/SVGMetadataElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGMetadataElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGMetadataElement);
+GC_DEFINE_ALLOCATOR(SVGMetadataElement);
 
 SVGMetadataElement::SVGMetadataElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
@@ -25,7 +25,7 @@ void SVGMetadataElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGMetadataElement);
 }
 
-JS::GCPtr<Layout::Node> SVGMetadataElement::create_layout_node(CSS::StyleProperties)
+GC::Ptr<Layout::Node> SVGMetadataElement::create_layout_node(CSS::StyleProperties)
 {
     return nullptr;
 }
diff --git a/Libraries/LibWeb/SVG/SVGMetadataElement.h b/Libraries/LibWeb/SVG/SVGMetadataElement.h
index 891c07bcb8a..6a08126dcf1 100644
--- a/Libraries/LibWeb/SVG/SVGMetadataElement.h
+++ b/Libraries/LibWeb/SVG/SVGMetadataElement.h
@@ -13,14 +13,14 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/struct.html#InterfaceSVGMetadataElement
 class SVGMetadataElement final : public SVGElement {
     WEB_PLATFORM_OBJECT(SVGMetadataElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGMetadataElement);
+    GC_DECLARE_ALLOCATOR(SVGMetadataElement);
 
 private:
     SVGMetadataElement(DOM::Document&, DOM::QualifiedName);
 
     virtual void initialize(JS::Realm&) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGPathElement.cpp b/Libraries/LibWeb/SVG/SVGPathElement.cpp
index ca1ae579e56..175026a496f 100644
--- a/Libraries/LibWeb/SVG/SVGPathElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGPathElement.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGPathElement);
+GC_DEFINE_ALLOCATOR(SVGPathElement);
 
 [[maybe_unused]] static void print_instruction(PathInstruction const& instruction)
 {
diff --git a/Libraries/LibWeb/SVG/SVGPathElement.h b/Libraries/LibWeb/SVG/SVGPathElement.h
index ceb4108e10f..03a492e9888 100644
--- a/Libraries/LibWeb/SVG/SVGPathElement.h
+++ b/Libraries/LibWeb/SVG/SVGPathElement.h
@@ -15,7 +15,7 @@ namespace Web::SVG {
 
 class SVGPathElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGPathElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGPathElement);
+    GC_DECLARE_ALLOCATOR(SVGPathElement);
 
 public:
     virtual ~SVGPathElement() override = default;
diff --git a/Libraries/LibWeb/SVG/SVGPolygonElement.cpp b/Libraries/LibWeb/SVG/SVGPolygonElement.cpp
index c2e05310a95..871a6c0bae1 100644
--- a/Libraries/LibWeb/SVG/SVGPolygonElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGPolygonElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGPolygonElement);
+GC_DEFINE_ALLOCATOR(SVGPolygonElement);
 
 SVGPolygonElement::SVGPolygonElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
diff --git a/Libraries/LibWeb/SVG/SVGPolygonElement.h b/Libraries/LibWeb/SVG/SVGPolygonElement.h
index 92fff8144db..b2b2e86e4a9 100644
--- a/Libraries/LibWeb/SVG/SVGPolygonElement.h
+++ b/Libraries/LibWeb/SVG/SVGPolygonElement.h
@@ -12,7 +12,7 @@ namespace Web::SVG {
 
 class SVGPolygonElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGPolygonElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGPolygonElement);
+    GC_DECLARE_ALLOCATOR(SVGPolygonElement);
 
 public:
     virtual ~SVGPolygonElement() override = default;
diff --git a/Libraries/LibWeb/SVG/SVGPolylineElement.cpp b/Libraries/LibWeb/SVG/SVGPolylineElement.cpp
index c8ab2a5e8ea..b1fb4eb1c4f 100644
--- a/Libraries/LibWeb/SVG/SVGPolylineElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGPolylineElement.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGPolylineElement);
+GC_DEFINE_ALLOCATOR(SVGPolylineElement);
 
 SVGPolylineElement::SVGPolylineElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
diff --git a/Libraries/LibWeb/SVG/SVGPolylineElement.h b/Libraries/LibWeb/SVG/SVGPolylineElement.h
index 8ffd01d0fe9..3d4fa1ef970 100644
--- a/Libraries/LibWeb/SVG/SVGPolylineElement.h
+++ b/Libraries/LibWeb/SVG/SVGPolylineElement.h
@@ -12,7 +12,7 @@ namespace Web::SVG {
 
 class SVGPolylineElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGPolylineElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGPolylineElement);
+    GC_DECLARE_ALLOCATOR(SVGPolylineElement);
 
 public:
     virtual ~SVGPolylineElement() override = default;
diff --git a/Libraries/LibWeb/SVG/SVGRadialGradientElement.cpp b/Libraries/LibWeb/SVG/SVGRadialGradientElement.cpp
index fbe7f9bc0c0..950675b2ba2 100644
--- a/Libraries/LibWeb/SVG/SVGRadialGradientElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGRadialGradientElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGRadialGradientElement);
+GC_DEFINE_ALLOCATOR(SVGRadialGradientElement);
 
 SVGRadialGradientElement::SVGRadialGradientElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGradientElement(document, qualified_name)
@@ -215,37 +215,37 @@ Optional<Painting::PaintStyle> SVGRadialGradientElement::to_gfx_paint_style(SVGP
     return *m_paint_style;
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::cx() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::cx() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::cy() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::cy() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::fx() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::fx() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::fy() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::fy() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::fr() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::fr() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRadialGradientElement::r() const
+GC::Ref<SVGAnimatedLength> SVGRadialGradientElement::r() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
diff --git a/Libraries/LibWeb/SVG/SVGRadialGradientElement.h b/Libraries/LibWeb/SVG/SVGRadialGradientElement.h
index b712a13ff35..3c7db7599e0 100644
--- a/Libraries/LibWeb/SVG/SVGRadialGradientElement.h
+++ b/Libraries/LibWeb/SVG/SVGRadialGradientElement.h
@@ -14,7 +14,7 @@ namespace Web::SVG {
 
 class SVGRadialGradientElement : public SVGGradientElement {
     WEB_PLATFORM_OBJECT(SVGRadialGradientElement, SVGGradientElement);
-    JS_DECLARE_ALLOCATOR(SVGRadialGradientElement);
+    GC_DECLARE_ALLOCATOR(SVGRadialGradientElement);
 
 public:
     virtual ~SVGRadialGradientElement() override = default;
@@ -23,12 +23,12 @@ public:
 
     virtual Optional<Painting::PaintStyle> to_gfx_paint_style(SVGPaintContext const&) const override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> cx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> cy() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> fx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> fy() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> fr() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> r() const;
+    GC::Ref<SVGAnimatedLength> cx() const;
+    GC::Ref<SVGAnimatedLength> cy() const;
+    GC::Ref<SVGAnimatedLength> fx() const;
+    GC::Ref<SVGAnimatedLength> fy() const;
+    GC::Ref<SVGAnimatedLength> fr() const;
+    GC::Ref<SVGAnimatedLength> r() const;
 
 protected:
     SVGRadialGradientElement(DOM::Document&, DOM::QualifiedName);
@@ -36,7 +36,7 @@ protected:
     virtual void initialize(JS::Realm&) override;
 
 private:
-    JS::GCPtr<SVGRadialGradientElement const> linked_radial_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
+    GC::Ptr<SVGRadialGradientElement const> linked_radial_gradient(HashTable<SVGGradientElement const*>& seen_gradients) const
     {
         if (auto gradient = linked_gradient(seen_gradients); gradient && is<SVGRadialGradientElement>(*gradient))
             return &verify_cast<SVGRadialGradientElement>(*gradient);
diff --git a/Libraries/LibWeb/SVG/SVGRectElement.cpp b/Libraries/LibWeb/SVG/SVGRectElement.cpp
index 9cddb40aed9..abda966110b 100644
--- a/Libraries/LibWeb/SVG/SVGRectElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGRectElement.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGRectElement);
+GC_DEFINE_ALLOCATOR(SVGRectElement);
 
 SVGRectElement::SVGRectElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGeometryElement(document, qualified_name)
@@ -154,7 +154,7 @@ Gfx::FloatSize SVGRectElement::calculate_used_corner_radius_values() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::x() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::x() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -164,7 +164,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::x() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::y() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::y() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -174,7 +174,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::y() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementWidthAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::width() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::width() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -184,7 +184,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::width() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementHeightAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::height() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::height() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -194,7 +194,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::height() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementRXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::rx() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::rx() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -204,7 +204,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::rx() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementRYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGRectElement::ry() const
+GC::Ref<SVGAnimatedLength> SVGRectElement::ry() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
diff --git a/Libraries/LibWeb/SVG/SVGRectElement.h b/Libraries/LibWeb/SVG/SVGRectElement.h
index 8befef1908a..f647cd09ccd 100644
--- a/Libraries/LibWeb/SVG/SVGRectElement.h
+++ b/Libraries/LibWeb/SVG/SVGRectElement.h
@@ -13,7 +13,7 @@ namespace Web::SVG {
 // https://www.w3.org/TR/SVG11/shapes.html#RectElement
 class SVGRectElement final : public SVGGeometryElement {
     WEB_PLATFORM_OBJECT(SVGRectElement, SVGGeometryElement);
-    JS_DECLARE_ALLOCATOR(SVGRectElement);
+    GC_DECLARE_ALLOCATOR(SVGRectElement);
 
 public:
     virtual ~SVGRectElement() override = default;
@@ -22,12 +22,12 @@ public:
 
     virtual Gfx::Path get_path(CSSPixelSize viewport_size) override;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> width() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> height() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> rx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> ry() const;
+    GC::Ref<SVGAnimatedLength> x() const;
+    GC::Ref<SVGAnimatedLength> y() const;
+    GC::Ref<SVGAnimatedLength> width() const;
+    GC::Ref<SVGAnimatedLength> height() const;
+    GC::Ref<SVGAnimatedLength> rx() const;
+    GC::Ref<SVGAnimatedLength> ry() const;
 
 private:
     SVGRectElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGSVGElement.cpp b/Libraries/LibWeb/SVG/SVGSVGElement.cpp
index 62c2eab47be..664447baa9a 100644
--- a/Libraries/LibWeb/SVG/SVGSVGElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGSVGElement.cpp
@@ -22,7 +22,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGSVGElement);
+GC_DEFINE_ALLOCATOR(SVGSVGElement);
 
 SVGSVGElement::SVGSVGElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, qualified_name)
@@ -42,7 +42,7 @@ void SVGSVGElement::visit_edges(Visitor& visitor)
     visitor.visit(m_view_box_for_bindings);
 }
 
-JS::GCPtr<Layout::Node> SVGSVGElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGSVGElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGSVGBox>(document(), *this, move(style));
 }
@@ -169,22 +169,22 @@ Optional<ViewBox> SVGSVGElement::view_box() const
     return {};
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGSVGElement::x() const
+GC::Ref<SVGAnimatedLength> SVGSVGElement::x() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::X);
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGSVGElement::y() const
+GC::Ref<SVGAnimatedLength> SVGSVGElement::y() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::Y);
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGSVGElement::width() const
+GC::Ref<SVGAnimatedLength> SVGSVGElement::width() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::Width);
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGSVGElement::height() const
+GC::Ref<SVGAnimatedLength> SVGSVGElement::height() const
 {
     return svg_animated_length_for_property(CSS::PropertyID::Height);
 }
@@ -200,31 +200,31 @@ void SVGSVGElement::set_current_scale(float)
     dbgln("(STUBBED) SVGSVGElement::set_current_scale(). Called on: {}", debug_description());
 }
 
-JS::NonnullGCPtr<Geometry::DOMPointReadOnly> SVGSVGElement::current_translate() const
+GC::Ref<Geometry::DOMPointReadOnly> SVGSVGElement::current_translate() const
 {
     dbgln("(STUBBED) SVGSVGElement::current_translate(). Called on: {}", debug_description());
     return Geometry::DOMPointReadOnly::create(realm());
 }
 
-JS::NonnullGCPtr<DOM::NodeList> SVGSVGElement::get_intersection_list(JS::NonnullGCPtr<Geometry::DOMRectReadOnly>, JS::GCPtr<SVGElement>) const
+GC::Ref<DOM::NodeList> SVGSVGElement::get_intersection_list(GC::Ref<Geometry::DOMRectReadOnly>, GC::Ptr<SVGElement>) const
 {
     dbgln("(STUBBED) SVGSVGElement::get_intersection_list(). Called on: {}", debug_description());
     return DOM::StaticNodeList::create(realm(), {});
 }
 
-JS::NonnullGCPtr<DOM::NodeList> SVGSVGElement::get_enclosure_list(JS::NonnullGCPtr<Geometry::DOMRectReadOnly>, JS::GCPtr<SVGElement>) const
+GC::Ref<DOM::NodeList> SVGSVGElement::get_enclosure_list(GC::Ref<Geometry::DOMRectReadOnly>, GC::Ptr<SVGElement>) const
 {
     dbgln("(STUBBED) SVGSVGElement::get_enclosure_list(). Called on: {}", debug_description());
     return DOM::StaticNodeList::create(realm(), {});
 }
 
-bool SVGSVGElement::check_intersection(JS::NonnullGCPtr<SVGElement>, JS::NonnullGCPtr<Geometry::DOMRectReadOnly>) const
+bool SVGSVGElement::check_intersection(GC::Ref<SVGElement>, GC::Ref<Geometry::DOMRectReadOnly>) const
 {
     dbgln("(STUBBED) SVGSVGElement::check_intersection(). Called on: {}", debug_description());
     return false;
 }
 
-bool SVGSVGElement::check_enclosure(JS::NonnullGCPtr<SVGElement>, JS::NonnullGCPtr<Geometry::DOMRectReadOnly>) const
+bool SVGSVGElement::check_enclosure(GC::Ref<SVGElement>, GC::Ref<Geometry::DOMRectReadOnly>) const
 {
     dbgln("(STUBBED) SVGSVGElement::check_enclosure(). Called on: {}", debug_description());
     return false;
@@ -237,31 +237,31 @@ void SVGSVGElement::deselect_all() const
         selection->remove_all_ranges();
 }
 
-JS::NonnullGCPtr<SVGLength> SVGSVGElement::create_svg_length() const
+GC::Ref<SVGLength> SVGSVGElement::create_svg_length() const
 {
     // A new, detached SVGLength object whose value is the unitless <number> 0.
     return SVGLength::create(realm(), SVGLength::SVG_LENGTHTYPE_NUMBER, 0);
 }
 
-JS::NonnullGCPtr<Geometry::DOMPoint> SVGSVGElement::create_svg_point() const
+GC::Ref<Geometry::DOMPoint> SVGSVGElement::create_svg_point() const
 {
     // A new, detached DOMPoint object whose coordinates are all 0.
     return Geometry::DOMPoint::from_point(vm(), Geometry::DOMPointInit {});
 }
 
-JS::NonnullGCPtr<Geometry::DOMMatrix> SVGSVGElement::create_svg_matrix() const
+GC::Ref<Geometry::DOMMatrix> SVGSVGElement::create_svg_matrix() const
 {
     // A new, detached DOMMatrix object representing the identity matrix.
     return Geometry::DOMMatrix::create(realm());
 }
 
-JS::NonnullGCPtr<Geometry::DOMRect> SVGSVGElement::create_svg_rect() const
+GC::Ref<Geometry::DOMRect> SVGSVGElement::create_svg_rect() const
 {
     // A new, DOMRect object whose x, y, width and height are all 0.
     return Geometry::DOMRect::construct_impl(realm(), 0, 0, 0, 0).release_value_but_fixme_should_propagate_errors();
 }
 
-JS::NonnullGCPtr<SVGTransform> SVGSVGElement::create_svg_transform() const
+GC::Ref<SVGTransform> SVGSVGElement::create_svg_transform() const
 {
     return SVGTransform::create(realm());
 }
diff --git a/Libraries/LibWeb/SVG/SVGSVGElement.h b/Libraries/LibWeb/SVG/SVGSVGElement.h
index 0db8ab863de..54c7a0240e0 100644
--- a/Libraries/LibWeb/SVG/SVGSVGElement.h
+++ b/Libraries/LibWeb/SVG/SVGSVGElement.h
@@ -26,10 +26,10 @@ class SVGSVGElement final : public SVGGraphicsElement
     // SVGSVGElement is not strictly a NonElementParentNode, but it implements the same get_element_by_id() method.
     , public DOM::NonElementParentNode<SVGSVGElement> {
     WEB_PLATFORM_OBJECT(SVGSVGElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGSVGElement);
+    GC_DECLARE_ALLOCATOR(SVGSVGElement);
 
 public:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
@@ -41,30 +41,30 @@ public:
 
     void set_fallback_view_box_for_svg_as_image(Optional<ViewBox>);
 
-    JS::NonnullGCPtr<SVGAnimatedRect> view_box_for_bindings() { return *m_view_box_for_bindings; }
+    GC::Ref<SVGAnimatedRect> view_box_for_bindings() { return *m_view_box_for_bindings; }
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> width() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> height() const;
+    GC::Ref<SVGAnimatedLength> x() const;
+    GC::Ref<SVGAnimatedLength> y() const;
+    GC::Ref<SVGAnimatedLength> width() const;
+    GC::Ref<SVGAnimatedLength> height() const;
 
     float current_scale() const;
     void set_current_scale(float);
 
-    JS::NonnullGCPtr<Geometry::DOMPointReadOnly> current_translate() const;
+    GC::Ref<Geometry::DOMPointReadOnly> current_translate() const;
 
-    JS::NonnullGCPtr<DOM::NodeList> get_intersection_list(JS::NonnullGCPtr<Geometry::DOMRectReadOnly> rect, JS::GCPtr<SVGElement> reference_element) const;
-    JS::NonnullGCPtr<DOM::NodeList> get_enclosure_list(JS::NonnullGCPtr<Geometry::DOMRectReadOnly> rect, JS::GCPtr<SVGElement> reference_element) const;
-    bool check_intersection(JS::NonnullGCPtr<SVGElement> element, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> rect) const;
-    bool check_enclosure(JS::NonnullGCPtr<SVGElement> element, JS::NonnullGCPtr<Geometry::DOMRectReadOnly> rect) const;
+    GC::Ref<DOM::NodeList> get_intersection_list(GC::Ref<Geometry::DOMRectReadOnly> rect, GC::Ptr<SVGElement> reference_element) const;
+    GC::Ref<DOM::NodeList> get_enclosure_list(GC::Ref<Geometry::DOMRectReadOnly> rect, GC::Ptr<SVGElement> reference_element) const;
+    bool check_intersection(GC::Ref<SVGElement> element, GC::Ref<Geometry::DOMRectReadOnly> rect) const;
+    bool check_enclosure(GC::Ref<SVGElement> element, GC::Ref<Geometry::DOMRectReadOnly> rect) const;
 
     void deselect_all() const;
 
-    JS::NonnullGCPtr<SVGLength> create_svg_length() const;
-    JS::NonnullGCPtr<Geometry::DOMPoint> create_svg_point() const;
-    JS::NonnullGCPtr<Geometry::DOMMatrix> create_svg_matrix() const;
-    JS::NonnullGCPtr<Geometry::DOMRect> create_svg_rect() const;
-    JS::NonnullGCPtr<SVGTransform> create_svg_transform() const;
+    GC::Ref<SVGLength> create_svg_length() const;
+    GC::Ref<Geometry::DOMPoint> create_svg_point() const;
+    GC::Ref<Geometry::DOMMatrix> create_svg_matrix() const;
+    GC::Ref<Geometry::DOMRect> create_svg_rect() const;
+    GC::Ref<SVGTransform> create_svg_transform() const;
 
     // Deprecated methods that have no effect when called, but which are kept for compatibility reasons.
     WebIDL::UnsignedLong suspend_redraw(WebIDL::UnsignedLong max_wait_milliseconds) const
@@ -100,7 +100,7 @@ private:
 
     Optional<ViewBox> m_fallback_view_box_for_svg_as_image;
 
-    JS::GCPtr<SVGAnimatedRect> m_view_box_for_bindings;
+    GC::Ptr<SVGAnimatedRect> m_view_box_for_bindings;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGScriptElement.cpp b/Libraries/LibWeb/SVG/SVGScriptElement.cpp
index 35aea884701..4bf97b9d40b 100644
--- a/Libraries/LibWeb/SVG/SVGScriptElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGScriptElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGScriptElement);
+GC_DEFINE_ALLOCATOR(SVGScriptElement);
 
 SVGScriptElement::SVGScriptElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
@@ -61,7 +61,7 @@ void SVGScriptElement::process_the_script_element()
     // https://html.spec.whatwg.org/multipage/document-lifecycle.html#read-html
     // Before any script execution occurs, the user agent must wait for scripts may run for the newly-created document to be true for document.
     if (!m_document->ready_to_run_scripts())
-        HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap(), [&] { return m_document->ready_to_run_scripts(); }));
+        HTML::main_thread_event_loop().spin_until(GC::create_function(heap(), [&] { return m_document->ready_to_run_scripts(); }));
 
     // FIXME: Support non-inline scripts.
     auto base_url = document().base_url();
diff --git a/Libraries/LibWeb/SVG/SVGScriptElement.h b/Libraries/LibWeb/SVG/SVGScriptElement.h
index a8e0ba1e7fa..3815d104a85 100644
--- a/Libraries/LibWeb/SVG/SVGScriptElement.h
+++ b/Libraries/LibWeb/SVG/SVGScriptElement.h
@@ -16,7 +16,7 @@ class SVGScriptElement
     : public SVGElement
     , public SVGURIReferenceMixin<SupportsXLinkHref::Yes> {
     WEB_PLATFORM_OBJECT(SVGScriptElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGScriptElement);
+    GC_DECLARE_ALLOCATOR(SVGScriptElement);
 
 public:
     void process_the_script_element();
@@ -35,7 +35,7 @@ private:
 
     bool m_already_processed { false };
 
-    JS::GCPtr<HTML::ClassicScript> m_script;
+    GC::Ptr<HTML::ClassicScript> m_script;
 
     size_t m_source_line_number { 1 };
 };
diff --git a/Libraries/LibWeb/SVG/SVGStopElement.cpp b/Libraries/LibWeb/SVG/SVGStopElement.cpp
index 595076f691a..b51cac542b9 100644
--- a/Libraries/LibWeb/SVG/SVGStopElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGStopElement.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGStopElement);
+GC_DEFINE_ALLOCATOR(SVGStopElement);
 
 SVGStopElement::SVGStopElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, qualified_name)
@@ -61,7 +61,7 @@ float SVGStopElement::stop_opacity() const
     return 1;
 }
 
-JS::NonnullGCPtr<SVGAnimatedNumber> SVGStopElement::offset() const
+GC::Ref<SVGAnimatedNumber> SVGStopElement::offset() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedNumber::create(realm(), 0, 0);
diff --git a/Libraries/LibWeb/SVG/SVGStopElement.h b/Libraries/LibWeb/SVG/SVGStopElement.h
index 9dd3418b56b..79d26682cd9 100644
--- a/Libraries/LibWeb/SVG/SVGStopElement.h
+++ b/Libraries/LibWeb/SVG/SVGStopElement.h
@@ -16,14 +16,14 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/pservers.html#GradientStops
 class SVGStopElement final : public SVGElement {
     WEB_PLATFORM_OBJECT(SVGStopElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGStopElement);
+    GC_DECLARE_ALLOCATOR(SVGStopElement);
 
 public:
     virtual ~SVGStopElement() override = default;
 
     virtual void attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_) override;
 
-    JS::NonnullGCPtr<SVGAnimatedNumber> offset() const;
+    GC::Ref<SVGAnimatedNumber> offset() const;
 
     virtual void apply_presentational_hints(CSS::StyleProperties&) const override;
 
diff --git a/Libraries/LibWeb/SVG/SVGStyleElement.cpp b/Libraries/LibWeb/SVG/SVGStyleElement.cpp
index 7e41c25b3b1..e7d0dcacecb 100644
--- a/Libraries/LibWeb/SVG/SVGStyleElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGStyleElement.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGStyleElement);
+GC_DEFINE_ALLOCATOR(SVGStyleElement);
 
 SVGStyleElement::SVGStyleElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
diff --git a/Libraries/LibWeb/SVG/SVGStyleElement.h b/Libraries/LibWeb/SVG/SVGStyleElement.h
index 7085571b256..21e650dc464 100644
--- a/Libraries/LibWeb/SVG/SVGStyleElement.h
+++ b/Libraries/LibWeb/SVG/SVGStyleElement.h
@@ -13,7 +13,7 @@ namespace Web::SVG {
 
 class SVGStyleElement final : public SVGElement {
     WEB_PLATFORM_OBJECT(SVGStyleElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGStyleElement);
+    GC_DECLARE_ALLOCATOR(SVGStyleElement);
 
 public:
     virtual ~SVGStyleElement() override;
diff --git a/Libraries/LibWeb/SVG/SVGSymbolElement.cpp b/Libraries/LibWeb/SVG/SVGSymbolElement.cpp
index fefc3be7663..f940d3a1af4 100644
--- a/Libraries/LibWeb/SVG/SVGSymbolElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGSymbolElement.cpp
@@ -19,7 +19,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGSymbolElement);
+GC_DEFINE_ALLOCATOR(SVGSymbolElement);
 
 SVGSymbolElement::SVGSymbolElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, qualified_name)
@@ -75,7 +75,7 @@ bool SVGSymbolElement::is_direct_child_of_use_shadow_tree() const
     return is<SVGUseElement>(host);
 }
 
-JS::GCPtr<Layout::Node> SVGSymbolElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGSymbolElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGGraphicsBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGSymbolElement.h b/Libraries/LibWeb/SVG/SVGSymbolElement.h
index e416753c346..47caa47873c 100644
--- a/Libraries/LibWeb/SVG/SVGSymbolElement.h
+++ b/Libraries/LibWeb/SVG/SVGSymbolElement.h
@@ -14,7 +14,7 @@ namespace Web::SVG {
 class SVGSymbolElement final : public SVGGraphicsElement
     , public SVGViewport {
     WEB_PLATFORM_OBJECT(SVGSymbolElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGSymbolElement);
+    GC_DECLARE_ALLOCATOR(SVGSymbolElement);
 
 public:
     virtual ~SVGSymbolElement() override = default;
@@ -28,7 +28,7 @@ public:
         return {};
     }
 
-    JS::NonnullGCPtr<SVGAnimatedRect> view_box_for_bindings() { return *m_view_box_for_bindings; }
+    GC::Ref<SVGAnimatedRect> view_box_for_bindings() { return *m_view_box_for_bindings; }
 
 private:
     SVGSymbolElement(DOM::Document&, DOM::QualifiedName);
@@ -36,7 +36,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     bool is_direct_child_of_use_shadow_tree() const;
 
@@ -44,7 +44,7 @@ private:
 
     Optional<ViewBox> m_view_box;
 
-    JS::GCPtr<SVGAnimatedRect> m_view_box_for_bindings;
+    GC::Ptr<SVGAnimatedRect> m_view_box_for_bindings;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGTSpanElement.cpp b/Libraries/LibWeb/SVG/SVGTSpanElement.cpp
index 0d2dbfc946e..90e42ba2d8a 100644
--- a/Libraries/LibWeb/SVG/SVGTSpanElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGTSpanElement.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTSpanElement);
+GC_DEFINE_ALLOCATOR(SVGTSpanElement);
 
 SVGTSpanElement::SVGTSpanElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGTextPositioningElement(document, move(qualified_name))
@@ -24,7 +24,7 @@ void SVGTSpanElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGTSpanElement);
 }
 
-JS::GCPtr<Layout::Node> SVGTSpanElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGTSpanElement::create_layout_node(CSS::StyleProperties style)
 {
     // Text must be within an SVG <text> element.
     if (shadow_including_first_ancestor_of_type<SVGTextElement>())
diff --git a/Libraries/LibWeb/SVG/SVGTSpanElement.h b/Libraries/LibWeb/SVG/SVGTSpanElement.h
index 358daffe9b5..17eba7f85ea 100644
--- a/Libraries/LibWeb/SVG/SVGTSpanElement.h
+++ b/Libraries/LibWeb/SVG/SVGTSpanElement.h
@@ -14,10 +14,10 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/text.html#InterfaceSVGTSpanElement
 class SVGTSpanElement : public SVGTextPositioningElement {
     WEB_PLATFORM_OBJECT(SVGTSpanElement, SVGTextPositioningElement);
-    JS_DECLARE_ALLOCATOR(SVGTSpanElement);
+    GC_DECLARE_ALLOCATOR(SVGTSpanElement);
 
 public:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
 protected:
     SVGTSpanElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGTextContentElement.cpp b/Libraries/LibWeb/SVG/SVGTextContentElement.cpp
index c5ac8496843..007eec244e9 100644
--- a/Libraries/LibWeb/SVG/SVGTextContentElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGTextContentElement.cpp
@@ -58,7 +58,7 @@ WebIDL::ExceptionOr<WebIDL::Long> SVGTextContentElement::get_number_of_chars() c
     return static_cast<WebIDL::Long>(chars.size());
 }
 
-JS::NonnullGCPtr<Geometry::DOMPoint> SVGTextContentElement::get_start_position_of_char(WebIDL::UnsignedLong charnum)
+GC::Ref<Geometry::DOMPoint> SVGTextContentElement::get_start_position_of_char(WebIDL::UnsignedLong charnum)
 {
     dbgln("(STUBBED) SVGTextContentElement::get_start_position_of_char(charnum={}). Called on: {}", charnum, debug_description());
     return Geometry::DOMPoint::from_point(vm(), Geometry::DOMPointInit {});
diff --git a/Libraries/LibWeb/SVG/SVGTextContentElement.h b/Libraries/LibWeb/SVG/SVGTextContentElement.h
index 1f0866eaa7d..aa88e428869 100644
--- a/Libraries/LibWeb/SVG/SVGTextContentElement.h
+++ b/Libraries/LibWeb/SVG/SVGTextContentElement.h
@@ -25,7 +25,7 @@ public:
 
     ByteString text_contents() const;
 
-    JS::NonnullGCPtr<Geometry::DOMPoint> get_start_position_of_char(WebIDL::UnsignedLong charnum);
+    GC::Ref<Geometry::DOMPoint> get_start_position_of_char(WebIDL::UnsignedLong charnum);
 
 protected:
     SVGTextContentElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGTextElement.cpp b/Libraries/LibWeb/SVG/SVGTextElement.cpp
index c2ce05d9a80..6bb9977e301 100644
--- a/Libraries/LibWeb/SVG/SVGTextElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGTextElement.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTextElement);
+GC_DEFINE_ALLOCATOR(SVGTextElement);
 
 SVGTextElement::SVGTextElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGTextPositioningElement(document, move(qualified_name))
@@ -23,7 +23,7 @@ void SVGTextElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGTextElement);
 }
 
-JS::GCPtr<Layout::Node> SVGTextElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGTextElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGTextBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGTextElement.h b/Libraries/LibWeb/SVG/SVGTextElement.h
index 65e4d0ff141..308f3ee1450 100644
--- a/Libraries/LibWeb/SVG/SVGTextElement.h
+++ b/Libraries/LibWeb/SVG/SVGTextElement.h
@@ -14,10 +14,10 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/text.html#InterfaceSVGTextElement
 class SVGTextElement : public SVGTextPositioningElement {
     WEB_PLATFORM_OBJECT(SVGTextElement, SVGTextPositioningElement);
-    JS_DECLARE_ALLOCATOR(SVGTextElement);
+    GC_DECLARE_ALLOCATOR(SVGTextElement);
 
 public:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
 protected:
     SVGTextElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGTextPathElement.cpp b/Libraries/LibWeb/SVG/SVGTextPathElement.cpp
index 073e0d79ea6..383da7a3210 100644
--- a/Libraries/LibWeb/SVG/SVGTextPathElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGTextPathElement.cpp
@@ -12,14 +12,14 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTextPathElement);
+GC_DEFINE_ALLOCATOR(SVGTextPathElement);
 
 SVGTextPathElement::SVGTextPathElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGTextContentElement(document, move(qualified_name))
 {
 }
 
-JS::GCPtr<SVGGeometryElement const> SVGTextPathElement::path_or_shape() const
+GC::Ptr<SVGGeometryElement const> SVGTextPathElement::path_or_shape() const
 {
     auto href = get_attribute(AttributeNames::href);
     if (!href.has_value())
@@ -40,7 +40,7 @@ void SVGTextPathElement::visit_edges(Cell::Visitor& visitor)
     SVGURIReferenceMixin::visit_edges(visitor);
 }
 
-JS::GCPtr<Layout::Node> SVGTextPathElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGTextPathElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGTextPathBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGTextPathElement.h b/Libraries/LibWeb/SVG/SVGTextPathElement.h
index 95c153dcc7d..aa445fb81c1 100644
--- a/Libraries/LibWeb/SVG/SVGTextPathElement.h
+++ b/Libraries/LibWeb/SVG/SVGTextPathElement.h
@@ -17,12 +17,12 @@ class SVGTextPathElement
     : public SVGTextContentElement
     , public SVGURIReferenceMixin<SupportsXLinkHref::Yes> {
     WEB_PLATFORM_OBJECT(SVGTextPathElement, SVGTextContentElement);
-    JS_DECLARE_ALLOCATOR(SVGTextPathElement);
+    GC_DECLARE_ALLOCATOR(SVGTextPathElement);
 
 public:
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
-    JS::GCPtr<SVGGeometryElement const> path_or_shape() const;
+    GC::Ptr<SVGGeometryElement const> path_or_shape() const;
 
 protected:
     SVGTextPathElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGTextPositioningElement.h b/Libraries/LibWeb/SVG/SVGTextPositioningElement.h
index 549865e4571..c2e5fdf746c 100644
--- a/Libraries/LibWeb/SVG/SVGTextPositioningElement.h
+++ b/Libraries/LibWeb/SVG/SVGTextPositioningElement.h
@@ -20,10 +20,10 @@ public:
 
     Gfx::FloatPoint get_offset(CSSPixelSize const& viewport_size) const;
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> dx() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> dy() const;
+    GC::Ref<SVGAnimatedLength> x() const;
+    GC::Ref<SVGAnimatedLength> y() const;
+    GC::Ref<SVGAnimatedLength> dx() const;
+    GC::Ref<SVGAnimatedLength> dy() const;
 
 protected:
     SVGTextPositioningElement(DOM::Document&, DOM::QualifiedName);
diff --git a/Libraries/LibWeb/SVG/SVGTitleElement.cpp b/Libraries/LibWeb/SVG/SVGTitleElement.cpp
index 3af95755173..6522193b8b2 100644
--- a/Libraries/LibWeb/SVG/SVGTitleElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGTitleElement.cpp
@@ -12,7 +12,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTitleElement);
+GC_DEFINE_ALLOCATOR(SVGTitleElement);
 
 SVGTitleElement::SVGTitleElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGElement(document, move(qualified_name))
@@ -25,7 +25,7 @@ void SVGTitleElement::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGTitleElement);
 }
 
-JS::GCPtr<Layout::Node> SVGTitleElement::create_layout_node(CSS::StyleProperties)
+GC::Ptr<Layout::Node> SVGTitleElement::create_layout_node(CSS::StyleProperties)
 {
     return nullptr;
 }
diff --git a/Libraries/LibWeb/SVG/SVGTitleElement.h b/Libraries/LibWeb/SVG/SVGTitleElement.h
index 48d5f926ee1..619f21e1af5 100644
--- a/Libraries/LibWeb/SVG/SVGTitleElement.h
+++ b/Libraries/LibWeb/SVG/SVGTitleElement.h
@@ -12,14 +12,14 @@ namespace Web::SVG {
 
 class SVGTitleElement final : public SVGElement {
     WEB_PLATFORM_OBJECT(SVGTitleElement, SVGElement);
-    JS_DECLARE_ALLOCATOR(SVGTitleElement);
+    GC_DECLARE_ALLOCATOR(SVGTitleElement);
 
 private:
     SVGTitleElement(DOM::Document&, DOM::QualifiedName);
 
     virtual void initialize(JS::Realm&) override;
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
     virtual void children_changed() override;
 };
 
diff --git a/Libraries/LibWeb/SVG/SVGTransform.cpp b/Libraries/LibWeb/SVG/SVGTransform.cpp
index 2baf8f3be27..c2580a4ea94 100644
--- a/Libraries/LibWeb/SVG/SVGTransform.cpp
+++ b/Libraries/LibWeb/SVG/SVGTransform.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTransform);
+GC_DEFINE_ALLOCATOR(SVGTransform);
 
-JS::NonnullGCPtr<SVGTransform> SVGTransform::create(JS::Realm& realm)
+GC::Ref<SVGTransform> SVGTransform::create(JS::Realm& realm)
 {
     return realm.create<SVGTransform>(realm);
 }
diff --git a/Libraries/LibWeb/SVG/SVGTransform.h b/Libraries/LibWeb/SVG/SVGTransform.h
index a6f8c91c7fa..642c3cf1724 100644
--- a/Libraries/LibWeb/SVG/SVGTransform.h
+++ b/Libraries/LibWeb/SVG/SVGTransform.h
@@ -15,10 +15,10 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/single-page.html#coords-InterfaceSVGTransform
 class SVGTransform final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGTransform, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGTransform);
+    GC_DECLARE_ALLOCATOR(SVGTransform);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGTransform> create(JS::Realm& realm);
+    [[nodiscard]] static GC::Ref<SVGTransform> create(JS::Realm& realm);
     virtual ~SVGTransform() override;
 
     enum class Type : u16 {
diff --git a/Libraries/LibWeb/SVG/SVGTransformList.cpp b/Libraries/LibWeb/SVG/SVGTransformList.cpp
index 4b60ddee954..7a81e40c555 100644
--- a/Libraries/LibWeb/SVG/SVGTransformList.cpp
+++ b/Libraries/LibWeb/SVG/SVGTransformList.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGTransformList);
+GC_DEFINE_ALLOCATOR(SVGTransformList);
 
-JS::NonnullGCPtr<SVGTransformList> SVGTransformList::create(JS::Realm& realm)
+GC::Ref<SVGTransformList> SVGTransformList::create(JS::Realm& realm)
 {
     return realm.create<SVGTransformList>(realm);
 }
@@ -40,7 +40,7 @@ WebIDL::UnsignedLong SVGTransformList::number_of_items()
 }
 
 // https://svgwg.org/svg2-draft/single-page.html#types-__svg__SVGNameList__getItem
-WebIDL::ExceptionOr<JS::NonnullGCPtr<SVGTransform>> SVGTransformList::get_item(WebIDL::UnsignedLong index)
+WebIDL::ExceptionOr<GC::Ref<SVGTransform>> SVGTransformList::get_item(WebIDL::UnsignedLong index)
 {
     // 1. If index is greater than or equal to the length of the list, then throw an IndexSizeError.
     if (index >= m_transforms.size())
@@ -50,7 +50,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<SVGTransform>> SVGTransformList::get_item(W
 }
 
 // https://svgwg.org/svg2-draft/single-page.html#types-__svg__SVGNameList__appendItem
-JS::NonnullGCPtr<SVGTransform> SVGTransformList::append_item(JS::NonnullGCPtr<SVGTransform> new_item)
+GC::Ref<SVGTransform> SVGTransformList::append_item(GC::Ref<SVGTransform> new_item)
 {
     // FIXME: This does not implement the steps from the specification.
     m_transforms.append(new_item);
diff --git a/Libraries/LibWeb/SVG/SVGTransformList.h b/Libraries/LibWeb/SVG/SVGTransformList.h
index a182a3b1b1c..93822f32036 100644
--- a/Libraries/LibWeb/SVG/SVGTransformList.h
+++ b/Libraries/LibWeb/SVG/SVGTransformList.h
@@ -16,18 +16,18 @@ namespace Web::SVG {
 // https://svgwg.org/svg2-draft/single-page.html#coords-InterfaceSVGTransformList
 class SVGTransformList final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(SVGTransformList, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(SVGTransformList);
+    GC_DECLARE_ALLOCATOR(SVGTransformList);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<SVGTransformList> create(JS::Realm& realm);
+    [[nodiscard]] static GC::Ref<SVGTransformList> create(JS::Realm& realm);
     virtual ~SVGTransformList() override;
 
     WebIDL::UnsignedLong length();
     WebIDL::UnsignedLong number_of_items();
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<SVGTransform>> get_item(WebIDL::UnsignedLong index);
+    WebIDL::ExceptionOr<GC::Ref<SVGTransform>> get_item(WebIDL::UnsignedLong index);
 
-    JS::NonnullGCPtr<SVGTransform> append_item(JS::NonnullGCPtr<SVGTransform> new_item);
+    GC::Ref<SVGTransform> append_item(GC::Ref<SVGTransform> new_item);
 
 private:
     SVGTransformList(JS::Realm& realm);
@@ -35,7 +35,7 @@ private:
     virtual void initialize(JS::Realm& realm) override;
     virtual void visit_edges(Cell::Visitor& visitor) override;
 
-    Vector<JS::NonnullGCPtr<SVGTransform>> m_transforms;
+    Vector<GC::Ref<SVGTransform>> m_transforms;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGURIReference.h b/Libraries/LibWeb/SVG/SVGURIReference.h
index 46658367d86..9377c99011e 100644
--- a/Libraries/LibWeb/SVG/SVGURIReference.h
+++ b/Libraries/LibWeb/SVG/SVGURIReference.h
@@ -22,7 +22,7 @@ class SVGURIReferenceMixin {
 public:
     virtual ~SVGURIReferenceMixin() = default;
 
-    JS::NonnullGCPtr<SVGAnimatedString> href()
+    GC::Ref<SVGAnimatedString> href()
     {
         // The href IDL attribute represents the value of the ‘href’ attribute, and, on elements that are defined to support
         // it, the deprecated ‘xlink:href’ attribute. On getting href, an SVGAnimatedString object is returned that:
@@ -44,7 +44,7 @@ protected:
     }
 
 private:
-    JS::GCPtr<SVGAnimatedString> m_href_animated_string;
+    GC::Ptr<SVGAnimatedString> m_href_animated_string;
 };
 
 }
diff --git a/Libraries/LibWeb/SVG/SVGUseElement.cpp b/Libraries/LibWeb/SVG/SVGUseElement.cpp
index 85f331e0df5..0528df5e2a4 100644
--- a/Libraries/LibWeb/SVG/SVGUseElement.cpp
+++ b/Libraries/LibWeb/SVG/SVGUseElement.cpp
@@ -23,7 +23,7 @@
 
 namespace Web::SVG {
 
-JS_DEFINE_ALLOCATOR(SVGUseElement);
+GC_DEFINE_ALLOCATOR(SVGUseElement);
 
 SVGUseElement::SVGUseElement(DOM::Document& document, DOM::QualifiedName qualified_name)
     : SVGGraphicsElement(document, qualified_name)
@@ -131,7 +131,7 @@ void SVGUseElement::svg_element_removed(SVGElement& svg_element)
 }
 
 // https://svgwg.org/svg2-draft/linking.html#processingURL-target
-JS::GCPtr<DOM::Element> SVGUseElement::referenced_element()
+GC::Ptr<DOM::Element> SVGUseElement::referenced_element()
 {
     if (!m_href.is_valid())
         return nullptr;
@@ -193,7 +193,7 @@ bool SVGUseElement::is_valid_reference_element(Element const& reference_element)
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementXAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::x() const
+GC::Ref<SVGAnimatedLength> SVGUseElement::x() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -203,7 +203,7 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::x() const
 }
 
 // https://www.w3.org/TR/SVG11/shapes.html#RectElementYAttribute
-JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::y() const
+GC::Ref<SVGAnimatedLength> SVGUseElement::y() const
 {
     // FIXME: Populate the unit type when it is parsed (0 here is "unknown").
     // FIXME: Create a proper animated value when animations are supported.
@@ -212,30 +212,30 @@ JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::y() const
     return SVGAnimatedLength::create(realm(), move(base_length), move(anim_length));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::width() const
+GC::Ref<SVGAnimatedLength> SVGUseElement::width() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
-JS::NonnullGCPtr<SVGAnimatedLength> SVGUseElement::height() const
+GC::Ref<SVGAnimatedLength> SVGUseElement::height() const
 {
     // FIXME: Implement this properly.
     return SVGAnimatedLength::create(realm(), SVGLength::create(realm(), 0, 0), SVGLength::create(realm(), 0, 0));
 }
 
 // https://svgwg.org/svg2-draft/struct.html#TermInstanceRoot
-JS::GCPtr<SVGElement> SVGUseElement::instance_root() const
+GC::Ptr<SVGElement> SVGUseElement::instance_root() const
 {
     return const_cast<DOM::ShadowRoot&>(*shadow_root()).first_child_of_type<SVGElement>();
 }
 
-JS::GCPtr<SVGElement> SVGUseElement::animated_instance_root() const
+GC::Ptr<SVGElement> SVGUseElement::animated_instance_root() const
 {
     return instance_root();
 }
 
-JS::GCPtr<Layout::Node> SVGUseElement::create_layout_node(CSS::StyleProperties style)
+GC::Ptr<Layout::Node> SVGUseElement::create_layout_node(CSS::StyleProperties style)
 {
     return heap().allocate<Layout::SVGGraphicsBox>(document(), *this, move(style));
 }
diff --git a/Libraries/LibWeb/SVG/SVGUseElement.h b/Libraries/LibWeb/SVG/SVGUseElement.h
index 7ec7efc223e..cf0b5211362 100644
--- a/Libraries/LibWeb/SVG/SVGUseElement.h
+++ b/Libraries/LibWeb/SVG/SVGUseElement.h
@@ -19,7 +19,7 @@ class SVGUseElement final
     : public SVGGraphicsElement
     , public SVGURIReferenceMixin<SupportsXLinkHref::Yes> {
     WEB_PLATFORM_OBJECT(SVGUseElement, SVGGraphicsElement);
-    JS_DECLARE_ALLOCATOR(SVGUseElement);
+    GC_DECLARE_ALLOCATOR(SVGUseElement);
 
 public:
     virtual ~SVGUseElement() override = default;
@@ -31,13 +31,13 @@ public:
     void svg_element_changed(SVGElement&);
     void svg_element_removed(SVGElement&);
 
-    JS::NonnullGCPtr<SVGAnimatedLength> x() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> y() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> width() const;
-    JS::NonnullGCPtr<SVGAnimatedLength> height() const;
+    GC::Ref<SVGAnimatedLength> x() const;
+    GC::Ref<SVGAnimatedLength> y() const;
+    GC::Ref<SVGAnimatedLength> width() const;
+    GC::Ref<SVGAnimatedLength> height() const;
 
-    JS::GCPtr<SVGElement> instance_root() const;
-    JS::GCPtr<SVGElement> animated_instance_root() const;
+    GC::Ptr<SVGElement> instance_root() const;
+    GC::Ptr<SVGElement> animated_instance_root() const;
 
     virtual Gfx::AffineTransform element_transform() const override;
 
@@ -49,13 +49,13 @@ private:
 
     virtual bool is_svg_use_element() const override { return true; }
 
-    virtual JS::GCPtr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
+    virtual GC::Ptr<Layout::Node> create_layout_node(CSS::StyleProperties) override;
 
     void process_the_url(Optional<String> const& href);
 
     static Optional<FlyString> parse_id_from_href(StringView);
 
-    JS::GCPtr<DOM::Element> referenced_element();
+    GC::Ptr<DOM::Element> referenced_element();
 
     void fetch_the_document(URL::URL const& url);
     bool is_referrenced_element_same_document() const;
@@ -68,8 +68,8 @@ private:
 
     URL::URL m_href;
 
-    JS::GCPtr<DOM::DocumentObserver> m_document_observer;
-    JS::GCPtr<HTML::SharedResourceRequest> m_resource_request;
+    GC::Ptr<DOM::DocumentObserver> m_document_observer;
+    GC::Ptr<HTML::SharedResourceRequest> m_resource_request;
     Optional<DOM::DocumentLoadEventDelayer> m_load_event_delayer;
 };
 
diff --git a/Libraries/LibWeb/Selection/Selection.cpp b/Libraries/LibWeb/Selection/Selection.cpp
index af84f872e72..b29f6e5e7c8 100644
--- a/Libraries/LibWeb/Selection/Selection.cpp
+++ b/Libraries/LibWeb/Selection/Selection.cpp
@@ -15,14 +15,14 @@
 
 namespace Web::Selection {
 
-JS_DEFINE_ALLOCATOR(Selection);
+GC_DEFINE_ALLOCATOR(Selection);
 
-JS::NonnullGCPtr<Selection> Selection::create(JS::NonnullGCPtr<JS::Realm> realm, JS::NonnullGCPtr<DOM::Document> document)
+GC::Ref<Selection> Selection::create(GC::Ref<JS::Realm> realm, GC::Ref<DOM::Document> document)
 {
     return realm->create<Selection>(realm, document);
 }
 
-Selection::Selection(JS::NonnullGCPtr<JS::Realm> realm, JS::NonnullGCPtr<DOM::Document> document)
+Selection::Selection(GC::Ref<JS::Realm> realm, GC::Ref<DOM::Document> document)
     : PlatformObject(realm)
     , m_document(document)
 {
@@ -55,7 +55,7 @@ void Selection::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://w3c.github.io/selection-api/#dfn-anchor
-JS::GCPtr<DOM::Node> Selection::anchor_node()
+GC::Ptr<DOM::Node> Selection::anchor_node()
 {
     if (!m_range)
         return nullptr;
@@ -75,7 +75,7 @@ unsigned Selection::anchor_offset()
 }
 
 // https://w3c.github.io/selection-api/#dfn-focus
-JS::GCPtr<DOM::Node> Selection::focus_node()
+GC::Ptr<DOM::Node> Selection::focus_node()
 {
     if (!m_range)
         return nullptr;
@@ -132,7 +132,7 @@ String Selection::direction() const
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-getrangeat
-WebIDL::ExceptionOr<JS::GCPtr<DOM::Range>> Selection::get_range_at(unsigned index)
+WebIDL::ExceptionOr<GC::Ptr<DOM::Range>> Selection::get_range_at(unsigned index)
 {
     // The method must throw an IndexSizeError exception if index is not 0, or if this is empty.
     if (index != 0 || is_empty())
@@ -143,7 +143,7 @@ WebIDL::ExceptionOr<JS::GCPtr<DOM::Range>> Selection::get_range_at(unsigned inde
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-addrange
-void Selection::add_range(JS::NonnullGCPtr<DOM::Range> range)
+void Selection::add_range(GC::Ref<DOM::Range> range)
 {
     // 1. If the root of the range's boundary points are not the document associated with this, abort these steps.
     if (&range->start_container()->root() != m_document.ptr())
@@ -161,7 +161,7 @@ void Selection::add_range(JS::NonnullGCPtr<DOM::Range> range)
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-removerange
-WebIDL::ExceptionOr<void> Selection::remove_range(JS::NonnullGCPtr<DOM::Range> range)
+WebIDL::ExceptionOr<void> Selection::remove_range(GC::Ref<DOM::Range> range)
 {
     // The method must make this empty by disassociating its range if this's range is range.
     if (m_range == range) {
@@ -188,7 +188,7 @@ void Selection::empty()
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-collapse
-WebIDL::ExceptionOr<void> Selection::collapse(JS::GCPtr<DOM::Node> node, unsigned offset)
+WebIDL::ExceptionOr<void> Selection::collapse(GC::Ptr<DOM::Node> node, unsigned offset)
 {
     // 1. If node is null, this method must behave identically as removeAllRanges() and abort these steps.
     if (!node) {
@@ -218,7 +218,7 @@ WebIDL::ExceptionOr<void> Selection::collapse(JS::GCPtr<DOM::Node> node, unsigne
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-setposition
-WebIDL::ExceptionOr<void> Selection::set_position(JS::GCPtr<DOM::Node> node, unsigned offset)
+WebIDL::ExceptionOr<void> Selection::set_position(GC::Ptr<DOM::Node> node, unsigned offset)
 {
     // The method must be an alias, and behave identically, to collapse().
     return collapse(node, offset);
@@ -266,7 +266,7 @@ WebIDL::ExceptionOr<void> Selection::collapse_to_end()
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-extend
-WebIDL::ExceptionOr<void> Selection::extend(JS::NonnullGCPtr<DOM::Node> node, unsigned offset)
+WebIDL::ExceptionOr<void> Selection::extend(GC::Ref<DOM::Node> node, unsigned offset)
 {
     // 1. If the document associated with this is not a shadow-including inclusive ancestor of node, abort these steps.
     if (!m_document->is_shadow_including_inclusive_ancestor_of(node))
@@ -317,7 +317,7 @@ WebIDL::ExceptionOr<void> Selection::extend(JS::NonnullGCPtr<DOM::Node> node, un
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-setbaseandextent
-WebIDL::ExceptionOr<void> Selection::set_base_and_extent(JS::NonnullGCPtr<DOM::Node> anchor_node, unsigned anchor_offset, JS::NonnullGCPtr<DOM::Node> focus_node, unsigned focus_offset)
+WebIDL::ExceptionOr<void> Selection::set_base_and_extent(GC::Ref<DOM::Node> anchor_node, unsigned anchor_offset, GC::Ref<DOM::Node> focus_node, unsigned focus_offset)
 {
     // 1. If anchorOffset is longer than anchorNode's length or if focusOffset is longer than focusNode's length, throw an IndexSizeError exception and abort these steps.
     if (anchor_offset > anchor_node->length())
@@ -359,7 +359,7 @@ WebIDL::ExceptionOr<void> Selection::set_base_and_extent(JS::NonnullGCPtr<DOM::N
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-selectallchildren
-WebIDL::ExceptionOr<void> Selection::select_all_children(JS::NonnullGCPtr<DOM::Node> node)
+WebIDL::ExceptionOr<void> Selection::select_all_children(GC::Ref<DOM::Node> node)
 {
     // 1. If node's root is not the document associated with this, abort these steps.
     if (&node->root() != m_document.ptr())
@@ -395,7 +395,7 @@ WebIDL::ExceptionOr<void> Selection::delete_from_document()
 }
 
 // https://w3c.github.io/selection-api/#dom-selection-containsnode
-bool Selection::contains_node(JS::NonnullGCPtr<DOM::Node> node, bool allow_partial_containment) const
+bool Selection::contains_node(GC::Ref<DOM::Node> node, bool allow_partial_containment) const
 {
     // The method must return false if this is empty or if node's root is not the document associated with this.
     if (!m_range)
@@ -450,17 +450,17 @@ String Selection::to_string() const
     return m_range->to_string();
 }
 
-JS::NonnullGCPtr<DOM::Document> Selection::document() const
+GC::Ref<DOM::Document> Selection::document() const
 {
     return m_document;
 }
 
-JS::GCPtr<DOM::Range> Selection::range() const
+GC::Ptr<DOM::Range> Selection::range() const
 {
     return m_range;
 }
 
-void Selection::set_range(JS::GCPtr<DOM::Range> range)
+void Selection::set_range(GC::Ptr<DOM::Range> range)
 {
     if (m_range == range)
         return;
@@ -474,7 +474,7 @@ void Selection::set_range(JS::GCPtr<DOM::Range> range)
         m_range->set_associated_selection({}, this);
 }
 
-JS::GCPtr<DOM::Position> Selection::cursor_position() const
+GC::Ptr<DOM::Position> Selection::cursor_position() const
 {
     if (!m_range)
         return nullptr;
diff --git a/Libraries/LibWeb/Selection/Selection.h b/Libraries/LibWeb/Selection/Selection.h
index af0006b3682..dfeab275ff6 100644
--- a/Libraries/LibWeb/Selection/Selection.h
+++ b/Libraries/LibWeb/Selection/Selection.h
@@ -13,10 +13,10 @@ namespace Web::Selection {
 
 class Selection final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Selection, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Selection);
+    GC_DECLARE_ALLOCATOR(Selection);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<Selection> create(JS::NonnullGCPtr<JS::Realm>, JS::NonnullGCPtr<DOM::Document>);
+    [[nodiscard]] static GC::Ref<Selection> create(GC::Ref<JS::Realm>, GC::Ref<DOM::Document>);
 
     virtual ~Selection() override;
 
@@ -26,40 +26,40 @@ public:
         Directionless,
     };
 
-    JS::GCPtr<DOM::Node> anchor_node();
+    GC::Ptr<DOM::Node> anchor_node();
     unsigned anchor_offset();
-    JS::GCPtr<DOM::Node> focus_node();
+    GC::Ptr<DOM::Node> focus_node();
     unsigned focus_offset() const;
     bool is_collapsed() const;
     unsigned range_count() const;
     String type() const;
     String direction() const;
-    WebIDL::ExceptionOr<JS::GCPtr<DOM::Range>> get_range_at(unsigned index);
-    void add_range(JS::NonnullGCPtr<DOM::Range>);
-    WebIDL::ExceptionOr<void> remove_range(JS::NonnullGCPtr<DOM::Range>);
+    WebIDL::ExceptionOr<GC::Ptr<DOM::Range>> get_range_at(unsigned index);
+    void add_range(GC::Ref<DOM::Range>);
+    WebIDL::ExceptionOr<void> remove_range(GC::Ref<DOM::Range>);
     void remove_all_ranges();
     void empty();
-    WebIDL::ExceptionOr<void> collapse(JS::GCPtr<DOM::Node>, unsigned offset);
-    WebIDL::ExceptionOr<void> set_position(JS::GCPtr<DOM::Node>, unsigned offset);
+    WebIDL::ExceptionOr<void> collapse(GC::Ptr<DOM::Node>, unsigned offset);
+    WebIDL::ExceptionOr<void> set_position(GC::Ptr<DOM::Node>, unsigned offset);
     WebIDL::ExceptionOr<void> collapse_to_start();
     WebIDL::ExceptionOr<void> collapse_to_end();
-    WebIDL::ExceptionOr<void> extend(JS::NonnullGCPtr<DOM::Node>, unsigned offset);
-    WebIDL::ExceptionOr<void> set_base_and_extent(JS::NonnullGCPtr<DOM::Node> anchor_node, unsigned anchor_offset, JS::NonnullGCPtr<DOM::Node> focus_node, unsigned focus_offset);
-    WebIDL::ExceptionOr<void> select_all_children(JS::NonnullGCPtr<DOM::Node>);
+    WebIDL::ExceptionOr<void> extend(GC::Ref<DOM::Node>, unsigned offset);
+    WebIDL::ExceptionOr<void> set_base_and_extent(GC::Ref<DOM::Node> anchor_node, unsigned anchor_offset, GC::Ref<DOM::Node> focus_node, unsigned focus_offset);
+    WebIDL::ExceptionOr<void> select_all_children(GC::Ref<DOM::Node>);
     WebIDL::ExceptionOr<void>
     delete_from_document();
-    bool contains_node(JS::NonnullGCPtr<DOM::Node>, bool allow_partial_containment) const;
+    bool contains_node(GC::Ref<DOM::Node>, bool allow_partial_containment) const;
 
     String to_string() const;
 
     // Non-standard convenience accessor for the selection's range.
-    JS::GCPtr<DOM::Range> range() const;
+    GC::Ptr<DOM::Range> range() const;
 
     // Non-standard accessor for the selection's document.
-    JS::NonnullGCPtr<DOM::Document> document() const;
+    GC::Ref<DOM::Document> document() const;
 
     // Non-standard
-    JS::GCPtr<DOM::Position> cursor_position() const;
+    GC::Ptr<DOM::Position> cursor_position() const;
 
     // Non-standard
     void move_offset_to_next_character(bool collapse_selection);
@@ -68,19 +68,19 @@ public:
     void move_offset_to_previous_word(bool collapse_selection);
 
 private:
-    Selection(JS::NonnullGCPtr<JS::Realm>, JS::NonnullGCPtr<DOM::Document>);
+    Selection(GC::Ref<JS::Realm>, GC::Ref<DOM::Document>);
 
     [[nodiscard]] bool is_empty() const;
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    void set_range(JS::GCPtr<DOM::Range>);
+    void set_range(GC::Ptr<DOM::Range>);
 
     // https://w3c.github.io/selection-api/#dfn-empty
-    JS::GCPtr<DOM::Range> m_range;
+    GC::Ptr<DOM::Range> m_range;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
+    GC::Ref<DOM::Document> m_document;
     Direction m_direction { Direction::Directionless };
 };
 
diff --git a/Libraries/LibWeb/ServiceWorker/Job.cpp b/Libraries/LibWeb/ServiceWorker/Job.cpp
index 9607cac5e6a..f50b835b131 100644
--- a/Libraries/LibWeb/ServiceWorker/Job.cpp
+++ b/Libraries/LibWeb/ServiceWorker/Job.cpp
@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/VM.h>
 #include <LibURL/URL.h>
 #include <LibWeb/DOMURL/DOMURL.h>
@@ -26,23 +26,23 @@
 namespace Web::ServiceWorker {
 
 static void run_job(JS::VM&, JobQueue&);
-static void finish_job(JS::VM&, JS::NonnullGCPtr<Job>);
-static void resolve_job_promise(JS::NonnullGCPtr<Job>, Optional<Registration const&>, JS::Value = JS::js_null());
+static void finish_job(JS::VM&, GC::Ref<Job>);
+static void resolve_job_promise(GC::Ref<Job>, Optional<Registration const&>, JS::Value = JS::js_null());
 template<typename Error>
-static void reject_job_promise(JS::NonnullGCPtr<Job>, String message);
-static void register_(JS::VM&, JS::NonnullGCPtr<Job>);
-static void update(JS::VM&, JS::NonnullGCPtr<Job>);
-static void unregister(JS::VM&, JS::NonnullGCPtr<Job>);
+static void reject_job_promise(GC::Ref<Job>, String message);
+static void register_(JS::VM&, GC::Ref<Job>);
+static void update(JS::VM&, GC::Ref<Job>);
+static void unregister(JS::VM&, GC::Ref<Job>);
 
-JS_DEFINE_ALLOCATOR(Job);
+GC_DEFINE_ALLOCATOR(Job);
 
 // https://w3c.github.io/ServiceWorker/#create-job-algorithm
-JS::NonnullGCPtr<Job> Job::create(JS::VM& vm, Job::Type type, StorageAPI::StorageKey storage_key, URL::URL scope_url, URL::URL script_url, JS::GCPtr<WebIDL::Promise> promise, JS::GCPtr<HTML::EnvironmentSettingsObject> client)
+GC::Ref<Job> Job::create(JS::VM& vm, Job::Type type, StorageAPI::StorageKey storage_key, URL::URL scope_url, URL::URL script_url, GC::Ptr<WebIDL::Promise> promise, GC::Ptr<HTML::EnvironmentSettingsObject> client)
 {
     return vm.heap().allocate<Job>(type, move(storage_key), move(scope_url), move(script_url), promise, client);
 }
 
-Job::Job(Job::Type type, StorageAPI::StorageKey storage_key, URL::URL scope_url, URL::URL script_url, JS::GCPtr<WebIDL::Promise> promise, JS::GCPtr<HTML::EnvironmentSettingsObject> client)
+Job::Job(Job::Type type, StorageAPI::StorageKey storage_key, URL::URL scope_url, URL::URL script_url, GC::Ptr<WebIDL::Promise> promise, GC::Ptr<HTML::EnvironmentSettingsObject> client)
     : job_type(type)
     , storage_key(move(storage_key))
     , scope_url(move(scope_url))
@@ -76,7 +76,7 @@ static HashMap<ByteString, JobQueue>& scope_to_job_queue_map()
 }
 
 // https://w3c.github.io/ServiceWorker/#register-algorithm
-static void register_(JS::VM& vm, JS::NonnullGCPtr<Job> job)
+static void register_(JS::VM& vm, GC::Ref<Job> job)
 {
     auto script_origin = job->script_url.origin();
     auto scope_origin = job->scope_url.origin();
@@ -146,15 +146,15 @@ static void register_(JS::VM& vm, JS::NonnullGCPtr<Job> job)
 
 // Used to share internal Update algorithm state b/w fetch callbacks
 class UpdateAlgorithmState : JS::Cell {
-    JS_CELL(UpdateAlgorithmState, JS::Cell);
+    GC_CELL(UpdateAlgorithmState, JS::Cell);
 
 public:
-    static JS::NonnullGCPtr<UpdateAlgorithmState> create(JS::VM& vm)
+    static GC::Ref<UpdateAlgorithmState> create(JS::VM& vm)
     {
         return vm.heap().allocate<UpdateAlgorithmState>();
     }
 
-    OrderedHashMap<URL::URL, JS::NonnullGCPtr<Fetch::Infrastructure::Response>>& updated_resource_map() { return m_map; }
+    OrderedHashMap<URL::URL, GC::Ref<Fetch::Infrastructure::Response>>& updated_resource_map() { return m_map; }
     bool has_updated_resources() const { return m_has_updated_resources; }
     void set_has_updated_resources(bool b) { m_has_updated_resources = b; }
 
@@ -167,12 +167,12 @@ private:
         visitor.visit(m_map);
     }
 
-    OrderedHashMap<URL::URL, JS::NonnullGCPtr<Fetch::Infrastructure::Response>> m_map;
+    OrderedHashMap<URL::URL, GC::Ref<Fetch::Infrastructure::Response>> m_map;
     bool m_has_updated_resources { false };
 };
 
 // https://w3c.github.io/ServiceWorker/#update
-static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
+static void update(JS::VM& vm, GC::Ref<Job> job)
 {
     // 1. Let registration be the result of running Get Registration given job’s storage key and job’s scope url.
     auto registration = Registration::get(job->storage_key, job->scope_url);
@@ -209,7 +209,7 @@ static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
     // - Soft-Update has no client
 
     // To perform the fetch hook given request, run the following steps:
-    auto perform_the_fetch_hook_function = [&registration = *registration, job, newest_worker, state](JS::NonnullGCPtr<Fetch::Infrastructure::Request> request, HTML::TopLevelModule top_level, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction process_custom_fetch_response) -> WebIDL::ExceptionOr<void> {
+    auto perform_the_fetch_hook_function = [&registration = *registration, job, newest_worker, state](GC::Ref<Fetch::Infrastructure::Request> request, HTML::TopLevelModule top_level, Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction process_custom_fetch_response) -> WebIDL::ExceptionOr<void> {
         // FIXME: Soft-Update has no client
         auto& realm = job->client->realm();
         auto& vm = realm.vm();
@@ -252,7 +252,7 @@ static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
         //        Is this actually what the spec wants us to do?
         IGNORE_USE_IN_ESCAPING_LAMBDA auto process_response_completion_result = Optional<WebIDL::ExceptionOr<void>> {};
 
-        fetch_algorithms_input.process_response = [request, job, state, newest_worker, &realm, &registration, &process_response_completion_result](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) mutable -> void {
+        fetch_algorithms_input.process_response = [request, job, state, newest_worker, &realm, &registration, &process_response_completion_result](GC::Ref<Fetch::Infrastructure::Response> response) mutable -> void {
             // 7. Extract a MIME type from the response’s header list. If s MIME type (ignoring parameters) is not a JavaScript MIME type, then:
             auto mime_type = response->header_list()->extract_mime_type();
             if (!mime_type.has_value() || !mime_type->is_javascript()) {
@@ -359,7 +359,7 @@ static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
 
         // FIXME: This feels.. uncomfortable but it should work to block the current task until the fetch has progressed past our processResponse hook or aborted
         auto& event_loop = job->client ? job->client->responsible_event_loop() : HTML::main_thread_event_loop();
-        event_loop.spin_until(JS::create_heap_function(realm.heap(), [fetch_controller, &realm, &process_response_completion_result]() -> bool {
+        event_loop.spin_until(GC::create_function(realm.heap(), [fetch_controller, &realm, &process_response_completion_result]() -> bool {
             if (process_response_completion_result.has_value())
                 return true;
             if (fetch_controller->state() == Fetch::Infrastructure::FetchController::State::Terminated || fetch_controller->state() == Fetch::Infrastructure::FetchController::State::Aborted) {
@@ -374,7 +374,7 @@ static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
     auto perform_the_fetch_hook = HTML::create_perform_the_fetch_hook(vm.heap(), move(perform_the_fetch_hook_function));
 
     // When the algorithm asynchronously completes, continue the rest of these steps, with script being the asynchronous completion value.
-    auto on_fetch_complete = HTML::create_on_fetch_script_complete(vm.heap(), [job, newest_worker, state, &registration = *registration, &vm](JS::GCPtr<HTML::Script> script) -> void {
+    auto on_fetch_complete = HTML::create_on_fetch_script_complete(vm.heap(), [job, newest_worker, state, &registration = *registration, &vm](GC::Ptr<HTML::Script> script) -> void {
         // If script is null or Is Async Module with script’s record, script’s base URL, and « » is true, then:
         // FIXME: Reject async modules
         if (!script) {
@@ -424,7 +424,7 @@ static void update(JS::VM& vm, JS::NonnullGCPtr<Job> job)
     }
 }
 
-static void unregister(JS::VM& vm, JS::NonnullGCPtr<Job> job)
+static void unregister(JS::VM& vm, GC::Ref<Job> job)
 {
     // If there's no client, there won't be any promises to resolve
     if (job->client) {
@@ -442,7 +442,7 @@ static void run_job(JS::VM& vm, JobQueue& job_queue)
     VERIFY(!job_queue.is_empty());
 
     // 2. Queue a task to run these steps:
-    auto job_run_steps = JS::create_heap_function(vm.heap(), [&vm, &job_queue] {
+    auto job_run_steps = GC::create_function(vm.heap(), [&vm, &job_queue] {
         // 1. Let job be the first item in jobQueue.
         auto& job = job_queue.first();
 
@@ -474,7 +474,7 @@ static void run_job(JS::VM& vm, JobQueue& job_queue)
 }
 
 // https://w3c.github.io/ServiceWorker/#finish-job-algorithm
-static void finish_job(JS::VM& vm, JS::NonnullGCPtr<Job> job)
+static void finish_job(JS::VM& vm, GC::Ref<Job> job)
 {
     // 1. Let jobQueue be job’s containing job queue.
     auto& job_queue = *job->containing_job_queue;
@@ -491,12 +491,12 @@ static void finish_job(JS::VM& vm, JS::NonnullGCPtr<Job> job)
 }
 
 // https://w3c.github.io/ServiceWorker/#resolve-job-promise-algorithm
-static void resolve_job_promise(JS::NonnullGCPtr<Job> job, Optional<Registration const&>, JS::Value value)
+static void resolve_job_promise(GC::Ref<Job> job, Optional<Registration const&>, JS::Value value)
 {
     // 1. If job’s client is not null, queue a task, on job’s client's responsible event loop using the DOM manipulation task source, to run the following substeps:
     if (job->client) {
         auto& realm = job->client->realm();
-        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, job->client->responsible_event_loop(), nullptr, JS::create_heap_function(realm.heap(), [&realm, job, value] {
+        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, job->client->responsible_event_loop(), nullptr, GC::create_function(realm.heap(), [&realm, job, value] {
             HTML::TemporaryExecutionContext const context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
             // FIXME: Resolve to a ServiceWorkerRegistration platform object
             // 1. Let convertedValue be null.
@@ -517,7 +517,7 @@ static void resolve_job_promise(JS::NonnullGCPtr<Job> job, Optional<Registration
         // 2. Queue a task, on equivalentJob’s client's responsible event loop using the DOM manipulation task source,
         //    to run the following substeps:
         auto& realm = equivalent_job->client->realm();
-        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, equivalent_job->client->responsible_event_loop(), nullptr, JS::create_heap_function(realm.heap(), [&realm, equivalent_job, value] {
+        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, equivalent_job->client->responsible_event_loop(), nullptr, GC::create_function(realm.heap(), [&realm, equivalent_job, value] {
             HTML::TemporaryExecutionContext const context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
             // FIXME: Resolve to a ServiceWorkerRegistration platform object
             // 1. Let convertedValue be null.
@@ -532,13 +532,13 @@ static void resolve_job_promise(JS::NonnullGCPtr<Job> job, Optional<Registration
 
 // https://w3c.github.io/ServiceWorker/#reject-job-promise-algorithm
 template<typename Error>
-static void reject_job_promise(JS::NonnullGCPtr<Job> job, String message)
+static void reject_job_promise(GC::Ref<Job> job, String message)
 {
     // 1. If job’s client is not null, queue a task, on job’s client's responsible event loop using the DOM manipulation task source,
     //    to reject job’s job promise with a new exception with errorData and a user agent-defined message, in job’s client's Realm.
     if (job->client) {
         auto& realm = job->client->realm();
-        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, job->client->responsible_event_loop(), nullptr, JS::create_heap_function(realm.heap(), [&realm, job, message] {
+        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, job->client->responsible_event_loop(), nullptr, GC::create_function(realm.heap(), [&realm, job, message] {
             HTML::TemporaryExecutionContext const context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
             WebIDL::reject_promise(realm, *job->job_promise, Error::create(realm, message));
         }));
@@ -554,7 +554,7 @@ static void reject_job_promise(JS::NonnullGCPtr<Job> job, String message)
         //    to reject equivalentJob’s job promise with a new exception with errorData and a user agent-defined message,
         //    in equivalentJob’s client's Realm.
         auto& realm = equivalent_job->client->realm();
-        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, equivalent_job->client->responsible_event_loop(), nullptr, JS::create_heap_function(realm.heap(), [&realm, equivalent_job, message] {
+        HTML::queue_a_task(HTML::Task::Source::DOMManipulation, equivalent_job->client->responsible_event_loop(), nullptr, GC::create_function(realm.heap(), [&realm, equivalent_job, message] {
             HTML::TemporaryExecutionContext const context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
             WebIDL::reject_promise(realm, *equivalent_job->job_promise, Error::create(realm, message));
         }));
@@ -562,7 +562,7 @@ static void reject_job_promise(JS::NonnullGCPtr<Job> job, String message)
 }
 
 // https://w3c.github.io/ServiceWorker/#schedule-job-algorithm
-void schedule_job(JS::VM& vm, JS::NonnullGCPtr<Job> job)
+void schedule_job(JS::VM& vm, GC::Ref<Job> job)
 {
     // 1. Let jobQueue be null.
     // Note: See below for how we ensure job queue
diff --git a/Libraries/LibWeb/ServiceWorker/Job.h b/Libraries/LibWeb/ServiceWorker/Job.h
index 5774b2a9460..8b0cb72782c 100644
--- a/Libraries/LibWeb/ServiceWorker/Job.h
+++ b/Libraries/LibWeb/ServiceWorker/Job.h
@@ -15,13 +15,13 @@
 namespace Web::ServiceWorker {
 
 struct Job;
-using JobQueue = JS::MarkedVector<JS::NonnullGCPtr<Job>>;
+using JobQueue = GC::MarkedVector<GC::Ref<Job>>;
 
 // https://w3c.github.io/ServiceWorker/#dfn-job
 // FIXME: Consider not making this GC allocated, and give a special JobQueue class responsibility for its referenced GC objects
 struct Job : public JS::Cell {
-    JS_CELL(Job, JS::Cell)
-    JS_DECLARE_ALLOCATOR(Job);
+    GC_CELL(Job, JS::Cell)
+    GC_DECLARE_ALLOCATOR(Job);
 
 public:
     enum class Type : u8 {
@@ -31,7 +31,7 @@ public:
     };
 
     // https://w3c.github.io/ServiceWorker/#create-job
-    static JS::NonnullGCPtr<Job> create(JS::VM&, Type, StorageAPI::StorageKey, URL::URL scope_url, URL::URL script_url, JS::GCPtr<WebIDL::Promise>, JS::GCPtr<HTML::EnvironmentSettingsObject> client);
+    static GC::Ref<Job> create(JS::VM&, Type, StorageAPI::StorageKey, URL::URL scope_url, URL::URL script_url, GC::Ptr<WebIDL::Promise>, GC::Ptr<HTML::EnvironmentSettingsObject> client);
 
     virtual ~Job() override;
 
@@ -42,12 +42,12 @@ public:
     Bindings::WorkerType worker_type = Bindings::WorkerType::Classic;
     // FIXME: The spec sometimes omits setting update_via_cache after CreateJob. Default to the default value for ServiceWorkerRegistrations
     Bindings::ServiceWorkerUpdateViaCache update_via_cache = Bindings::ServiceWorkerUpdateViaCache::Imports;
-    JS::GCPtr<HTML::EnvironmentSettingsObject> client = nullptr;
+    GC::Ptr<HTML::EnvironmentSettingsObject> client = nullptr;
     Optional<URL::URL> referrer;
     // FIXME: Spec just references this as an ECMAScript promise https://github.com/w3c/ServiceWorker/issues/1731
-    JS::GCPtr<WebIDL::Promise> job_promise = nullptr;
+    GC::Ptr<WebIDL::Promise> job_promise = nullptr;
     RawPtr<JobQueue> containing_job_queue = nullptr;
-    Vector<JS::NonnullGCPtr<Job>> list_of_equivalent_jobs;
+    Vector<GC::Ref<Job>> list_of_equivalent_jobs;
     bool force_cache_bypass = false;
 
     // https://w3c.github.io/ServiceWorker/#dfn-job-equivalent
@@ -70,10 +70,10 @@ public:
 private:
     virtual void visit_edges(JS::Cell::Visitor& visitor) override;
 
-    Job(Type, StorageAPI::StorageKey, URL::URL scope_url, URL::URL script_url, JS::GCPtr<WebIDL::Promise>, JS::GCPtr<HTML::EnvironmentSettingsObject> client);
+    Job(Type, StorageAPI::StorageKey, URL::URL scope_url, URL::URL script_url, GC::Ptr<WebIDL::Promise>, GC::Ptr<HTML::EnvironmentSettingsObject> client);
 };
 
 // https://w3c.github.io/ServiceWorker/#schedule-job-algorithm
-void schedule_job(JS::VM&, JS::NonnullGCPtr<Job>);
+void schedule_job(JS::VM&, GC::Ref<Job>);
 
 }
diff --git a/Libraries/LibWeb/StorageAPI/NavigatorStorage.cpp b/Libraries/LibWeb/StorageAPI/NavigatorStorage.cpp
index 4dfc17a7369..1f279863f1f 100644
--- a/Libraries/LibWeb/StorageAPI/NavigatorStorage.cpp
+++ b/Libraries/LibWeb/StorageAPI/NavigatorStorage.cpp
@@ -13,7 +13,7 @@
 namespace Web::StorageAPI {
 
 // https://storage.spec.whatwg.org/#dom-navigatorstorage-storage
-JS::NonnullGCPtr<StorageManager> NavigatorStorage::storage()
+GC::Ref<StorageManager> NavigatorStorage::storage()
 {
     // The storage getter steps are to return this’s relevant settings object’s StorageManager object.
     return HTML::relevant_settings_object(this_navigator_storage_object()).storage_manager();
diff --git a/Libraries/LibWeb/StorageAPI/NavigatorStorage.h b/Libraries/LibWeb/StorageAPI/NavigatorStorage.h
index 537077e01a8..b56fc08a663 100644
--- a/Libraries/LibWeb/StorageAPI/NavigatorStorage.h
+++ b/Libraries/LibWeb/StorageAPI/NavigatorStorage.h
@@ -7,8 +7,8 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 
@@ -18,7 +18,7 @@ class NavigatorStorage {
 public:
     virtual ~NavigatorStorage() = default;
 
-    JS::NonnullGCPtr<StorageManager> storage();
+    GC::Ref<StorageManager> storage();
 
 protected:
     virtual Bindings::PlatformObject const& this_navigator_storage_object() const = 0;
diff --git a/Libraries/LibWeb/StorageAPI/StorageManager.cpp b/Libraries/LibWeb/StorageAPI/StorageManager.cpp
index 85402947878..90c301de911 100644
--- a/Libraries/LibWeb/StorageAPI/StorageManager.cpp
+++ b/Libraries/LibWeb/StorageAPI/StorageManager.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::StorageAPI {
 
-JS_DEFINE_ALLOCATOR(StorageManager);
+GC_DEFINE_ALLOCATOR(StorageManager);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<StorageManager>> StorageManager::create(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<StorageManager>> StorageManager::create(JS::Realm& realm)
 {
     return realm.create<StorageManager>(realm);
 }
diff --git a/Libraries/LibWeb/StorageAPI/StorageManager.h b/Libraries/LibWeb/StorageAPI/StorageManager.h
index a2156451242..24c565fbcce 100644
--- a/Libraries/LibWeb/StorageAPI/StorageManager.h
+++ b/Libraries/LibWeb/StorageAPI/StorageManager.h
@@ -12,10 +12,10 @@ namespace Web::StorageAPI {
 
 class StorageManager final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(StorageManager, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(StorageManager);
+    GC_DECLARE_ALLOCATOR(StorageManager);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<StorageManager>> create(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<StorageManager>> create(JS::Realm&);
     virtual ~StorageManager() override = default;
 
 private:
diff --git a/Libraries/LibWeb/Streams/AbstractOperations.cpp b/Libraries/LibWeb/Streams/AbstractOperations.cpp
index 6a3a3b63bc1..3d92a0539ea 100644
--- a/Libraries/LibWeb/Streams/AbstractOperations.cpp
+++ b/Libraries/LibWeb/Streams/AbstractOperations.cpp
@@ -46,7 +46,7 @@
 namespace Web::Streams {
 
 // https://streams.spec.whatwg.org/#acquire-readable-stream-reader
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamDefaultReader>> acquire_readable_stream_default_reader(ReadableStream& stream)
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamDefaultReader>> acquire_readable_stream_default_reader(ReadableStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -61,7 +61,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamDefaultReader>> acquire_reada
 }
 
 // https://streams.spec.whatwg.org/#acquire-readable-stream-byob-reader
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamBYOBReader>> acquire_readable_stream_byob_reader(ReadableStream& stream)
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamBYOBReader>> acquire_readable_stream_byob_reader(ReadableStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -87,7 +87,7 @@ bool is_readable_stream_locked(ReadableStream const& stream)
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-cancel
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_cancel(ReadableStream& stream, JS::Value reason)
+GC::Ref<WebIDL::Promise> readable_stream_cancel(ReadableStream& stream, JS::Value reason)
 {
     auto& realm = stream.realm();
 
@@ -109,10 +109,10 @@ JS::NonnullGCPtr<WebIDL::Promise> readable_stream_cancel(ReadableStream& stream,
     auto reader = stream.reader();
 
     // 6. If reader is not undefined and reader implements ReadableStreamBYOBReader,
-    if (reader.has_value() && reader->has<JS::NonnullGCPtr<ReadableStreamBYOBReader>>()) {
+    if (reader.has_value() && reader->has<GC::Ref<ReadableStreamBYOBReader>>()) {
         // 1. Let readIntoRequests be reader.[[readIntoRequests]].
         // 2. Set reader.[[readIntoRequests]] to an empty list.
-        auto read_into_requests = move(reader->get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>()->read_into_requests());
+        auto read_into_requests = move(reader->get<GC::Ref<ReadableStreamBYOBReader>>()->read_into_requests());
 
         // 3. For each readIntoRequest of readIntoRequests,
         for (auto& read_into_request : read_into_requests) {
@@ -128,7 +128,7 @@ JS::NonnullGCPtr<WebIDL::Promise> readable_stream_cancel(ReadableStream& stream,
 
     // 8. Return the result of reacting to sourceCancelPromise with a fulfillment step that returns undefined.
     auto react_result = WebIDL::react_to_promise(*source_cancel_promise,
-        JS::create_heap_function(stream.heap(), [](JS::Value) -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); }),
+        GC::create_function(stream.heap(), [](JS::Value) -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); }),
         {});
 
     return react_result;
@@ -141,7 +141,7 @@ void readable_stream_fulfill_read_into_request(ReadableStream& stream, JS::Value
     VERIFY(readable_stream_has_byob_reader(stream));
 
     // 2. Let reader be stream.[[reader]].
-    auto reader = stream.reader()->get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>();
+    auto reader = stream.reader()->get<GC::Ref<ReadableStreamBYOBReader>>();
 
     // 3. Assert: reader.[[readIntoRequests]] is not empty.
     VERIFY(!reader->read_into_requests().is_empty());
@@ -167,7 +167,7 @@ void readable_stream_fulfill_read_request(ReadableStream& stream, JS::Value chun
     VERIFY(readable_stream_has_default_reader(stream));
 
     // 2. Let reader be stream.[[reader]].
-    auto reader = stream.reader()->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>();
+    auto reader = stream.reader()->get<GC::Ref<ReadableStreamDefaultReader>>();
 
     // 3. Assert: reader.[[readRequests]] is not empty.
     VERIFY(!reader->read_requests().is_empty());
@@ -193,7 +193,7 @@ size_t readable_stream_get_num_read_into_requests(ReadableStream const& stream)
     VERIFY(readable_stream_has_byob_reader(stream));
 
     // 2. Return stream.[[reader]].[[readIntoRequests]]'s size.
-    return stream.reader()->get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>()->read_into_requests().size();
+    return stream.reader()->get<GC::Ref<ReadableStreamBYOBReader>>()->read_into_requests().size();
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-get-num-read-requests
@@ -203,7 +203,7 @@ size_t readable_stream_get_num_read_requests(ReadableStream const& stream)
     VERIFY(readable_stream_has_default_reader(stream));
 
     // 2. Return stream.[[reader]].[[readRequests]]'s size.
-    return stream.reader()->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()->read_requests().size();
+    return stream.reader()->get<GC::Ref<ReadableStreamDefaultReader>>()->read_requests().size();
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-has-byob-reader
@@ -217,7 +217,7 @@ bool readable_stream_has_byob_reader(ReadableStream const& stream)
         return false;
 
     // 3. If reader implements ReadableStreamBYOBReader, return true.
-    if (reader->has<JS::NonnullGCPtr<ReadableStreamBYOBReader>>())
+    if (reader->has<GC::Ref<ReadableStreamBYOBReader>>())
         return true;
 
     // 4. Return false.
@@ -235,7 +235,7 @@ bool readable_stream_has_default_reader(ReadableStream const& stream)
         return false;
 
     // 3. If reader implements ReadableStreamDefaultReader, return true.
-    if (reader->has<JS::NonnullGCPtr<ReadableStreamDefaultReader>>())
+    if (reader->has<GC::Ref<ReadableStreamDefaultReader>>())
         return true;
 
     // 4. Return false.
@@ -243,7 +243,7 @@ bool readable_stream_has_default_reader(ReadableStream const& stream)
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-pipe-to
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source, WritableStream& dest, bool, bool, bool, Optional<JS::Value> signal)
+GC::Ref<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source, WritableStream& dest, bool, bool, bool, Optional<JS::Value> signal)
 {
     auto& realm = source.realm();
 
@@ -307,7 +307,7 @@ JS::NonnullGCPtr<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source
 
     // FIXME: Currently a naive implementation that uses ReadableStreamDefaultReader::read_all_chunks() to read all chunks
     //        from the source and then through the callback success_steps writes those chunks to the destination.
-    auto chunk_steps = JS::create_heap_function(realm.heap(), [&realm, writer](ByteBuffer buffer) {
+    auto chunk_steps = GC::create_function(realm.heap(), [&realm, writer](ByteBuffer buffer) {
         auto array_buffer = JS::ArrayBuffer::create(realm, move(buffer));
         auto chunk = JS::Uint8Array::create(realm, array_buffer->byte_length(), *array_buffer);
 
@@ -315,14 +315,14 @@ JS::NonnullGCPtr<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source
         WebIDL::resolve_promise(realm, promise, JS::js_undefined());
     });
 
-    auto success_steps = JS::create_heap_function(realm.heap(), [promise, &realm, writer](ByteBuffer) {
+    auto success_steps = GC::create_function(realm.heap(), [promise, &realm, writer](ByteBuffer) {
         // Make sure we close the acquired writer.
         WebIDL::resolve_promise(realm, writable_stream_default_writer_close(*writer), JS::js_undefined());
 
         WebIDL::resolve_promise(realm, promise, JS::js_undefined());
     });
 
-    auto failure_steps = JS::create_heap_function(realm.heap(), [promise, &realm, writer](JS::Value error) {
+    auto failure_steps = GC::create_function(realm.heap(), [promise, &realm, writer](JS::Value error) {
         // Make sure we close the acquired writer.
         WebIDL::resolve_promise(realm, writable_stream_default_writer_close(*writer), JS::js_undefined());
 
@@ -342,7 +342,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_tee(JS::Realm& realm, Re
     // 2. Assert: cloneForBranch2 is a boolean.
 
     // 3. If stream.[[controller]] implements ReadableByteStreamController, return ? ReadableByteStreamTee(stream).
-    if (stream.controller()->has<JS::NonnullGCPtr<Streams::ReadableByteStreamController>>()) {
+    if (stream.controller()->has<GC::Ref<Streams::ReadableByteStreamController>>()) {
         return TRY(readable_byte_stream_tee(realm, stream));
     }
 
@@ -351,8 +351,8 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_tee(JS::Realm& realm, Re
 }
 
 struct DefaultStreamTeeParams final : JS::Cell {
-    JS_CELL(DefaultStreamTeeParams, JS::Cell);
-    JS_DECLARE_ALLOCATOR(DefaultStreamTeeParams);
+    GC_CELL(DefaultStreamTeeParams, JS::Cell);
+    GC_DECLARE_ALLOCATOR(DefaultStreamTeeParams);
 
     virtual void visit_edges(Visitor& visitor) override
     {
@@ -370,24 +370,24 @@ struct DefaultStreamTeeParams final : JS::Cell {
     bool canceled2 { false };
     JS::Value reason1 { JS::js_undefined() };
     JS::Value reason2 { JS::js_undefined() };
-    JS::GCPtr<ReadableStream> branch1;
-    JS::GCPtr<ReadableStream> branch2;
-    JS::GCPtr<PullAlgorithm> pull_algorithm;
+    GC::Ptr<ReadableStream> branch1;
+    GC::Ptr<ReadableStream> branch2;
+    GC::Ptr<PullAlgorithm> pull_algorithm;
 };
 
-JS_DEFINE_ALLOCATOR(DefaultStreamTeeParams);
+GC_DEFINE_ALLOCATOR(DefaultStreamTeeParams);
 
 // https://streams.spec.whatwg.org/#ref-for-read-request③
 class DefaultStreamTeeReadRequest final : public ReadRequest {
-    JS_CELL(DefaultStreamTeeReadRequest, ReadRequest);
-    JS_DECLARE_ALLOCATOR(DefaultStreamTeeReadRequest);
+    GC_CELL(DefaultStreamTeeReadRequest, ReadRequest);
+    GC_DECLARE_ALLOCATOR(DefaultStreamTeeReadRequest);
 
 public:
     DefaultStreamTeeReadRequest(
         JS::Realm& realm,
-        JS::NonnullGCPtr<ReadableStream> stream,
-        JS::NonnullGCPtr<DefaultStreamTeeParams> params,
-        JS::NonnullGCPtr<WebIDL::Promise> cancel_promise,
+        GC::Ref<ReadableStream> stream,
+        GC::Ref<DefaultStreamTeeParams> params,
+        GC::Ref<WebIDL::Promise> cancel_promise,
         bool clone_for_branch2)
         : m_realm(realm)
         , m_stream(stream)
@@ -401,11 +401,11 @@ public:
     virtual void on_chunk(JS::Value chunk) override
     {
         // 1. Queue a microtask to perform the following steps:
-        HTML::queue_a_microtask(nullptr, JS::create_heap_function(m_realm->heap(), [this, chunk]() {
+        HTML::queue_a_microtask(nullptr, GC::create_function(m_realm->heap(), [this, chunk]() {
             HTML::TemporaryExecutionContext execution_context { m_realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
-            auto controller1 = m_params->branch1->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
-            auto controller2 = m_params->branch2->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+            auto controller1 = m_params->branch1->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
+            auto controller2 = m_params->branch2->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
             // 1. Set readAgain to false.
             m_params->read_again = false;
@@ -470,8 +470,8 @@ public:
     // https://streams.spec.whatwg.org/#ref-for-read-request-close-steps②
     virtual void on_close() override
     {
-        auto controller1 = m_params->branch1->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
-        auto controller2 = m_params->branch2->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+        auto controller1 = m_params->branch1->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
+        auto controller2 = m_params->branch2->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
         // 1. Set reading to false.
         m_params->reading = false;
@@ -509,14 +509,14 @@ private:
         visitor.visit(m_cancel_promise);
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<ReadableStream> m_stream;
-    JS::NonnullGCPtr<DefaultStreamTeeParams> m_params;
-    JS::NonnullGCPtr<WebIDL::Promise> m_cancel_promise;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<ReadableStream> m_stream;
+    GC::Ref<DefaultStreamTeeParams> m_params;
+    GC::Ref<WebIDL::Promise> m_cancel_promise;
     bool m_clone_for_branch2 { false };
 };
 
-JS_DEFINE_ALLOCATOR(DefaultStreamTeeReadRequest);
+GC_DEFINE_ALLOCATOR(DefaultStreamTeeReadRequest);
 
 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaulttee
 WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& realm, ReadableStream& stream, bool clone_for_branch2)
@@ -541,7 +541,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
     auto cancel_promise = WebIDL::create_promise(realm);
 
     // 13. Let pullAlgorithm be the following steps:
-    auto pull_algorithm = JS::create_heap_function(realm.heap(), [&realm, &stream, reader, params, cancel_promise, clone_for_branch2]() {
+    auto pull_algorithm = GC::create_function(realm.heap(), [&realm, &stream, reader, params, cancel_promise, clone_for_branch2]() {
         // 1. If reading is true,
         if (params->reading) {
             // 1. Set readAgain to true.
@@ -568,7 +568,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
     params->pull_algorithm = pull_algorithm;
 
     // 14. Let cancel1Algorithm be the following steps, taking a reason argument:
-    auto cancel1_algorithm = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
+    auto cancel1_algorithm = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
         // 1. Set canceled1 to true.
         params->canceled1 = true;
 
@@ -592,7 +592,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
     });
 
     // 15. Let cancel2Algorithm be the following steps, taking a reason argument:
-    auto cancel2_algorithm = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
+    auto cancel2_algorithm = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
         // 1. Set canceled2 to true.
         params->canceled2 = true;
 
@@ -616,7 +616,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
     });
 
     // 16. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
         return JS::js_undefined();
     });
 
@@ -627,9 +627,9 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
     params->branch2 = MUST(create_readable_stream(realm, start_algorithm, pull_algorithm, cancel2_algorithm));
 
     // 19. Upon rejection of reader.[[closedPromise]] with reason r,
-    WebIDL::upon_rejection(*reader->closed_promise_capability(), JS::create_heap_function(realm.heap(), [&realm, params, cancel_promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
-        auto controller1 = params->branch1->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
-        auto controller2 = params->branch2->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+    WebIDL::upon_rejection(*reader->closed_promise_capability(), GC::create_function(realm.heap(), [&realm, params, cancel_promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        auto controller1 = params->branch1->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
+        auto controller2 = params->branch2->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
         // 1. Perform ! ReadableStreamDefaultControllerError(branch1.[[controller]], r).
         readable_stream_default_controller_error(controller1, reason);
@@ -650,8 +650,8 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& r
 }
 
 struct ByteStreamTeeParams final : JS::Cell {
-    JS_CELL(ByteStreamTeeParams, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ByteStreamTeeParams);
+    GC_CELL(ByteStreamTeeParams, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ByteStreamTeeParams);
 
     explicit ByteStreamTeeParams(ReadableStreamReader reader)
         : reader(move(reader))
@@ -677,26 +677,26 @@ struct ByteStreamTeeParams final : JS::Cell {
     bool canceled2 { false };
     JS::Value reason1 { JS::js_undefined() };
     JS::Value reason2 { JS::js_undefined() };
-    JS::GCPtr<ReadableStream> branch1;
-    JS::GCPtr<ReadableStream> branch2;
-    JS::GCPtr<PullAlgorithm> pull1_algorithm;
-    JS::GCPtr<PullAlgorithm> pull2_algorithm;
+    GC::Ptr<ReadableStream> branch1;
+    GC::Ptr<ReadableStream> branch2;
+    GC::Ptr<PullAlgorithm> pull1_algorithm;
+    GC::Ptr<PullAlgorithm> pull2_algorithm;
     ReadableStreamReader reader;
 };
 
-JS_DEFINE_ALLOCATOR(ByteStreamTeeParams);
+GC_DEFINE_ALLOCATOR(ByteStreamTeeParams);
 
 // https://streams.spec.whatwg.org/#ref-for-read-request④
 class ByteStreamTeeDefaultReadRequest final : public ReadRequest {
-    JS_CELL(ByteStreamTeeDefaultReadRequest, ReadRequest);
-    JS_DECLARE_ALLOCATOR(ByteStreamTeeDefaultReadRequest);
+    GC_CELL(ByteStreamTeeDefaultReadRequest, ReadRequest);
+    GC_DECLARE_ALLOCATOR(ByteStreamTeeDefaultReadRequest);
 
 public:
     ByteStreamTeeDefaultReadRequest(
         JS::Realm& realm,
-        JS::NonnullGCPtr<ReadableStream> stream,
-        JS::NonnullGCPtr<ByteStreamTeeParams> params,
-        JS::NonnullGCPtr<WebIDL::Promise> cancel_promise)
+        GC::Ref<ReadableStream> stream,
+        GC::Ref<ByteStreamTeeParams> params,
+        GC::Ref<WebIDL::Promise> cancel_promise)
         : m_realm(realm)
         , m_stream(stream)
         , m_params(params)
@@ -708,11 +708,11 @@ public:
     virtual void on_chunk(JS::Value chunk) override
     {
         // 1. Queue a microtask to perform the following steps:
-        HTML::queue_a_microtask(nullptr, JS::create_heap_function(m_realm->heap(), [this, chunk]() mutable {
+        HTML::queue_a_microtask(nullptr, GC::create_function(m_realm->heap(), [this, chunk]() mutable {
             HTML::TemporaryExecutionContext execution_context { m_realm };
 
-            auto controller1 = m_params->branch1->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
-            auto controller2 = m_params->branch2->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+            auto controller1 = m_params->branch1->controller()->get<GC::Ref<ReadableByteStreamController>>();
+            auto controller2 = m_params->branch2->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
             // 1. Set readAgainForBranch1 to false.
             m_params->read_again_for_branch1 = false;
@@ -784,8 +784,8 @@ public:
     // https://streams.spec.whatwg.org/#ref-for-read-request-close-steps③
     virtual void on_close() override
     {
-        auto controller1 = m_params->branch1->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
-        auto controller2 = m_params->branch2->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+        auto controller1 = m_params->branch1->controller()->get<GC::Ref<ReadableByteStreamController>>();
+        auto controller2 = m_params->branch2->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
         // 1. Set reading to false.
         m_params->reading = false;
@@ -833,27 +833,27 @@ private:
         visitor.visit(m_cancel_promise);
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<ReadableStream> m_stream;
-    JS::NonnullGCPtr<ByteStreamTeeParams> m_params;
-    JS::NonnullGCPtr<WebIDL::Promise> m_cancel_promise;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<ReadableStream> m_stream;
+    GC::Ref<ByteStreamTeeParams> m_params;
+    GC::Ref<WebIDL::Promise> m_cancel_promise;
 };
 
-JS_DEFINE_ALLOCATOR(ByteStreamTeeDefaultReadRequest);
+GC_DEFINE_ALLOCATOR(ByteStreamTeeDefaultReadRequest);
 
 // https://streams.spec.whatwg.org/#ref-for-read-into-request②
 class ByteStreamTeeBYOBReadRequest final : public ReadIntoRequest {
-    JS_CELL(ByteStreamTeeBYOBReadRequest, ReadIntoRequest);
-    JS_DECLARE_ALLOCATOR(ByteStreamTeeBYOBReadRequest);
+    GC_CELL(ByteStreamTeeBYOBReadRequest, ReadIntoRequest);
+    GC_DECLARE_ALLOCATOR(ByteStreamTeeBYOBReadRequest);
 
 public:
     ByteStreamTeeBYOBReadRequest(
         JS::Realm& realm,
-        JS::NonnullGCPtr<ReadableStream> stream,
-        JS::NonnullGCPtr<ByteStreamTeeParams> params,
-        JS::NonnullGCPtr<WebIDL::Promise> cancel_promise,
-        JS::NonnullGCPtr<ReadableStream> byob_branch,
-        JS::NonnullGCPtr<ReadableStream> other_branch,
+        GC::Ref<ReadableStream> stream,
+        GC::Ref<ByteStreamTeeParams> params,
+        GC::Ref<WebIDL::Promise> cancel_promise,
+        GC::Ref<ReadableStream> byob_branch,
+        GC::Ref<ReadableStream> other_branch,
         bool for_branch2)
         : m_realm(realm)
         , m_stream(stream)
@@ -871,11 +871,11 @@ public:
         auto chunk_view = m_realm->create<WebIDL::ArrayBufferView>(chunk.as_object());
 
         // 1. Queue a microtask to perform the following steps:
-        HTML::queue_a_microtask(nullptr, JS::create_heap_function(m_realm->heap(), [this, chunk = chunk_view]() {
+        HTML::queue_a_microtask(nullptr, GC::create_function(m_realm->heap(), [this, chunk = chunk_view]() {
             HTML::TemporaryExecutionContext execution_context { m_realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
 
-            auto byob_controller = m_byob_branch->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
-            auto other_controller = m_other_branch->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+            auto byob_controller = m_byob_branch->controller()->get<GC::Ref<ReadableByteStreamController>>();
+            auto other_controller = m_other_branch->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
             // 1. Set readAgainForBranch1 to false.
             m_params->read_again_for_branch1 = false;
@@ -950,8 +950,8 @@ public:
     // https://streams.spec.whatwg.org/#ref-for-read-into-request-close-steps②
     virtual void on_close(JS::Value chunk) override
     {
-        auto byob_controller = m_byob_branch->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
-        auto other_controller = m_other_branch->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+        auto byob_controller = m_byob_branch->controller()->get<GC::Ref<ReadableByteStreamController>>();
+        auto other_controller = m_other_branch->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
         // 1. Set reading to false.
         m_params->reading = false;
@@ -1014,23 +1014,23 @@ private:
         visitor.visit(m_other_branch);
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<ReadableStream> m_stream;
-    JS::NonnullGCPtr<ByteStreamTeeParams> m_params;
-    JS::NonnullGCPtr<WebIDL::Promise> m_cancel_promise;
-    JS::NonnullGCPtr<ReadableStream> m_byob_branch;
-    JS::NonnullGCPtr<ReadableStream> m_other_branch;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<ReadableStream> m_stream;
+    GC::Ref<ByteStreamTeeParams> m_params;
+    GC::Ref<WebIDL::Promise> m_cancel_promise;
+    GC::Ref<ReadableStream> m_byob_branch;
+    GC::Ref<ReadableStream> m_other_branch;
     bool m_for_branch2 { false };
 };
 
-JS_DEFINE_ALLOCATOR(ByteStreamTeeBYOBReadRequest);
+GC_DEFINE_ALLOCATOR(ByteStreamTeeBYOBReadRequest);
 
 // https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamtee
 WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& realm, ReadableStream& stream)
 {
     // 1. Assert: stream implements ReadableStream.
     // 2. Assert: stream.[[controller]] implements ReadableByteStreamController.
-    VERIFY(stream.controller().has_value() && stream.controller()->has<JS::NonnullGCPtr<ReadableByteStreamController>>());
+    VERIFY(stream.controller().has_value() && stream.controller()->has<GC::Ref<ReadableByteStreamController>>());
 
     // 3. Let reader be ? AcquireReadableStreamDefaultReader(stream).
     auto reader = TRY(acquire_readable_stream_default_reader(stream));
@@ -1050,13 +1050,13 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     auto cancel_promise = WebIDL::create_promise(realm);
 
     // 14. Let forwardReaderError be the following steps, taking a thisReader argument:
-    auto forward_reader_error = JS::create_heap_function(realm.heap(), [&realm, params, cancel_promise](ReadableStreamReader const& this_reader) {
+    auto forward_reader_error = GC::create_function(realm.heap(), [&realm, params, cancel_promise](ReadableStreamReader const& this_reader) {
         // 1. Upon rejection of thisReader.[[closedPromise]] with reason r,
         auto closed_promise = this_reader.visit([](auto const& underlying_reader) { return underlying_reader->closed_promise_capability(); });
 
-        WebIDL::upon_rejection(*closed_promise, JS::create_heap_function(realm.heap(), [&realm, this_reader, params, cancel_promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
-            auto controller1 = params->branch1->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
-            auto controller2 = params->branch2->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+        WebIDL::upon_rejection(*closed_promise, GC::create_function(realm.heap(), [&realm, this_reader, params, cancel_promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+            auto controller1 = params->branch1->controller()->get<GC::Ref<ReadableByteStreamController>>();
+            auto controller2 = params->branch2->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
             // 1. If thisReader is not reader, return.
             if (this_reader != params->reader) {
@@ -1079,9 +1079,9 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     });
 
     // 15. Let pullWithDefaultReader be the following steps:
-    auto pull_with_default_reader = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise, forward_reader_error]() mutable {
+    auto pull_with_default_reader = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise, forward_reader_error]() mutable {
         // 1. If reader implements ReadableStreamBYOBReader,
-        if (auto const* byob_reader = params->reader.get_pointer<JS::NonnullGCPtr<ReadableStreamBYOBReader>>()) {
+        if (auto const* byob_reader = params->reader.get_pointer<GC::Ref<ReadableStreamBYOBReader>>()) {
             // 1. Assert: reader.[[readIntoRequests]] is empty.
             VERIFY((*byob_reader)->read_into_requests().is_empty());
 
@@ -1099,13 +1099,13 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
         auto read_request = realm.heap().allocate<ByteStreamTeeDefaultReadRequest>(realm, stream, params, cancel_promise);
 
         // 3. Perform ! ReadableStreamDefaultReaderRead(reader, readRequest).
-        readable_stream_default_reader_read(params->reader.get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>(), read_request);
+        readable_stream_default_reader_read(params->reader.get<GC::Ref<ReadableStreamDefaultReader>>(), read_request);
     });
 
     // 16. Let pullWithBYOBReader be the following steps, given view and forBranch2:
-    auto pull_with_byob_reader = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise, forward_reader_error](JS::NonnullGCPtr<WebIDL::ArrayBufferView> view, bool for_branch2) mutable {
+    auto pull_with_byob_reader = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise, forward_reader_error](GC::Ref<WebIDL::ArrayBufferView> view, bool for_branch2) mutable {
         // 1. If reader implements ReadableStreamDefaultReader,
-        if (auto const* default_reader = params->reader.get_pointer<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()) {
+        if (auto const* default_reader = params->reader.get_pointer<GC::Ref<ReadableStreamDefaultReader>>()) {
             // 2. Assert: reader.[[readRequests]] is empty.
             VERIFY((*default_reader)->read_requests().is_empty());
 
@@ -1129,12 +1129,12 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
         auto read_into_request = realm.heap().allocate<ByteStreamTeeBYOBReadRequest>(realm, stream, params, cancel_promise, *byob_branch, *other_branch, for_branch2);
 
         // 5. Perform ! ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest).
-        readable_stream_byob_reader_read(params->reader.get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>(), view, 1, read_into_request);
+        readable_stream_byob_reader_read(params->reader.get<GC::Ref<ReadableStreamBYOBReader>>(), view, 1, read_into_request);
     });
 
     // 17. Let pull1Algorithm be the following steps:
-    auto pull1_algorithm = JS::create_heap_function(realm.heap(), [&realm, params, pull_with_default_reader, pull_with_byob_reader]() {
-        auto controller1 = params->branch1->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+    auto pull1_algorithm = GC::create_function(realm.heap(), [&realm, params, pull_with_default_reader, pull_with_byob_reader]() {
+        auto controller1 = params->branch1->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
         // 1. If reading is true,
         if (params->reading) {
@@ -1165,8 +1165,8 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     });
 
     // 18. Let pull2Algorithm be the following steps:
-    auto pull2_algorithm = JS::create_heap_function(realm.heap(), [&realm, params, pull_with_default_reader, pull_with_byob_reader]() {
-        auto controller2 = params->branch2->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+    auto pull2_algorithm = GC::create_function(realm.heap(), [&realm, params, pull_with_default_reader, pull_with_byob_reader]() {
+        auto controller2 = params->branch2->controller()->get<GC::Ref<ReadableByteStreamController>>();
 
         // 1. If reading is true,
         if (params->reading) {
@@ -1201,7 +1201,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     params->pull2_algorithm = pull2_algorithm;
 
     // 19. Let cancel1Algorithm be the following steps, taking a reason argument:
-    auto cancel1_algorithm = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
+    auto cancel1_algorithm = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
         // 1. Set canceled1 to true.
         params->canceled1 = true;
 
@@ -1225,7 +1225,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     });
 
     // 20. Let cancel2Algorithm be the following steps, taking a reason argument:
-    auto cancel2_algorithm = JS::create_heap_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
+    auto cancel2_algorithm = GC::create_function(realm.heap(), [&realm, &stream, params, cancel_promise](JS::Value reason) {
         // 1. Set canceled2 to true.
         params->canceled2 = true;
 
@@ -1249,7 +1249,7 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
     });
 
     // 21. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
         return JS::js_undefined();
     });
 
@@ -1267,14 +1267,14 @@ WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& real
 }
 
 // https://streams.spec.whatwg.org/#make-size-algorithm-from-size-function
-JS::NonnullGCPtr<SizeAlgorithm> extract_size_algorithm(JS::VM& vm, QueuingStrategy const& strategy)
+GC::Ref<SizeAlgorithm> extract_size_algorithm(JS::VM& vm, QueuingStrategy const& strategy)
 {
     // 1. If strategy["size"] does not exist, return an algorithm that returns 1.
     if (!strategy.size)
-        return JS::create_heap_function(vm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
+        return GC::create_function(vm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
 
     // 2. Return an algorithm that performs the following steps, taking a chunk argument:
-    return JS::create_heap_function(vm.heap(), [size = strategy.size](JS::Value chunk) {
+    return GC::create_function(vm.heap(), [size = strategy.size](JS::Value chunk) {
         return WebIDL::invoke_callback(*size, JS::js_undefined(), chunk);
     });
 }
@@ -1321,10 +1321,10 @@ void readable_stream_close(ReadableStream& stream)
     }));
 
     // 6. If reader implements ReadableStreamDefaultReader,
-    if (reader->has<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()) {
+    if (reader->has<GC::Ref<ReadableStreamDefaultReader>>()) {
         // 1. Let readRequests be reader.[[readRequests]].
         // 2. Set reader.[[readRequests]] to an empty list.
-        auto read_requests = move(reader->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()->read_requests());
+        auto read_requests = move(reader->get<GC::Ref<ReadableStreamDefaultReader>>()->read_requests());
 
         // 3. For each readRequest of readRequests,
         for (auto& read_request : read_requests) {
@@ -1364,22 +1364,22 @@ void readable_stream_error(ReadableStream& stream, JS::Value error)
     WebIDL::mark_promise_as_handled(*closed_promise_capability);
 
     // 8. If reader implements ReadableStreamDefaultReader,
-    if (reader->has<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()) {
+    if (reader->has<GC::Ref<ReadableStreamDefaultReader>>()) {
         // 1. Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).
-        readable_stream_default_reader_error_read_requests(*reader->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>(), error);
+        readable_stream_default_reader_error_read_requests(*reader->get<GC::Ref<ReadableStreamDefaultReader>>(), error);
     }
     // 9. Otherwise,
     else {
         // 1. Assert: reader implements ReadableStreamBYOBReader.
-        VERIFY(reader->has<JS::NonnullGCPtr<ReadableStreamBYOBReader>>());
+        VERIFY(reader->has<GC::Ref<ReadableStreamBYOBReader>>());
 
         // 2. Perform ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e).
-        readable_stream_byob_reader_error_read_into_requests(*reader->get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>(), error);
+        readable_stream_byob_reader_error_read_into_requests(*reader->get<GC::Ref<ReadableStreamBYOBReader>>(), error);
     }
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-from-iterable
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_iterable(JS::VM& vm, JS::Value async_iterable)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> readable_stream_from_iterable(JS::VM& vm, JS::Value async_iterable)
 {
     auto& realm = *vm.current_realm();
 
@@ -1392,12 +1392,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
     auto iterator_record = TRY(JS::get_iterator(vm, async_iterable, JS::IteratorHint::Async));
 
     // 3. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
         return JS::js_undefined();
     });
 
     // 4. Let pullAlgorithm be the following steps:
-    auto pull_algorithm = JS::create_heap_function(realm.heap(), [&vm, &realm, stream, iterator_record]() mutable {
+    auto pull_algorithm = GC::create_function(realm.heap(), [&vm, &realm, stream, iterator_record]() mutable {
         // 1.  Let nextResult be IteratorNext(iteratorRecord).
         auto next_result = JS::iterator_next(vm, iterator_record);
 
@@ -1410,7 +1410,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
 
         // 4. Return the result of reacting to nextPromise with the following fulfillment steps, given iterResult:
         auto react_result = WebIDL::react_to_promise(*next_promise,
-            JS::create_heap_function(realm.heap(), [&vm, stream](JS::Value iter_result) -> WebIDL::ExceptionOr<JS::Value> {
+            GC::create_function(realm.heap(), [&vm, stream](JS::Value iter_result) -> WebIDL::ExceptionOr<JS::Value> {
                 // 1. If iterResult is not an Object, throw a TypeError.
                 if (!iter_result.is_object())
                     return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "iterResult is not an Object"sv };
@@ -1421,7 +1421,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
                 // 3. If done is true:
                 if (done) {
                     // 1. Perform ! ReadableStreamDefaultControllerClose(stream.[[controller]]).
-                    readable_stream_default_controller_close(*stream->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+                    readable_stream_default_controller_close(*stream->controller()->get<GC::Ref<ReadableStreamDefaultController>>());
                 }
                 // 4. Otherwise:
                 else {
@@ -1429,7 +1429,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
                     auto value = TRY(JS::iterator_value(vm, iter_result.as_object()));
 
                     // 2. Perform ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], value).
-                    MUST(readable_stream_default_controller_enqueue(*stream->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>(), value));
+                    MUST(readable_stream_default_controller_enqueue(*stream->controller()->get<GC::Ref<ReadableStreamDefaultController>>(), value));
                 }
 
                 return JS::js_undefined();
@@ -1440,7 +1440,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
     });
 
     // 5. Let cancelAlgorithm be the following steps, given reason:
-    auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&vm, &realm, iterator_record](JS::Value reason) {
+    auto cancel_algorithm = GC::create_function(realm.heap(), [&vm, &realm, iterator_record](JS::Value reason) {
         // 1. Let iterator be iteratorRecord.[[Iterator]].
         auto iterator = iterator_record->iterator;
 
@@ -1467,7 +1467,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
 
         // 8. Return the result of reacting to returnPromise with the following fulfillment steps, given iterResult:
         auto react_result = WebIDL::react_to_promise(*return_promise,
-            JS::create_heap_function(realm.heap(), [](JS::Value iter_result) -> WebIDL::ExceptionOr<JS::Value> {
+            GC::create_function(realm.heap(), [](JS::Value iter_result) -> WebIDL::ExceptionOr<JS::Value> {
                 // 1. If iterResult is not an Object, throw a TypeError.
                 if (!iter_result.is_object())
                     return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "iterResult is not an Object"sv };
@@ -1489,33 +1489,33 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_itera
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-add-read-request
-void readable_stream_add_read_request(ReadableStream& stream, JS::NonnullGCPtr<ReadRequest> read_request)
+void readable_stream_add_read_request(ReadableStream& stream, GC::Ref<ReadRequest> read_request)
 {
     // 1. Assert: stream.[[reader]] implements ReadableStreamDefaultReader.
-    VERIFY(stream.reader().has_value() && stream.reader()->has<JS::NonnullGCPtr<ReadableStreamDefaultReader>>());
+    VERIFY(stream.reader().has_value() && stream.reader()->has<GC::Ref<ReadableStreamDefaultReader>>());
 
     // 2. Assert: stream.[[state]] is "readable".
     VERIFY(stream.state() == ReadableStream::State::Readable);
 
     // 3. Append readRequest to stream.[[reader]].[[readRequests]].
-    stream.reader()->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>()->read_requests().append(read_request);
+    stream.reader()->get<GC::Ref<ReadableStreamDefaultReader>>()->read_requests().append(read_request);
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-add-read-into-request
-void readable_stream_add_read_into_request(ReadableStream& stream, JS::NonnullGCPtr<ReadIntoRequest> read_into_request)
+void readable_stream_add_read_into_request(ReadableStream& stream, GC::Ref<ReadIntoRequest> read_into_request)
 {
     // 1. Assert: stream.[[reader]] implements ReadableStreamBYOBReader.
-    VERIFY(stream.reader().has_value() && stream.reader()->has<JS::NonnullGCPtr<ReadableStreamBYOBReader>>());
+    VERIFY(stream.reader().has_value() && stream.reader()->has<GC::Ref<ReadableStreamBYOBReader>>());
 
     // 2. Assert: stream.[[state]] is "readable" or "closed".
     VERIFY(stream.is_readable() || stream.is_closed());
 
     // 3. Append readRequest to stream.[[reader]].[[readIntoRequests]].
-    stream.reader()->get<JS::NonnullGCPtr<ReadableStreamBYOBReader>>()->read_into_requests().append(read_into_request);
+    stream.reader()->get<GC::Ref<ReadableStreamBYOBReader>>()->read_into_requests().append(read_into_request);
 }
 
 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-cancel
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_reader_generic_cancel(ReadableStreamGenericReaderMixin& reader, JS::Value reason)
+GC::Ref<WebIDL::Promise> readable_stream_reader_generic_cancel(ReadableStreamGenericReaderMixin& reader, JS::Value reason)
 {
     // 1. Let stream be reader.[[stream]]
     auto stream = reader.stream();
@@ -1811,8 +1811,8 @@ void readable_byte_stream_controller_pull_into(ReadableByteStreamController& con
     JS::NativeFunction* ctor = realm.intrinsics().data_view_constructor();
 
     // 4. If view has a [[TypedArrayName]] internal slot (i.e., it is not a DataView),
-    if (view.bufferable_object().has<JS::NonnullGCPtr<JS::TypedArrayBase>>()) {
-        auto const& typed_array = *view.bufferable_object().get<JS::NonnullGCPtr<JS::TypedArrayBase>>();
+    if (view.bufferable_object().has<GC::Ref<JS::TypedArrayBase>>()) {
+        auto const& typed_array = *view.bufferable_object().get<GC::Ref<JS::TypedArrayBase>>();
 
         // 1. Set elementSize to the element size specified in the typed array constructors table for view.[[TypedArrayName]].
         element_size = typed_array.element_size();
@@ -1958,7 +1958,7 @@ void readable_stream_byob_reader_read(ReadableStreamBYOBReader& reader, WebIDL::
     }
     // 5. Otherwise, perform ! ReadableByteStreamControllerPullInto(stream.[[controller]], view, readIntoRequest).
     else {
-        readable_byte_stream_controller_pull_into(*stream->controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>(), view, min, read_into_request);
+        readable_byte_stream_controller_pull_into(*stream->controller()->get<GC::Ref<ReadableByteStreamController>>(), view, min, read_into_request);
     }
 }
 
@@ -2014,7 +2014,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_byob_reader(ReadableStreamBYOBR
         return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Cannot create stream reader for a locked stream"sv };
 
     // 2. If stream.[[controller]] does not implement ReadableByteStreamController, throw a TypeError exception.
-    if (!stream.controller()->has<JS::NonnullGCPtr<ReadableByteStreamController>>())
+    if (!stream.controller()->has<GC::Ref<ReadableByteStreamController>>())
         return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "BYOB reader cannot set up reader from non-byte stream"sv };
 
     // 3. Perform ! ReadableStreamReaderGenericInitialize(reader, stream).
@@ -2143,7 +2143,7 @@ void readable_stream_default_controller_can_pull_if_needed(ReadableStreamDefault
     auto pull_promise = controller.pull_algorithm()->function()();
 
     // 7. Upon fulfillment of pullPromise,
-    WebIDL::upon_fulfillment(*pull_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*pull_promise, GC::create_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Set controller.[[pulling]] to false.
         controller.set_pulling(false);
 
@@ -2160,7 +2160,7 @@ void readable_stream_default_controller_can_pull_if_needed(ReadableStreamDefault
     }));
 
     // 8. Upon rejection of pullPromise with reason e,
-    WebIDL::upon_rejection(*pull_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value e) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*pull_promise, GC::create_function(controller.heap(), [&controller](JS::Value e) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! ReadableStreamDefaultControllerError(controller, e).
         readable_stream_default_controller_error(controller, e);
 
@@ -2201,7 +2201,7 @@ bool readable_stream_default_controller_should_call_pull(ReadableStreamDefaultCo
 }
 
 // https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollergetbyobrequest
-JS::GCPtr<ReadableStreamBYOBRequest> readable_byte_stream_controller_get_byob_request(JS::NonnullGCPtr<ReadableByteStreamController> controller)
+GC::Ptr<ReadableStreamBYOBRequest> readable_byte_stream_controller_get_byob_request(GC::Ref<ReadableByteStreamController> controller)
 {
     auto& vm = controller->vm();
     auto& realm = controller->realm();
@@ -2508,7 +2508,7 @@ bool readable_stream_default_controller_can_close_or_enqueue(ReadableStreamDefau
 }
 
 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller
-WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStream& stream, ReadableStreamDefaultController& controller, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStream& stream, ReadableStreamDefaultController& controller, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm)
 {
     auto& realm = stream.realm();
 
@@ -2547,7 +2547,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStre
     auto start_promise = WebIDL::create_resolved_promise(realm, start_result);
 
     // 11. Upon fulfillment of startPromise,
-    WebIDL::upon_fulfillment(start_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(start_promise, GC::create_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Set controller.[[started]] to true.
         controller.set_started(true);
 
@@ -2564,7 +2564,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStre
     }));
 
     // 12. Upon rejection of startPromise with reason r,
-    WebIDL::upon_rejection(start_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value r) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(start_promise, GC::create_function(controller.heap(), [&controller](JS::Value r) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! ReadableStreamDefaultControllerError(controller, r).
         readable_stream_default_controller_error(controller, r);
 
@@ -2575,7 +2575,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStre
 }
 
 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller-from-underlying-source
-WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underlying_source(ReadableStream& stream, JS::Value underlying_source_value, UnderlyingSource underlying_source, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underlying_source(ReadableStream& stream, JS::Value underlying_source_value, UnderlyingSource underlying_source, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm)
 {
     auto& realm = stream.realm();
 
@@ -2583,23 +2583,23 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underly
     auto controller = realm.create<ReadableStreamDefaultController>(realm);
 
     // 2. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> {
         return JS::js_undefined();
     });
 
     // 3. Let pullAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto pull_algorithm = JS::create_heap_function(realm.heap(), [&realm]() {
+    auto pull_algorithm = GC::create_function(realm.heap(), [&realm]() {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 4. Let cancelAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm](JS::Value) {
+    auto cancel_algorithm = GC::create_function(realm.heap(), [&realm](JS::Value) {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 5. If underlyingSourceDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["start"] with argument list « controller » and callback this value underlyingSource.
     if (underlying_source.start) {
-        start_algorithm = JS::create_heap_function(realm.heap(), [controller, underlying_source_value, callback = underlying_source.start]() -> WebIDL::ExceptionOr<JS::Value> {
+        start_algorithm = GC::create_function(realm.heap(), [controller, underlying_source_value, callback = underlying_source.start]() -> WebIDL::ExceptionOr<JS::Value> {
             // Note: callback does not return a promise, so invoke_callback may return an abrupt completion
             return TRY(WebIDL::invoke_callback(*callback, underlying_source_value, controller)).release_value();
         });
@@ -2607,7 +2607,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underly
 
     // 6. If underlyingSourceDict["pull"] exists, then set pullAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["pull"] with argument list « controller » and callback this value underlyingSource.
     if (underlying_source.pull) {
-        pull_algorithm = JS::create_heap_function(realm.heap(), [&realm, controller, underlying_source_value, callback = underlying_source.pull]() {
+        pull_algorithm = GC::create_function(realm.heap(), [&realm, controller, underlying_source_value, callback = underlying_source.pull]() {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_source_value, controller)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -2616,7 +2616,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underly
 
     // 7. If underlyingSourceDict["cancel"] exists, then set cancelAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSourceDict["cancel"] with argument list « reason » and callback this value underlyingSource.
     if (underlying_source.cancel) {
-        cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm, underlying_source_value, callback = underlying_source.cancel](JS::Value reason) {
+        cancel_algorithm = GC::create_function(realm.heap(), [&realm, underlying_source_value, callback = underlying_source.cancel](JS::Value reason) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_source_value, reason)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -2656,7 +2656,7 @@ void readable_byte_stream_controller_call_pull_if_needed(ReadableByteStreamContr
     auto pull_promise = controller.pull_algorithm()->function()();
 
     // 7. Upon fulfillment of pullPromise,
-    WebIDL::upon_fulfillment(*pull_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*pull_promise, GC::create_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Set controller.[[pulling]] to false.
         controller.set_pulling(false);
 
@@ -2673,7 +2673,7 @@ void readable_byte_stream_controller_call_pull_if_needed(ReadableByteStreamContr
     }));
 
     // 8. Upon rejection of pullPromise with reason e,
-    WebIDL::upon_rejection(*pull_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value error) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*pull_promise, GC::create_function(controller.heap(), [&controller](JS::Value error) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! ReadableByteStreamControllerError(controller, e).
         readable_byte_stream_controller_error(controller, error);
 
@@ -2773,7 +2773,7 @@ void readable_byte_stream_controller_error(ReadableByteStreamController& control
 }
 
 // https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollerfillreadrequestfromqueue
-void readable_byte_stream_controller_fill_read_request_from_queue(ReadableByteStreamController& controller, JS::NonnullGCPtr<ReadRequest> read_request)
+void readable_byte_stream_controller_fill_read_request_from_queue(ReadableByteStreamController& controller, GC::Ref<ReadRequest> read_request)
 {
     auto& vm = controller.vm();
     auto& realm = controller.realm();
@@ -2897,7 +2897,7 @@ bool readable_byte_stream_controller_should_call_pull(ReadableByteStreamControll
 // NON-STANDARD: Can be used instead of CreateReadableStream in cases where we need to set up a newly allocated
 //               ReadableStream before initialization of said ReadableStream, i.e. ReadableStream is captured by lambdas in an uninitialized state.
 // Spec steps are taken from: https://streams.spec.whatwg.org/#create-readable-stream
-WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStream& stream, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark, JS::GCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStream& stream, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark, GC::Ptr<SizeAlgorithm> size_algorithm)
 {
     // 1. If highWaterMark was not passed, set it to 1.
     if (!high_water_mark.has_value())
@@ -2905,7 +2905,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStrea
 
     // 2. If sizeAlgorithm was not passed, set it to an algorithm that returns 1.
     if (!size_algorithm)
-        size_algorithm = JS::create_heap_function(realm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
+        size_algorithm = GC::create_function(realm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
 
     // 3. Assert: ! IsNonNegativeNumber(highWaterMark) is true.
     VERIFY(is_non_negative_number(JS::Value { *high_water_mark }));
@@ -2926,7 +2926,7 @@ WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStrea
 }
 
 // https://streams.spec.whatwg.org/#create-readable-stream
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark, JS::GCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> create_readable_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark, GC::Ptr<SizeAlgorithm> size_algorithm)
 {
     // 1. If highWaterMark was not passed, set it to 1.
     if (!high_water_mark.has_value())
@@ -2934,7 +2934,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_stream(JS:
 
     // 2. If sizeAlgorithm was not passed, set it to an algorithm that returns 1.
     if (!size_algorithm)
-        size_algorithm = JS::create_heap_function(realm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
+        size_algorithm = GC::create_function(realm.heap(), [](JS::Value) { return JS::normal_completion(JS::Value(1)); });
 
     // 3. Assert: ! IsNonNegativeNumber(highWaterMark) is true.
     VERIFY(is_non_negative_number(JS::Value { *high_water_mark }));
@@ -2956,7 +2956,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_stream(JS:
 }
 
 // https://streams.spec.whatwg.org/#abstract-opdef-createreadablebytestream
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_byte_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> create_readable_byte_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm)
 {
     // 1. Let stream be a new ReadableStream.
     auto stream = realm.create<ReadableStream>(realm);
@@ -2975,7 +2975,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_byte_strea
 }
 
 // https://streams.spec.whatwg.org/#create-writable-stream
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStream>> create_writable_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<WriteAlgorithm> write_algorithm, JS::NonnullGCPtr<CloseAlgorithm> close_algorithm, JS::NonnullGCPtr<AbortAlgorithm> abort_algorithm, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<GC::Ref<WritableStream>> create_writable_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<WriteAlgorithm> write_algorithm, GC::Ref<CloseAlgorithm> close_algorithm, GC::Ref<AbortAlgorithm> abort_algorithm, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm)
 {
     // 1. Assert: ! IsNonNegativeNumber(highWaterMark) is true.
     VERIFY(is_non_negative_number(JS::Value { high_water_mark }));
@@ -3034,7 +3034,7 @@ void initialize_writable_stream(WritableStream& stream)
 }
 
 // https://streams.spec.whatwg.org/#acquire-writable-stream-default-writer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> acquire_writable_stream_default_writer(WritableStream& stream)
+WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> acquire_writable_stream_default_writer(WritableStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -3135,7 +3135,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_writer(WritableStreamDe
 }
 
 // https://streams.spec.whatwg.org/#set-up-readable-byte-stream-controller
-WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream& stream, ReadableByteStreamController& controller, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, double high_water_mark, JS::Value auto_allocate_chunk_size)
+WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream& stream, ReadableByteStreamController& controller, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, double high_water_mark, JS::Value auto_allocate_chunk_size)
 {
     auto& realm = stream.realm();
 
@@ -3194,7 +3194,7 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream&
     auto start_promise = WebIDL::create_resolved_promise(realm, start_result);
 
     // 16. Upon fulfillment of startPromise,
-    WebIDL::upon_fulfillment(start_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(start_promise, GC::create_function(controller.heap(), [&controller](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Set controller.[[started]] to true.
         controller.set_started(true);
 
@@ -3211,7 +3211,7 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream&
     }));
 
     // 17. Upon rejection of startPromise with reason r,
-    WebIDL::upon_rejection(start_promise, JS::create_heap_function(controller.heap(), [&controller](JS::Value r) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(start_promise, GC::create_function(controller.heap(), [&controller](JS::Value r) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! ReadableByteStreamControllerError(controller, r).
         readable_byte_stream_controller_error(controller, r);
 
@@ -3225,15 +3225,15 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream&
 WebIDL::ExceptionOr<void> readable_stream_enqueue(ReadableStreamController& controller, JS::Value chunk)
 {
     // 1. If stream.[[controller]] implements ReadableStreamDefaultController,
-    if (controller.has<JS::NonnullGCPtr<ReadableStreamDefaultController>>()) {
+    if (controller.has<GC::Ref<ReadableStreamDefaultController>>()) {
         // 1. Perform ! ReadableStreamDefaultControllerEnqueue(stream.[[controller]], chunk).
-        return readable_stream_default_controller_enqueue(controller.get<JS::NonnullGCPtr<ReadableStreamDefaultController>>(), chunk);
+        return readable_stream_default_controller_enqueue(controller.get<GC::Ref<ReadableStreamDefaultController>>(), chunk);
     }
     // 2. Otherwise,
     else {
         // 1. Assert: stream.[[controller]] implements ReadableByteStreamController.
-        VERIFY(controller.has<JS::NonnullGCPtr<ReadableByteStreamController>>());
-        auto readable_byte_controller = controller.get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+        VERIFY(controller.has<GC::Ref<ReadableByteStreamController>>());
+        auto readable_byte_controller = controller.get<GC::Ref<ReadableByteStreamController>>();
 
         // FIXME: 2. Assert: chunk is an ArrayBufferView.
 
@@ -3372,7 +3372,7 @@ WebIDL::ExceptionOr<void> readable_byte_stream_controller_enqueue(ReadableByteSt
 WebIDL::ExceptionOr<void> readable_stream_pull_from_bytes(ReadableStream& stream, ByteBuffer bytes)
 {
     // 1. Assert: stream.[[controller]] implements ReadableByteStreamController.
-    auto controller = stream.controller()->get<JS::NonnullGCPtr<ReadableByteStreamController>>();
+    auto controller = stream.controller()->get<GC::Ref<ReadableByteStreamController>>();
 
     // 2. Let available be bytes’s length.
     auto available = bytes.size();
@@ -3412,7 +3412,7 @@ WebIDL::ExceptionOr<void> readable_stream_pull_from_bytes(ReadableStream& stream
 }
 
 // https://streams.spec.whatwg.org/#transfer-array-buffer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> transfer_array_buffer(JS::Realm& realm, JS::ArrayBuffer& buffer)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> transfer_array_buffer(JS::Realm& realm, JS::ArrayBuffer& buffer)
 {
     auto& vm = realm.vm();
 
@@ -3520,10 +3520,10 @@ void readable_byte_stream_controller_process_read_requests_using_queue(ReadableB
     auto reader = controller.stream()->reader();
 
     // 2. Assert: reader implements ReadableStreamDefaultReader.
-    VERIFY(reader->has<JS::NonnullGCPtr<ReadableStreamDefaultReader>>());
+    VERIFY(reader->has<GC::Ref<ReadableStreamDefaultReader>>());
 
     // 3. While reader.[[readRequests]] is not empty,
-    auto readable_stream_default_reader = reader->get<JS::NonnullGCPtr<ReadableStreamDefaultReader>>();
+    auto readable_stream_default_reader = reader->get<GC::Ref<ReadableStreamDefaultReader>>();
     while (!readable_stream_default_reader->read_requests().is_empty()) {
         // 1. If controller.[[queueTotalSize]] is 0, return.
         if (controller.queue_total_size() == 0.0)
@@ -3539,7 +3539,7 @@ void readable_byte_stream_controller_process_read_requests_using_queue(ReadableB
 }
 
 // https://streams.spec.whatwg.org/#readable-byte-stream-controller-enqueue-chunk-to-queue
-void readable_byte_stream_controller_enqueue_chunk_to_queue(ReadableByteStreamController& controller, JS::NonnullGCPtr<JS::ArrayBuffer> buffer, u32 byte_offset, u32 byte_length)
+void readable_byte_stream_controller_enqueue_chunk_to_queue(ReadableByteStreamController& controller, GC::Ref<JS::ArrayBuffer> buffer, u32 byte_offset, u32 byte_length)
 {
     // 1. Append a new readable byte stream queue entry with buffer buffer, byte offset byteOffset, and byte length byteLength to controller.[[queue]].
     controller.queue().append(ReadableByteStreamQueueEntry {
@@ -3593,38 +3593,38 @@ PullIntoDescriptor readable_byte_stream_controller_shift_pending_pull_into(Reada
 }
 
 // https://streams.spec.whatwg.org/#readablestream-set-up-with-byte-reading-support
-void set_up_readable_stream_controller_with_byte_reading_support(ReadableStream& stream, JS::GCPtr<PullAlgorithm> pull_algorithm, JS::GCPtr<CancelAlgorithm> cancel_algorithm, double high_water_mark)
+void set_up_readable_stream_controller_with_byte_reading_support(ReadableStream& stream, GC::Ptr<PullAlgorithm> pull_algorithm, GC::Ptr<CancelAlgorithm> cancel_algorithm, double high_water_mark)
 {
     auto& realm = stream.realm();
 
     // 1. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
 
     // 2. Let pullAlgorithmWrapper be an algorithm that runs these steps:
-    auto pull_algorithm_wrapper = JS::create_heap_function(realm.heap(), [&realm, pull_algorithm]() {
+    auto pull_algorithm_wrapper = GC::create_function(realm.heap(), [&realm, pull_algorithm]() {
         // 1. Let result be the result of running pullAlgorithm, if pullAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
-        JS::GCPtr<JS::PromiseCapability> result = nullptr;
+        GC::Ptr<JS::PromiseCapability> result = nullptr;
         if (pull_algorithm)
             result = pull_algorithm->function()();
 
         // 2. If result is a Promise, then return result.
         if (result != nullptr)
-            return JS::NonnullGCPtr(*result);
+            return GC::Ref(*result);
 
         // 3. Return a promise resolved with undefined.
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 3. Let cancelAlgorithmWrapper be an algorithm that runs these steps:
-    auto cancel_algorithm_wrapper = JS::create_heap_function(realm.heap(), [&realm, cancel_algorithm](JS::Value c) {
+    auto cancel_algorithm_wrapper = GC::create_function(realm.heap(), [&realm, cancel_algorithm](JS::Value c) {
         // 1. Let result be the result of running cancelAlgorithm, if cancelAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
-        JS::GCPtr<JS::PromiseCapability> result = nullptr;
+        GC::Ptr<JS::PromiseCapability> result = nullptr;
         if (cancel_algorithm)
             result = cancel_algorithm->function()(c);
 
         // 2. If result is a Promise, then return result.
         if (result != nullptr)
-            return JS::NonnullGCPtr(*result);
+            return GC::Ref(*result);
 
         // 3. Return a promise resolved with undefined.
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
@@ -3639,7 +3639,7 @@ void set_up_readable_stream_controller_with_byte_reading_support(ReadableStream&
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-abort
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_abort(WritableStream& stream, JS::Value reason)
+GC::Ref<WebIDL::Promise> writable_stream_abort(WritableStream& stream, JS::Value reason)
 {
     auto& realm = stream.realm();
 
@@ -3692,7 +3692,7 @@ JS::NonnullGCPtr<WebIDL::Promise> writable_stream_abort(WritableStream& stream,
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-close
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_close(WritableStream& stream)
+GC::Ref<WebIDL::Promise> writable_stream_close(WritableStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -3733,7 +3733,7 @@ JS::NonnullGCPtr<WebIDL::Promise> writable_stream_close(WritableStream& stream)
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-add-write-request
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_add_write_request(WritableStream& stream)
+GC::Ref<WebIDL::Promise> writable_stream_add_write_request(WritableStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -3844,7 +3844,7 @@ void writable_stream_finish_erroring(WritableStream& stream)
     auto promise = stream.controller()->abort_steps(abort_request.reason);
 
     // 13. Upon fulfillment of promise,
-    WebIDL::upon_fulfillment(*promise, JS::create_heap_function(realm.heap(), [&realm, &stream, abort_promise = abort_request.promise](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*promise, GC::create_function(realm.heap(), [&realm, &stream, abort_promise = abort_request.promise](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Resolve abortRequest’s promise with undefined.
         WebIDL::resolve_promise(realm, abort_promise, JS::js_undefined());
 
@@ -3855,7 +3855,7 @@ void writable_stream_finish_erroring(WritableStream& stream)
     }));
 
     // 14. Upon rejection of promise with reason reason,
-    WebIDL::upon_rejection(*promise, JS::create_heap_function(realm.heap(), [&realm, &stream, abort_promise = abort_request.promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*promise, GC::create_function(realm.heap(), [&realm, &stream, abort_promise = abort_request.promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Reject abortRequest’s promise with reason.
         WebIDL::reject_promise(realm, abort_promise, reason);
 
@@ -4126,7 +4126,7 @@ void writable_stream_update_backpressure(WritableStream& stream, bool backpressu
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-default-writer-abort
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_abort(WritableStreamDefaultWriter& writer, JS::Value reason)
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_abort(WritableStreamDefaultWriter& writer, JS::Value reason)
 {
     // 1. Let stream be writer.[[stream]].
     auto stream = writer.stream();
@@ -4139,7 +4139,7 @@ JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_abort(WritableS
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-default-writer-close
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_close(WritableStreamDefaultWriter& writer)
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_close(WritableStreamDefaultWriter& writer)
 {
     // 1. Let stream be writer.[[stream]].
     auto stream = writer.stream();
@@ -4241,7 +4241,7 @@ void writable_stream_default_writer_release(WritableStreamDefaultWriter& writer)
 }
 
 // https://streams.spec.whatwg.org/#writable-stream-default-writer-write
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_write(WritableStreamDefaultWriter& writer, JS::Value chunk)
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_write(WritableStreamDefaultWriter& writer, JS::Value chunk)
 {
     auto& realm = writer.realm();
 
@@ -4294,7 +4294,7 @@ JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_write(WritableS
 }
 
 // https://streams.spec.whatwg.org/#set-up-writable-stream-default-controller
-WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStream& stream, WritableStreamDefaultController& controller, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<WriteAlgorithm> write_algorithm, JS::NonnullGCPtr<CloseAlgorithm> close_algorithm, JS::NonnullGCPtr<AbortAlgorithm> abort_algorithm, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStream& stream, WritableStreamDefaultController& controller, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<WriteAlgorithm> write_algorithm, GC::Ref<CloseAlgorithm> close_algorithm, GC::Ref<AbortAlgorithm> abort_algorithm, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm)
 {
     auto& realm = stream.realm();
 
@@ -4346,7 +4346,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStre
     auto start_promise = WebIDL::create_resolved_promise(realm, start_result);
 
     // 17. Upon fulfillment of startPromise,
-    WebIDL::upon_fulfillment(*start_promise, JS::create_heap_function(realm.heap(), [&controller, &stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*start_promise, GC::create_function(realm.heap(), [&controller, &stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Assert: stream.[[state]] is "writable" or "erroring".
         auto state = stream.state();
         VERIFY(state == WritableStream::State::Writable || state == WritableStream::State::Erroring);
@@ -4361,7 +4361,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStre
     }));
 
     // 18. Upon rejection of startPromise with reason r,
-    WebIDL::upon_rejection(*start_promise, JS::create_heap_function(realm.heap(), [&stream, &controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*start_promise, GC::create_function(realm.heap(), [&stream, &controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Assert: stream.[[state]] is "writable" or "erroring".
         auto state = stream.state();
         VERIFY(state == WritableStream::State::Writable || state == WritableStream::State::Erroring);
@@ -4379,7 +4379,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStre
 }
 
 // https://streams.spec.whatwg.org/#set-up-writable-stream-default-controller-from-underlying-sink
-WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underlying_sink(WritableStream& stream, JS::Value underlying_sink_value, UnderlyingSink& underlying_sink, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm)
+WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underlying_sink(WritableStream& stream, JS::Value underlying_sink_value, UnderlyingSink& underlying_sink, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm)
 {
     auto& realm = stream.realm();
 
@@ -4387,26 +4387,26 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underly
     auto controller = realm.create<WritableStreamDefaultController>(realm);
 
     // 2. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
 
     // 3. Let writeAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto write_algorithm = JS::create_heap_function(realm.heap(), [&realm](JS::Value) {
+    auto write_algorithm = GC::create_function(realm.heap(), [&realm](JS::Value) {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 4. Let closeAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto close_algorithm = JS::create_heap_function(realm.heap(), [&realm]() {
+    auto close_algorithm = GC::create_function(realm.heap(), [&realm]() {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 5. Let abortAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto abort_algorithm = JS::create_heap_function(realm.heap(), [&realm](JS::Value) {
+    auto abort_algorithm = GC::create_function(realm.heap(), [&realm](JS::Value) {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 6. If underlyingSinkDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSinkDict["start"] with argument list « controller » and callback this value underlyingSink.
     if (underlying_sink.start) {
-        start_algorithm = JS::create_heap_function(realm.heap(), [controller, underlying_sink_value, callback = underlying_sink.start]() -> WebIDL::ExceptionOr<JS::Value> {
+        start_algorithm = GC::create_function(realm.heap(), [controller, underlying_sink_value, callback = underlying_sink.start]() -> WebIDL::ExceptionOr<JS::Value> {
             // Note: callback does not return a promise, so invoke_callback may return an abrupt completion
             return TRY(WebIDL::invoke_callback(*callback, underlying_sink_value, controller)).release_value();
         });
@@ -4414,7 +4414,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underly
 
     // 7. If underlyingSinkDict["write"] exists, then set writeAlgorithm to an algorithm which takes an argument chunk and returns the result of invoking underlyingSinkDict["write"] with argument list « chunk, controller » and callback this value underlyingSink.
     if (underlying_sink.write) {
-        write_algorithm = JS::create_heap_function(realm.heap(), [&realm, controller, underlying_sink_value, callback = underlying_sink.write](JS::Value chunk) {
+        write_algorithm = GC::create_function(realm.heap(), [&realm, controller, underlying_sink_value, callback = underlying_sink.write](JS::Value chunk) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_sink_value, chunk, controller)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4423,7 +4423,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underly
 
     // 8. If underlyingSinkDict["close"] exists, then set closeAlgorithm to an algorithm which returns the result of invoking underlyingSinkDict["close"] with argument list «» and callback this value underlyingSink.
     if (underlying_sink.close) {
-        close_algorithm = JS::create_heap_function(realm.heap(), [&realm, underlying_sink_value, callback = underlying_sink.close]() {
+        close_algorithm = GC::create_function(realm.heap(), [&realm, underlying_sink_value, callback = underlying_sink.close]() {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_sink_value)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4432,7 +4432,7 @@ WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underly
 
     // 9. If underlyingSinkDict["abort"] exists, then set abortAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSinkDict["abort"] with argument list « reason » and callback this value underlyingSink.
     if (underlying_sink.abort) {
-        abort_algorithm = JS::create_heap_function(realm.heap(), [&realm, underlying_sink_value, callback = underlying_sink.abort](JS::Value reason) {
+        abort_algorithm = GC::create_function(realm.heap(), [&realm, underlying_sink_value, callback = underlying_sink.abort](JS::Value reason) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_sink_value, reason)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4604,7 +4604,7 @@ void writable_stream_default_controller_process_close(WritableStreamDefaultContr
     writable_stream_default_controller_clear_algorithms(controller);
 
     // 7. Upon fulfillment of sinkClosePromise,
-    WebIDL::upon_fulfillment(*sink_close_promise, JS::create_heap_function(controller.heap(), [stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*sink_close_promise, GC::create_function(controller.heap(), [stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! WritableStreamFinishInFlightClose(stream).
         writable_stream_finish_in_flight_close(*stream);
 
@@ -4612,7 +4612,7 @@ void writable_stream_default_controller_process_close(WritableStreamDefaultContr
     }));
 
     // 8. Upon rejection of sinkClosePromise with reason reason,
-    WebIDL::upon_rejection(*sink_close_promise, JS::create_heap_function(controller.heap(), [stream = stream](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*sink_close_promise, GC::create_function(controller.heap(), [stream = stream](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! WritableStreamFinishInFlightCloseWithError(stream, reason).
         writable_stream_finish_in_flight_close_with_error(*stream, reason);
 
@@ -4633,7 +4633,7 @@ void writable_stream_default_controller_process_write(WritableStreamDefaultContr
     auto sink_write_promise = controller.write_algorithm()->function()(chunk);
 
     // 4. Upon fulfillment of sinkWritePromise,
-    WebIDL::upon_fulfillment(*sink_write_promise, JS::create_heap_function(controller.heap(), [&controller, stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_fulfillment(*sink_write_promise, GC::create_function(controller.heap(), [&controller, stream](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Perform ! WritableStreamFinishInFlightWrite(stream).
         writable_stream_finish_in_flight_write(*stream);
 
@@ -4662,7 +4662,7 @@ void writable_stream_default_controller_process_write(WritableStreamDefaultContr
     }));
 
     // 5. Upon rejection of sinkWritePromise with reason,
-    WebIDL::upon_rejection(*sink_write_promise, JS::create_heap_function(controller.heap(), [&controller, stream](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    WebIDL::upon_rejection(*sink_write_promise, GC::create_function(controller.heap(), [&controller, stream](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. If stream.[[state]] is "writable", perform ! WritableStreamDefaultControllerClearAlgorithms(controller).
         if (stream->state() == WritableStream::State::Writable)
             writable_stream_default_controller_clear_algorithms(controller);
@@ -4710,33 +4710,33 @@ void writable_stream_default_controller_write(WritableStreamDefaultController& c
 }
 
 // https://streams.spec.whatwg.org/#initialize-transform-stream
-void initialize_transform_stream(TransformStream& stream, JS::NonnullGCPtr<WebIDL::Promise> start_promise, double writable_high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> writable_size_algorithm, double readable_high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> readable_size_algorithm)
+void initialize_transform_stream(TransformStream& stream, GC::Ref<WebIDL::Promise> start_promise, double writable_high_water_mark, GC::Ref<SizeAlgorithm> writable_size_algorithm, double readable_high_water_mark, GC::Ref<SizeAlgorithm> readable_size_algorithm)
 {
     auto& realm = stream.realm();
 
     // 1. Let startAlgorithm be an algorithm that returns startPromise.
-    auto writable_start_algorithm = JS::create_heap_function(realm.heap(), [start_promise]() -> WebIDL::ExceptionOr<JS::Value> {
+    auto writable_start_algorithm = GC::create_function(realm.heap(), [start_promise]() -> WebIDL::ExceptionOr<JS::Value> {
         return start_promise->promise();
     });
 
-    auto readable_start_algorithm = JS::create_heap_function(realm.heap(), [start_promise]() -> WebIDL::ExceptionOr<JS::Value> {
+    auto readable_start_algorithm = GC::create_function(realm.heap(), [start_promise]() -> WebIDL::ExceptionOr<JS::Value> {
         return start_promise->promise();
     });
 
     // 2. Let writeAlgorithm be the following steps, taking a chunk argument:
-    auto write_algorithm = JS::create_heap_function(realm.heap(), [&stream](JS::Value chunk) {
+    auto write_algorithm = GC::create_function(realm.heap(), [&stream](JS::Value chunk) {
         // 1. Return ! TransformStreamDefaultSinkWriteAlgorithm(stream, chunk).
         return transform_stream_default_sink_write_algorithm(stream, chunk);
     });
 
     // 3. Let abortAlgorithm be the following steps, taking a reason argument:
-    auto abort_algorithm = JS::create_heap_function(realm.heap(), [&stream](JS::Value reason) {
+    auto abort_algorithm = GC::create_function(realm.heap(), [&stream](JS::Value reason) {
         // 1. Return ! TransformStreamDefaultSinkAbortAlgorithm(stream, reason).
         return transform_stream_default_sink_abort_algorithm(stream, reason);
     });
 
     // 4. Let closeAlgorithm be the following steps:
-    auto close_algorithm = JS::create_heap_function(realm.heap(), [&stream]() {
+    auto close_algorithm = GC::create_function(realm.heap(), [&stream]() {
         // 1. Return ! TransformStreamDefaultSinkCloseAlgorithm(stream).
         return transform_stream_default_sink_close_algorithm(stream);
     });
@@ -4745,13 +4745,13 @@ void initialize_transform_stream(TransformStream& stream, JS::NonnullGCPtr<WebID
     stream.set_writable(MUST(create_writable_stream(realm, writable_start_algorithm, write_algorithm, close_algorithm, abort_algorithm, writable_high_water_mark, writable_size_algorithm)));
 
     // 6. Let pullAlgorithm be the following steps:
-    auto pull_algorithm = JS::create_heap_function(realm.heap(), [&stream]() {
+    auto pull_algorithm = GC::create_function(realm.heap(), [&stream]() {
         // 1. Return ! TransformStreamDefaultSourcePullAlgorithm(stream).
         return transform_stream_default_source_pull_algorithm(stream);
     });
 
     // 7. Let cancelAlgorithm be the following steps, taking a reason argument:
-    auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&stream](JS::Value reason) {
+    auto cancel_algorithm = GC::create_function(realm.heap(), [&stream](JS::Value reason) {
         // 1. Return ! TransformStreamDefaultSourceCancelAlgorithm(stream, reason).
         return transform_stream_default_source_cancel_algorithm(stream, reason);
     });
@@ -4771,7 +4771,7 @@ void initialize_transform_stream(TransformStream& stream, JS::NonnullGCPtr<WebID
 }
 
 // https://streams.spec.whatwg.org/#set-up-transform-stream-default-controller
-void set_up_transform_stream_default_controller(TransformStream& stream, TransformStreamDefaultController& controller, JS::NonnullGCPtr<TransformAlgorithm> transform_algorithm, JS::NonnullGCPtr<FlushAlgorithm> flush_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm)
+void set_up_transform_stream_default_controller(TransformStream& stream, TransformStreamDefaultController& controller, GC::Ref<TransformAlgorithm> transform_algorithm, GC::Ref<FlushAlgorithm> flush_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm)
 {
     // 1. Assert: stream implements TransformStream.
     // 2. Assert: stream.[[controller]] is undefined.
@@ -4803,7 +4803,7 @@ void set_up_transform_stream_default_controller_from_transformer(TransformStream
     auto controller = realm.create<TransformStreamDefaultController>(realm);
 
     // 2. Let transformAlgorithm be the following steps, taking a chunk argument:
-    auto transform_algorithm = JS::create_heap_function(realm.heap(), [controller, &realm, &vm](JS::Value chunk) {
+    auto transform_algorithm = GC::create_function(realm.heap(), [controller, &realm, &vm](JS::Value chunk) {
         // 1. Let result be TransformStreamDefaultControllerEnqueue(controller, chunk).
         auto result = transform_stream_default_controller_enqueue(*controller, chunk);
 
@@ -4818,12 +4818,12 @@ void set_up_transform_stream_default_controller_from_transformer(TransformStream
     });
 
     // 3. Let flushAlgorithm be an algorithm which returns a promise resolved with undefined.
-    auto flush_algorithm = JS::create_heap_function(realm.heap(), [&realm]() {
+    auto flush_algorithm = GC::create_function(realm.heap(), [&realm]() {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 4. Let cancelAlgorithm be an algorithm which returns a promise resolved with undefined.
-    auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm](JS::Value) {
+    auto cancel_algorithm = GC::create_function(realm.heap(), [&realm](JS::Value) {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
@@ -4831,7 +4831,7 @@ void set_up_transform_stream_default_controller_from_transformer(TransformStream
     //    and returns the result of invoking transformerDict["transform"] with argument list « chunk, controller » and
     //    callback this value transformer.
     if (transformer_dict.transform) {
-        transform_algorithm = JS::create_heap_function(realm.heap(), [controller, &realm, transformer, callback = transformer_dict.transform](JS::Value chunk) {
+        transform_algorithm = GC::create_function(realm.heap(), [controller, &realm, transformer, callback = transformer_dict.transform](JS::Value chunk) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, transformer, chunk, controller)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4841,7 +4841,7 @@ void set_up_transform_stream_default_controller_from_transformer(TransformStream
     // 6. If transformerDict["flush"] exists, set flushAlgorithm to an algorithm which returns the result of invoking
     //    transformerDict["flush"] with argument list « controller » and callback this value transformer.
     if (transformer_dict.flush) {
-        flush_algorithm = JS::create_heap_function(realm.heap(), [&realm, transformer, callback = transformer_dict.flush, controller]() {
+        flush_algorithm = GC::create_function(realm.heap(), [&realm, transformer, callback = transformer_dict.flush, controller]() {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, transformer, controller)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4851,7 +4851,7 @@ void set_up_transform_stream_default_controller_from_transformer(TransformStream
     // 7. If transformerDict["cancel"] exists, set cancelAlgorithm to an algorithm which takes an argument reason and returns
     // the result of invoking transformerDict["cancel"] with argument list « reason » and callback this value transformer.
     if (transformer_dict.cancel) {
-        cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm, transformer, callback = transformer_dict.cancel](JS::Value reason) {
+        cancel_algorithm = GC::create_function(realm.heap(), [&realm, transformer, callback = transformer_dict.cancel](JS::Value reason) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, transformer, reason)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -4885,8 +4885,8 @@ WebIDL::ExceptionOr<void> transform_stream_default_controller_enqueue(TransformS
     auto stream = controller.stream();
 
     // 2. Let readableController be stream.[[readable]].[[controller]].
-    VERIFY(stream->readable()->controller().has_value() && stream->readable()->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
-    auto& readable_controller = stream->readable()->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+    VERIFY(stream->readable()->controller().has_value() && stream->readable()->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
+    auto& readable_controller = stream->readable()->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
     // 3. If ! ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) is false, throw a TypeError exception.
     if (!readable_stream_default_controller_can_close_or_enqueue(readable_controller))
@@ -4937,8 +4937,8 @@ void transform_stream_default_controller_terminate(TransformStreamDefaultControl
     auto stream = controller.stream();
 
     // 2. Let readableController be stream.[[readable]].[[controller]].
-    VERIFY(stream->readable()->controller().has_value() && stream->readable()->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
-    auto readable_controller = stream->readable()->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+    VERIFY(stream->readable()->controller().has_value() && stream->readable()->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
+    auto readable_controller = stream->readable()->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
     // 3. Perform ! ReadableStreamDefaultControllerClose(readableController).
     readable_stream_default_controller_close(readable_controller);
@@ -4951,7 +4951,7 @@ void transform_stream_default_controller_terminate(TransformStreamDefaultControl
 }
 
 // https://streams.spec.whatwg.org/#transform-stream-default-controller-perform-transform
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_controller_perform_transform(TransformStreamDefaultController& controller, JS::Value chunk)
+GC::Ref<WebIDL::Promise> transform_stream_default_controller_perform_transform(TransformStreamDefaultController& controller, JS::Value chunk)
 {
     auto& realm = controller.realm();
 
@@ -4961,7 +4961,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_controller_perform_tr
     // 2. Return the result of reacting to transformPromise with the following rejection steps given the argument r:
     auto react_result = WebIDL::react_to_promise(*transform_promise,
         {},
-        JS::create_heap_function(realm.heap(), [&controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [&controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. Perform ! TransformStreamError(controller.[[stream]], r).
             transform_stream_error(*controller.stream(), reason);
 
@@ -4973,7 +4973,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_controller_perform_tr
 }
 
 // https://streams.spec.whatwg.org/#transform-stream-default-sink-abort-algorithm
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(TransformStream& stream, JS::Value reason)
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(TransformStream& stream, JS::Value reason)
 {
     auto& realm = stream.realm();
 
@@ -4983,7 +4983,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(
 
     // 2. If controller.[[finishPromise]] is not undefined, return controller.[[finishPromise]].
     if (controller->finish_promise())
-        return JS::NonnullGCPtr { *controller->finish_promise() };
+        return GC::Ref { *controller->finish_promise() };
 
     // 3. Let readable be stream.[[readable]].
     auto readable = stream.readable();
@@ -5001,16 +5001,16 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(
     WebIDL::react_to_promise(
         *cancel_promise,
         // 1. If cancelPromise was fulfilled, then:
-        JS::create_heap_function(realm.heap(), [&realm, readable, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [&realm, readable, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. If readable.[[state]] is "errored", reject controller.[[finishPromise]] with readable.[[storedError]].
             if (readable->state() == ReadableStream::State::Errored) {
                 WebIDL::reject_promise(realm, *controller->finish_promise(), readable->stored_error());
             }
             // 2. Otherwise:
             else {
-                VERIFY(readable->controller().has_value() && readable->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+                VERIFY(readable->controller().has_value() && readable->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
                 // 1. Perform ! ReadableStreamDefaultControllerError(readable.[[controller]], reason).
-                readable_stream_default_controller_error(readable->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>(), reason);
+                readable_stream_default_controller_error(readable->controller()->get<GC::Ref<ReadableStreamDefaultController>>(), reason);
 
                 // 2. Resolve controller.[[finishPromise]] with undefined.
                 WebIDL::resolve_promise(realm, *controller->finish_promise(), JS::js_undefined());
@@ -5018,10 +5018,10 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(
             return JS::js_undefined();
         }),
         // 2. If cancelPromise was rejected with reason r, then:
-        JS::create_heap_function(realm.heap(), [&realm, readable, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
-            VERIFY(readable->controller().has_value() && readable->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+        GC::create_function(realm.heap(), [&realm, readable, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+            VERIFY(readable->controller().has_value() && readable->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
             // 1. Perform ! ReadableStreamDefaultControllerError(readable.[[controller]], r).
-            readable_stream_default_controller_error(readable->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>(), reason);
+            readable_stream_default_controller_error(readable->controller()->get<GC::Ref<ReadableStreamDefaultController>>(), reason);
 
             // 2. Reject controller.[[finishPromise]] with r.
             WebIDL::reject_promise(realm, *controller->finish_promise(), reason);
@@ -5034,7 +5034,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(
 }
 
 // https://streams.spec.whatwg.org/#transform-stream-default-sink-close-algorithm
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_close_algorithm(TransformStream& stream)
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_close_algorithm(TransformStream& stream)
 {
     auto& realm = stream.realm();
 
@@ -5054,19 +5054,19 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_close_algorithm(
     auto react_result = WebIDL::react_to_promise(
         *flush_promise,
         // 1. If flushPromise was fulfilled, then:
-        JS::create_heap_function(realm.heap(), [readable](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [readable](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. If readable.[[state]] is "errored", throw readable.[[storedError]].
             if (readable->state() == ReadableStream::State::Errored)
                 return JS::throw_completion(readable->stored_error());
 
-            VERIFY(readable->controller().has_value() && readable->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+            VERIFY(readable->controller().has_value() && readable->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
             // 2. Perform ! ReadableStreamDefaultControllerClose(readable.[[controller]]).
-            readable_stream_default_controller_close(readable->controller().value().get<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+            readable_stream_default_controller_close(readable->controller().value().get<GC::Ref<ReadableStreamDefaultController>>());
 
             return JS::js_undefined();
         }),
         // 2. If flushPromise was rejected with reason r, then:
-        JS::create_heap_function(realm.heap(), [&stream, readable](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [&stream, readable](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. Perform ! TransformStreamError(stream, r).
             transform_stream_error(stream, reason);
 
@@ -5078,7 +5078,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_close_algorithm(
 }
 
 // https://streams.spec.whatwg.org/#transform-stream-default-sink-write-algorithm
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_write_algorithm(TransformStream& stream, JS::Value chunk)
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_write_algorithm(TransformStream& stream, JS::Value chunk)
 {
     auto& realm = stream.realm();
 
@@ -5098,7 +5098,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_write_algorithm(
 
         // 3. Return the result of reacting to backpressureChangePromise with the following fulfillment steps:
         auto react_result = WebIDL::react_to_promise(*backpressure_change_promise,
-            JS::create_heap_function(realm.heap(), [&stream, controller, chunk](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+            GC::create_function(realm.heap(), [&stream, controller, chunk](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
                 // 1. Let writable be stream.[[writable]].
                 auto writable = stream.writable();
 
@@ -5124,7 +5124,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_write_algorithm(
     return transform_stream_default_controller_perform_transform(*controller, chunk);
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_pull_algorithm(TransformStream& stream)
+GC::Ref<WebIDL::Promise> transform_stream_default_source_pull_algorithm(TransformStream& stream)
 {
     // 1. Assert: stream.[[backpressure]] is true.
     VERIFY(stream.backpressure().has_value() && *stream.backpressure());
@@ -5136,11 +5136,11 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_pull_algorithm
     transform_stream_set_backpressure(stream, false);
 
     // 4. Return stream.[[backpressureChangePromise]].
-    return JS::NonnullGCPtr { *stream.backpressure_change_promise() };
+    return GC::Ref { *stream.backpressure_change_promise() };
 }
 
 // https://streams.spec.whatwg.org/#transform-stream-default-source-cancel
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorithm(TransformStream& stream, JS::Value reason)
+GC::Ref<WebIDL::Promise> transform_stream_default_source_cancel_algorithm(TransformStream& stream, JS::Value reason)
 {
     auto& realm = stream.realm();
 
@@ -5149,7 +5149,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorit
 
     // 2. If controller.[[finishPromise]] is not undefined, return controller.[[finishPromise]].
     if (controller->finish_promise())
-        return JS::NonnullGCPtr { *controller->finish_promise() };
+        return GC::Ref { *controller->finish_promise() };
 
     // 3. Let writable be stream.[[writable]].
     auto writable = stream.writable();
@@ -5167,7 +5167,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorit
     WebIDL::react_to_promise(
         *cancel_promise,
         // 1. If cancelPromise was fulfilled, then:
-        JS::create_heap_function(realm.heap(), [&realm, writable, controller, &stream, reason](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [&realm, writable, controller, &stream, reason](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. If writable.[[state]] is "errored", reject controller.[[finishPromise]] with writable.[[storedError]].
             if (writable->state() == WritableStream::State::Errored) {
                 WebIDL::reject_promise(realm, *controller->finish_promise(), writable->stored_error());
@@ -5184,7 +5184,7 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorit
             return JS::js_undefined();
         }),
         // 2. If cancelPromise was rejected with reason r, then:
-        JS::create_heap_function(realm.heap(), [&realm, writable, &stream, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        GC::create_function(realm.heap(), [&realm, writable, &stream, controller](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. Perform ! WritableStreamDefaultControllerErrorIfNeeded(writable.[[controller]], r).
             writable_stream_default_controller_error_if_needed(*writable->controller(), reason);
             // 2. Perform ! TransformStreamUnblockWrite(stream).
@@ -5201,9 +5201,9 @@ JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorit
 // https://streams.spec.whatwg.org/#transform-stream-error
 void transform_stream_error(TransformStream& stream, JS::Value error)
 {
-    VERIFY(stream.readable()->controller().has_value() && stream.readable()->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+    VERIFY(stream.readable()->controller().has_value() && stream.readable()->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
 
-    auto readable_controller = stream.readable()->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+    auto readable_controller = stream.readable()->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
     // 1. Perform ! ReadableStreamDefaultControllerError(stream.[[readable]].[[controller]], e).
     readable_stream_default_controller_error(*readable_controller, error);
@@ -5245,7 +5245,7 @@ void transform_stream_set_backpressure(TransformStream& stream, bool backpressur
 }
 
 // https://streams.spec.whatwg.org/#transformstream-set-up
-void transform_stream_set_up(TransformStream& stream, JS::NonnullGCPtr<TransformAlgorithm> transform_algorithm, JS::GCPtr<FlushAlgorithm> flush_algorithm, JS::GCPtr<CancelAlgorithm> cancel_algorithm)
+void transform_stream_set_up(TransformStream& stream, GC::Ref<TransformAlgorithm> transform_algorithm, GC::Ptr<FlushAlgorithm> flush_algorithm, GC::Ptr<CancelAlgorithm> cancel_algorithm)
 {
     auto& realm = stream.realm();
 
@@ -5253,7 +5253,7 @@ void transform_stream_set_up(TransformStream& stream, JS::NonnullGCPtr<Transform
     auto writable_high_water_mark = 1.0;
 
     // 2. Let writableSizeAlgorithm be an algorithm that returns 1.
-    auto writable_size_algorithm = JS::create_heap_function(realm.heap(), [](JS::Value) {
+    auto writable_size_algorithm = GC::create_function(realm.heap(), [](JS::Value) {
         return JS::normal_completion(JS::Value { 1 });
     });
 
@@ -5261,49 +5261,49 @@ void transform_stream_set_up(TransformStream& stream, JS::NonnullGCPtr<Transform
     auto readable_high_water_mark = 0.0;
 
     // 4. Let readableSizeAlgorithm be an algorithm that returns 1.
-    auto readable_size_algorithm = JS::create_heap_function(realm.heap(), [](JS::Value) {
+    auto readable_size_algorithm = GC::create_function(realm.heap(), [](JS::Value) {
         return JS::normal_completion(JS::Value { 1 });
     });
 
     // 5. Let transformAlgorithmWrapper be an algorithm that runs these steps given a value chunk:
-    auto transform_algorithm_wrapper = JS::create_heap_function(realm.heap(), [&realm, transform_algorithm](JS::Value chunk) -> JS::NonnullGCPtr<WebIDL::Promise> {
+    auto transform_algorithm_wrapper = GC::create_function(realm.heap(), [&realm, transform_algorithm](JS::Value chunk) -> GC::Ref<WebIDL::Promise> {
         // 1. Let result be the result of running transformAlgorithm given chunk. If this throws an exception e, return a promise rejected with e.
-        JS::GCPtr<JS::PromiseCapability> result = nullptr;
+        GC::Ptr<JS::PromiseCapability> result = nullptr;
         result = transform_algorithm->function()(chunk);
 
         // 2. If result is a Promise, then return result.
         if (result)
-            return JS::NonnullGCPtr { *result };
+            return GC::Ref { *result };
 
         // 3. Return a promise resolved with undefined.
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 6. Let flushAlgorithmWrapper be an algorithm that runs these steps:
-    auto flush_algorithm_wrapper = JS::create_heap_function(realm.heap(), [&realm, flush_algorithm]() -> JS::NonnullGCPtr<WebIDL::Promise> {
+    auto flush_algorithm_wrapper = GC::create_function(realm.heap(), [&realm, flush_algorithm]() -> GC::Ref<WebIDL::Promise> {
         // 1. Let result be the result of running flushAlgorithm, if flushAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
-        JS::GCPtr<JS::PromiseCapability> result = nullptr;
+        GC::Ptr<JS::PromiseCapability> result = nullptr;
         if (flush_algorithm)
             result = flush_algorithm->function()();
 
         // 2. If result is a Promise, then return result.
         if (result)
-            return JS::NonnullGCPtr { *result };
+            return GC::Ref { *result };
 
         // 3. Return a promise resolved with undefined.
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 7. Let cancelAlgorithmWrapper be an algorithm that runs these steps given a value reason:
-    auto cancel_algorithm_wrapper = JS::create_heap_function(realm.heap(), [&realm, cancel_algorithm](JS::Value reason) -> JS::NonnullGCPtr<WebIDL::Promise> {
+    auto cancel_algorithm_wrapper = GC::create_function(realm.heap(), [&realm, cancel_algorithm](JS::Value reason) -> GC::Ref<WebIDL::Promise> {
         // 1. Let result be the result of running cancelAlgorithm given reason, if cancelAlgorithm was given, or null otherwise. If this throws an exception e, return a promise rejected with e.
-        JS::GCPtr<JS::PromiseCapability> result = nullptr;
+        GC::Ptr<JS::PromiseCapability> result = nullptr;
         if (cancel_algorithm)
             result = cancel_algorithm->function()(reason);
 
         // 2. If result is a Promise, then return result.
         if (result)
-            return JS::NonnullGCPtr { *result };
+            return GC::Ref { *result };
 
         // 3. Return a promise resolved with undefined.
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
@@ -5418,12 +5418,12 @@ bool is_close_sentinel(JS::Value value)
 
 // Non-standard function to aid in converting a user-provided function into a WebIDL::Callback. This is essentially
 // what the Bindings generator would do at compile time, but at runtime instead.
-JS::ThrowCompletionOr<JS::Handle<WebIDL::CallbackType>> property_to_callback(JS::VM& vm, JS::Value value, JS::PropertyKey const& property_key, WebIDL::OperationReturnsPromise operation_returns_promise)
+JS::ThrowCompletionOr<GC::Root<WebIDL::CallbackType>> property_to_callback(JS::VM& vm, JS::Value value, JS::PropertyKey const& property_key, WebIDL::OperationReturnsPromise operation_returns_promise)
 {
     auto property = TRY(value.get(vm, property_key));
 
     if (property.is_undefined())
-        return JS::Handle<WebIDL::CallbackType> {};
+        return GC::Root<WebIDL::CallbackType> {};
 
     if (!property.is_function())
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAFunction, property.to_string_without_side_effects());
@@ -5440,21 +5440,21 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller_from_underlying
     auto controller = realm.create<ReadableByteStreamController>(realm);
 
     // 2. Let startAlgorithm be an algorithm that returns undefined.
-    auto start_algorithm = JS::create_heap_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
+    auto start_algorithm = GC::create_function(realm.heap(), []() -> WebIDL::ExceptionOr<JS::Value> { return JS::js_undefined(); });
 
     // 3. Let pullAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto pull_algorithm = JS::create_heap_function(realm.heap(), [&realm]() {
+    auto pull_algorithm = GC::create_function(realm.heap(), [&realm]() {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 4. Let cancelAlgorithm be an algorithm that returns a promise resolved with undefined.
-    auto cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm](JS::Value) {
+    auto cancel_algorithm = GC::create_function(realm.heap(), [&realm](JS::Value) {
         return WebIDL::create_resolved_promise(realm, JS::js_undefined());
     });
 
     // 5. If underlyingSourceDict["start"] exists, then set startAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["start"] with argument list « controller » and callback this value underlyingSource.
     if (underlying_source_dict.start) {
-        start_algorithm = JS::create_heap_function(realm.heap(), [controller, underlying_source, callback = underlying_source_dict.start]() -> WebIDL::ExceptionOr<JS::Value> {
+        start_algorithm = GC::create_function(realm.heap(), [controller, underlying_source, callback = underlying_source_dict.start]() -> WebIDL::ExceptionOr<JS::Value> {
             // Note: callback does not return a promise, so invoke_callback may return an abrupt completion
             return TRY(WebIDL::invoke_callback(*callback, underlying_source, controller)).release_value();
         });
@@ -5462,7 +5462,7 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller_from_underlying
 
     // 6. If underlyingSourceDict["pull"] exists, then set pullAlgorithm to an algorithm which returns the result of invoking underlyingSourceDict["pull"] with argument list « controller » and callback this value underlyingSource.
     if (underlying_source_dict.pull) {
-        pull_algorithm = JS::create_heap_function(realm.heap(), [&realm, controller, underlying_source, callback = underlying_source_dict.pull]() {
+        pull_algorithm = GC::create_function(realm.heap(), [&realm, controller, underlying_source, callback = underlying_source_dict.pull]() {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_source, controller)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
@@ -5471,7 +5471,7 @@ WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller_from_underlying
 
     // 7. If underlyingSourceDict["cancel"] exists, then set cancelAlgorithm to an algorithm which takes an argument reason and returns the result of invoking underlyingSourceDict["cancel"] with argument list « reason » and callback this value underlyingSource.
     if (underlying_source_dict.cancel) {
-        cancel_algorithm = JS::create_heap_function(realm.heap(), [&realm, underlying_source, callback = underlying_source_dict.cancel](JS::Value reason) {
+        cancel_algorithm = GC::create_function(realm.heap(), [&realm, underlying_source, callback = underlying_source_dict.cancel](JS::Value reason) {
             // Note: callback returns a promise, so invoke_callback will never return an abrupt completion
             auto result = MUST(WebIDL::invoke_callback(*callback, underlying_source, reason)).release_value();
             return WebIDL::create_resolved_promise(realm, result);
diff --git a/Libraries/LibWeb/Streams/AbstractOperations.h b/Libraries/LibWeb/Streams/AbstractOperations.h
index 437edb5c9b5..ce31666f07c 100644
--- a/Libraries/LibWeb/Streams/AbstractOperations.h
+++ b/Libraries/LibWeb/Streams/AbstractOperations.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/Streams/ReadableStream.h>
 #include <LibWeb/WebIDL/CallbackType.h>
@@ -19,29 +19,29 @@
 
 namespace Web::Streams {
 
-using SizeAlgorithm = JS::HeapFunction<JS::Completion(JS::Value)>;
-using PullAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>()>;
-using CancelAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>(JS::Value)>;
-using StartAlgorithm = JS::HeapFunction<WebIDL::ExceptionOr<JS::Value>()>;
-using AbortAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>(JS::Value)>;
-using CloseAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>()>;
-using WriteAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>(JS::Value)>;
-using FlushAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>()>;
-using TransformAlgorithm = JS::HeapFunction<JS::NonnullGCPtr<WebIDL::Promise>(JS::Value)>;
+using SizeAlgorithm = GC::Function<JS::Completion(JS::Value)>;
+using PullAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>()>;
+using CancelAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>(JS::Value)>;
+using StartAlgorithm = GC::Function<WebIDL::ExceptionOr<JS::Value>()>;
+using AbortAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>(JS::Value)>;
+using CloseAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>()>;
+using WriteAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>(JS::Value)>;
+using FlushAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>()>;
+using TransformAlgorithm = GC::Function<GC::Ref<WebIDL::Promise>(JS::Value)>;
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamDefaultReader>> acquire_readable_stream_default_reader(ReadableStream&);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamBYOBReader>> acquire_readable_stream_byob_reader(ReadableStream&);
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamDefaultReader>> acquire_readable_stream_default_reader(ReadableStream&);
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamBYOBReader>> acquire_readable_stream_byob_reader(ReadableStream&);
 bool is_readable_stream_locked(ReadableStream const&);
 
-JS::NonnullGCPtr<SizeAlgorithm> extract_size_algorithm(JS::VM&, QueuingStrategy const&);
+GC::Ref<SizeAlgorithm> extract_size_algorithm(JS::VM&, QueuingStrategy const&);
 WebIDL::ExceptionOr<double> extract_high_water_mark(QueuingStrategy const&, double default_hwm);
 
 void readable_stream_close(ReadableStream&);
 void readable_stream_error(ReadableStream&, JS::Value error);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> readable_stream_from_iterable(JS::VM& vm, JS::Value async_iterable);
-void readable_stream_add_read_request(ReadableStream&, JS::NonnullGCPtr<ReadRequest>);
-void readable_stream_add_read_into_request(ReadableStream&, JS::NonnullGCPtr<ReadIntoRequest>);
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_cancel(ReadableStream&, JS::Value reason);
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> readable_stream_from_iterable(JS::VM& vm, JS::Value async_iterable);
+void readable_stream_add_read_request(ReadableStream&, GC::Ref<ReadRequest>);
+void readable_stream_add_read_into_request(ReadableStream&, GC::Ref<ReadIntoRequest>);
+GC::Ref<WebIDL::Promise> readable_stream_cancel(ReadableStream&, JS::Value reason);
 void readable_stream_fulfill_read_into_request(ReadableStream&, JS::Value chunk, bool done);
 void readable_stream_fulfill_read_request(ReadableStream&, JS::Value chunk, bool done);
 size_t readable_stream_get_num_read_into_requests(ReadableStream const&);
@@ -49,13 +49,13 @@ size_t readable_stream_get_num_read_requests(ReadableStream const&);
 bool readable_stream_has_byob_reader(ReadableStream const&);
 bool readable_stream_has_default_reader(ReadableStream const&);
 
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source, WritableStream& dest, bool prevent_close, bool prevent_abort, bool prevent_cancel, Optional<JS::Value> signal);
+GC::Ref<WebIDL::Promise> readable_stream_pipe_to(ReadableStream& source, WritableStream& dest, bool prevent_close, bool prevent_abort, bool prevent_cancel, Optional<JS::Value> signal);
 
 WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_tee(JS::Realm&, ReadableStream&, bool clone_for_branch2);
 WebIDL::ExceptionOr<ReadableStreamPair> readable_stream_default_tee(JS::Realm& realm, ReadableStream& stream, bool clone_for_branch2);
 WebIDL::ExceptionOr<ReadableStreamPair> readable_byte_stream_tee(JS::Realm& realm, ReadableStream& stream);
 
-JS::NonnullGCPtr<WebIDL::Promise> readable_stream_reader_generic_cancel(ReadableStreamGenericReaderMixin&, JS::Value reason);
+GC::Ref<WebIDL::Promise> readable_stream_reader_generic_cancel(ReadableStreamGenericReaderMixin&, JS::Value reason);
 void readable_stream_reader_generic_initialize(ReadableStreamReader, ReadableStream&);
 void readable_stream_reader_generic_release(ReadableStreamGenericReaderMixin&);
 
@@ -81,12 +81,12 @@ void readable_stream_default_controller_clear_algorithms(ReadableStreamDefaultCo
 void readable_stream_default_controller_error(ReadableStreamDefaultController&, JS::Value error);
 Optional<double> readable_stream_default_controller_get_desired_size(ReadableStreamDefaultController&);
 bool readable_stream_default_controller_can_close_or_enqueue(ReadableStreamDefaultController&);
-WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStream&, ReadableStreamDefaultController&, JS::NonnullGCPtr<StartAlgorithm>, JS::NonnullGCPtr<PullAlgorithm>, JS::NonnullGCPtr<CancelAlgorithm>, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm>);
-WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underlying_source(ReadableStream&, JS::Value underlying_source_value, UnderlyingSource, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm>);
-void set_up_readable_stream_controller_with_byte_reading_support(ReadableStream&, JS::GCPtr<PullAlgorithm> = {}, JS::GCPtr<CancelAlgorithm> = {}, double high_water_mark = 0);
-WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream&, ReadableByteStreamController&, JS::NonnullGCPtr<StartAlgorithm>, JS::NonnullGCPtr<PullAlgorithm>, JS::NonnullGCPtr<CancelAlgorithm>, double high_water_mark, JS::Value auto_allocate_chunk_size);
+WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller(ReadableStream&, ReadableStreamDefaultController&, GC::Ref<StartAlgorithm>, GC::Ref<PullAlgorithm>, GC::Ref<CancelAlgorithm>, double high_water_mark, GC::Ref<SizeAlgorithm>);
+WebIDL::ExceptionOr<void> set_up_readable_stream_default_controller_from_underlying_source(ReadableStream&, JS::Value underlying_source_value, UnderlyingSource, double high_water_mark, GC::Ref<SizeAlgorithm>);
+void set_up_readable_stream_controller_with_byte_reading_support(ReadableStream&, GC::Ptr<PullAlgorithm> = {}, GC::Ptr<CancelAlgorithm> = {}, double high_water_mark = 0);
+WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller(ReadableStream&, ReadableByteStreamController&, GC::Ref<StartAlgorithm>, GC::Ref<PullAlgorithm>, GC::Ref<CancelAlgorithm>, double high_water_mark, JS::Value auto_allocate_chunk_size);
 WebIDL::ExceptionOr<void> set_up_readable_byte_stream_controller_from_underlying_source(ReadableStream&, JS::Value underlying_source, UnderlyingSource const& underlying_source_dict, double high_water_mark);
-JS::GCPtr<ReadableStreamBYOBRequest> readable_byte_stream_controller_get_byob_request(JS::NonnullGCPtr<ReadableByteStreamController>);
+GC::Ptr<ReadableStreamBYOBRequest> readable_byte_stream_controller_get_byob_request(GC::Ref<ReadableByteStreamController>);
 
 WebIDL::ExceptionOr<void> readable_byte_stream_controller_respond_in_readable_state(ReadableByteStreamController&, u64 bytes_written, PullIntoDescriptor&);
 void readable_byte_stream_controller_respond_in_closed_state(ReadableByteStreamController&, PullIntoDescriptor&);
@@ -97,12 +97,12 @@ WebIDL::ExceptionOr<void> readable_byte_stream_controller_respond_with_new_view(
 WebIDL::ExceptionOr<void> readable_stream_enqueue(ReadableStreamController& controller, JS::Value chunk);
 WebIDL::ExceptionOr<void> readable_byte_stream_controller_enqueue(ReadableByteStreamController& controller, JS::Value chunk);
 WebIDL::ExceptionOr<void> readable_stream_pull_from_bytes(ReadableStream&, ByteBuffer bytes);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> transfer_array_buffer(JS::Realm& realm, JS::ArrayBuffer& buffer);
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> transfer_array_buffer(JS::Realm& realm, JS::ArrayBuffer& buffer);
 WebIDL::ExceptionOr<void> readable_byte_stream_controller_enqueue_detached_pull_into_queue(ReadableByteStreamController& controller, PullIntoDescriptor& pull_into_descriptor);
 void readable_byte_stream_controller_commit_pull_into_descriptor(ReadableStream&, PullIntoDescriptor const&);
 void readable_byte_stream_controller_process_read_requests_using_queue(ReadableByteStreamController& controller);
 void readable_byte_stream_controller_process_pull_into_descriptors_using_queue(ReadableByteStreamController&);
-void readable_byte_stream_controller_enqueue_chunk_to_queue(ReadableByteStreamController& controller, JS::NonnullGCPtr<JS::ArrayBuffer> buffer, u32 byte_offset, u32 byte_length);
+void readable_byte_stream_controller_enqueue_chunk_to_queue(ReadableByteStreamController& controller, GC::Ref<JS::ArrayBuffer> buffer, u32 byte_offset, u32 byte_length);
 WebIDL::ExceptionOr<void> readable_byte_stream_controller_enqueue_cloned_chunk_to_queue(ReadableByteStreamController& controller, JS::ArrayBuffer& buffer, u64 byte_offset, u64 byte_length);
 PullIntoDescriptor readable_byte_stream_controller_shift_pending_pull_into(ReadableByteStreamController& controller);
 
@@ -111,27 +111,27 @@ void readable_byte_stream_controller_clear_algorithms(ReadableByteStreamControll
 void readable_byte_stream_controller_clear_pending_pull_intos(ReadableByteStreamController&);
 WebIDL::ExceptionOr<void> readable_byte_stream_controller_close(ReadableByteStreamController&);
 void readable_byte_stream_controller_error(ReadableByteStreamController&, JS::Value error);
-void readable_byte_stream_controller_fill_read_request_from_queue(ReadableByteStreamController&, JS::NonnullGCPtr<ReadRequest>);
+void readable_byte_stream_controller_fill_read_request_from_queue(ReadableByteStreamController&, GC::Ref<ReadRequest>);
 bool readable_byte_stream_controller_fill_pull_into_descriptor_from_queue(ReadableByteStreamController&, PullIntoDescriptor&);
 Optional<double> readable_byte_stream_controller_get_desired_size(ReadableByteStreamController const&);
 void readable_byte_stream_controller_handle_queue_drain(ReadableByteStreamController&);
 void readable_byte_stream_controller_invalidate_byob_request(ReadableByteStreamController&);
 bool readable_byte_stream_controller_should_call_pull(ReadableByteStreamController const&);
 
-WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStream& stream, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark = {}, JS::GCPtr<SizeAlgorithm> size_algorithm = {});
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark = {}, JS::GCPtr<SizeAlgorithm> size_algorithm = {});
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> create_readable_byte_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<PullAlgorithm> pull_algorithm, JS::NonnullGCPtr<CancelAlgorithm> cancel_algorithm);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStream>> create_writable_stream(JS::Realm& realm, JS::NonnullGCPtr<StartAlgorithm> start_algorithm, JS::NonnullGCPtr<WriteAlgorithm> write_algorithm, JS::NonnullGCPtr<CloseAlgorithm> close_algorithm, JS::NonnullGCPtr<AbortAlgorithm> abort_algorithm, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm);
+WebIDL::ExceptionOr<void> set_up_readable_stream(JS::Realm& realm, ReadableStream& stream, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark = {}, GC::Ptr<SizeAlgorithm> size_algorithm = {});
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> create_readable_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm, Optional<double> high_water_mark = {}, GC::Ptr<SizeAlgorithm> size_algorithm = {});
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> create_readable_byte_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<PullAlgorithm> pull_algorithm, GC::Ref<CancelAlgorithm> cancel_algorithm);
+WebIDL::ExceptionOr<GC::Ref<WritableStream>> create_writable_stream(JS::Realm& realm, GC::Ref<StartAlgorithm> start_algorithm, GC::Ref<WriteAlgorithm> write_algorithm, GC::Ref<CloseAlgorithm> close_algorithm, GC::Ref<AbortAlgorithm> abort_algorithm, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm);
 void initialize_readable_stream(ReadableStream&);
 void initialize_writable_stream(WritableStream&);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> acquire_writable_stream_default_writer(WritableStream&);
+WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> acquire_writable_stream_default_writer(WritableStream&);
 bool is_writable_stream_locked(WritableStream const&);
 WebIDL::ExceptionOr<void> set_up_writable_stream_default_writer(WritableStreamDefaultWriter&, WritableStream&);
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_abort(WritableStream&, JS::Value reason);
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_close(WritableStream&);
+GC::Ref<WebIDL::Promise> writable_stream_abort(WritableStream&, JS::Value reason);
+GC::Ref<WebIDL::Promise> writable_stream_close(WritableStream&);
 
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_add_write_request(WritableStream&);
+GC::Ref<WebIDL::Promise> writable_stream_add_write_request(WritableStream&);
 bool writable_stream_close_queued_or_in_flight(WritableStream const&);
 void writable_stream_deal_with_rejection(WritableStream&, JS::Value error);
 void writable_stream_finish_erroring(WritableStream&);
@@ -146,16 +146,16 @@ void writable_stream_reject_close_and_closed_promise_if_needed(WritableStream&);
 void writable_stream_start_erroring(WritableStream&, JS::Value reason);
 void writable_stream_update_backpressure(WritableStream&, bool backpressure);
 
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_abort(WritableStreamDefaultWriter&, JS::Value reason);
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_close(WritableStreamDefaultWriter&);
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_abort(WritableStreamDefaultWriter&, JS::Value reason);
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_close(WritableStreamDefaultWriter&);
 void writable_stream_default_writer_ensure_closed_promise_rejected(WritableStreamDefaultWriter&, JS::Value error);
 void writable_stream_default_writer_ensure_ready_promise_rejected(WritableStreamDefaultWriter&, JS::Value error);
 Optional<double> writable_stream_default_writer_get_desired_size(WritableStreamDefaultWriter const&);
 void writable_stream_default_writer_release(WritableStreamDefaultWriter&);
-JS::NonnullGCPtr<WebIDL::Promise> writable_stream_default_writer_write(WritableStreamDefaultWriter&, JS::Value chunk);
+GC::Ref<WebIDL::Promise> writable_stream_default_writer_write(WritableStreamDefaultWriter&, JS::Value chunk);
 
-WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStream&, WritableStreamDefaultController&, JS::NonnullGCPtr<StartAlgorithm>, JS::NonnullGCPtr<WriteAlgorithm>, JS::NonnullGCPtr<CloseAlgorithm>, JS::NonnullGCPtr<AbortAlgorithm>, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm>);
-WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underlying_sink(WritableStream&, JS::Value underlying_sink_value, UnderlyingSink&, double high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> size_algorithm);
+WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller(WritableStream&, WritableStreamDefaultController&, GC::Ref<StartAlgorithm>, GC::Ref<WriteAlgorithm>, GC::Ref<CloseAlgorithm>, GC::Ref<AbortAlgorithm>, double high_water_mark, GC::Ref<SizeAlgorithm>);
+WebIDL::ExceptionOr<void> set_up_writable_stream_default_controller_from_underlying_sink(WritableStream&, JS::Value underlying_sink_value, UnderlyingSink&, double high_water_mark, GC::Ref<SizeAlgorithm> size_algorithm);
 void writable_stream_default_controller_advance_queue_if_needed(WritableStreamDefaultController&);
 void writable_stream_default_controller_clear_algorithms(WritableStreamDefaultController&);
 void writable_stream_default_controller_close(WritableStreamDefaultController&);
@@ -168,23 +168,23 @@ void writable_stream_default_controller_process_close(WritableStreamDefaultContr
 void writable_stream_default_controller_process_write(WritableStreamDefaultController&, JS::Value chunk);
 void writable_stream_default_controller_write(WritableStreamDefaultController&, JS::Value chunk, JS::Value chunk_size);
 
-void initialize_transform_stream(TransformStream&, JS::NonnullGCPtr<WebIDL::Promise> start_promise, double writable_high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> writable_size_algorithm, double readable_high_water_mark, JS::NonnullGCPtr<SizeAlgorithm> readable_size_algorithm);
-void set_up_transform_stream_default_controller(TransformStream&, TransformStreamDefaultController&, JS::NonnullGCPtr<TransformAlgorithm>, JS::NonnullGCPtr<FlushAlgorithm>, JS::NonnullGCPtr<CancelAlgorithm>);
+void initialize_transform_stream(TransformStream&, GC::Ref<WebIDL::Promise> start_promise, double writable_high_water_mark, GC::Ref<SizeAlgorithm> writable_size_algorithm, double readable_high_water_mark, GC::Ref<SizeAlgorithm> readable_size_algorithm);
+void set_up_transform_stream_default_controller(TransformStream&, TransformStreamDefaultController&, GC::Ref<TransformAlgorithm>, GC::Ref<FlushAlgorithm>, GC::Ref<CancelAlgorithm>);
 void set_up_transform_stream_default_controller_from_transformer(TransformStream&, JS::Value transformer, Transformer&);
 void transform_stream_default_controller_clear_algorithms(TransformStreamDefaultController&);
 WebIDL::ExceptionOr<void> transform_stream_default_controller_enqueue(TransformStreamDefaultController&, JS::Value chunk);
 void transform_stream_default_controller_error(TransformStreamDefaultController&, JS::Value error);
 void transform_stream_default_controller_terminate(TransformStreamDefaultController&);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_controller_perform_transform(TransformStreamDefaultController&, JS::Value chunk);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(TransformStream&, JS::Value reason);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_close_algorithm(TransformStream&);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_sink_write_algorithm(TransformStream&, JS::Value chunk);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_pull_algorithm(TransformStream&);
-JS::NonnullGCPtr<WebIDL::Promise> transform_stream_default_source_cancel_algorithm(TransformStream&, JS::Value reason);
+GC::Ref<WebIDL::Promise> transform_stream_default_controller_perform_transform(TransformStreamDefaultController&, JS::Value chunk);
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_abort_algorithm(TransformStream&, JS::Value reason);
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_close_algorithm(TransformStream&);
+GC::Ref<WebIDL::Promise> transform_stream_default_sink_write_algorithm(TransformStream&, JS::Value chunk);
+GC::Ref<WebIDL::Promise> transform_stream_default_source_pull_algorithm(TransformStream&);
+GC::Ref<WebIDL::Promise> transform_stream_default_source_cancel_algorithm(TransformStream&, JS::Value reason);
 void transform_stream_error(TransformStream&, JS::Value error);
 void transform_stream_error_writable_and_unblock_write(TransformStream&, JS::Value error);
 void transform_stream_set_backpressure(TransformStream&, bool backpressure);
-void transform_stream_set_up(TransformStream&, JS::NonnullGCPtr<TransformAlgorithm>, JS::GCPtr<FlushAlgorithm> = {}, JS::GCPtr<CancelAlgorithm> = {});
+void transform_stream_set_up(TransformStream&, GC::Ref<TransformAlgorithm>, GC::Ptr<FlushAlgorithm> = {}, GC::Ptr<CancelAlgorithm> = {});
 void transform_stream_unblock_write(TransformStream&);
 
 bool is_non_negative_number(JS::Value);
@@ -194,7 +194,7 @@ WebIDL::ExceptionOr<JS::Value> structured_clone(JS::Realm&, JS::Value value);
 
 JS::Value create_close_sentinel();
 bool is_close_sentinel(JS::Value);
-JS::ThrowCompletionOr<JS::Handle<WebIDL::CallbackType>> property_to_callback(JS::VM& vm, JS::Value value, JS::PropertyKey const& property_key, WebIDL::OperationReturnsPromise);
+JS::ThrowCompletionOr<GC::Root<WebIDL::CallbackType>> property_to_callback(JS::VM& vm, JS::Value value, JS::PropertyKey const& property_key, WebIDL::OperationReturnsPromise);
 
 // https://streams.spec.whatwg.org/#value-with-size
 struct ValueWithSize {
diff --git a/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp b/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp
index 455dabc1d93..ca38178aa51 100644
--- a/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp
+++ b/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.cpp
@@ -12,10 +12,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ByteLengthQueuingStrategy);
+GC_DEFINE_ALLOCATOR(ByteLengthQueuingStrategy);
 
 // https://streams.spec.whatwg.org/#blqs-constructor
-JS::NonnullGCPtr<ByteLengthQueuingStrategy> ByteLengthQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
+GC::Ref<ByteLengthQueuingStrategy> ByteLengthQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
 {
     // The new ByteLengthQueuingStrategy(init) constructor steps are:
     // 1. Set this.[[highWaterMark]] to init["highWaterMark"].
@@ -31,7 +31,7 @@ ByteLengthQueuingStrategy::ByteLengthQueuingStrategy(JS::Realm& realm, double hi
 ByteLengthQueuingStrategy::~ByteLengthQueuingStrategy() = default;
 
 // https://streams.spec.whatwg.org/#blqs-size
-JS::NonnullGCPtr<WebIDL::CallbackType> ByteLengthQueuingStrategy::size()
+GC::Ref<WebIDL::CallbackType> ByteLengthQueuingStrategy::size()
 {
     // 1. Return this's relevant global object's byte length queuing strategy size function.
     return verify_cast<HTML::Window>(HTML::relevant_global_object(*this)).byte_length_queuing_strategy_size_function();
diff --git a/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h b/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h
index 7940b42952b..3bbbe0a55f2 100644
--- a/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h
+++ b/Libraries/LibWeb/Streams/ByteLengthQueuingStrategy.h
@@ -17,10 +17,10 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#bytelengthqueuingstrategy
 class ByteLengthQueuingStrategy final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ByteLengthQueuingStrategy, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ByteLengthQueuingStrategy);
+    GC_DECLARE_ALLOCATOR(ByteLengthQueuingStrategy);
 
 public:
-    static JS::NonnullGCPtr<ByteLengthQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
+    static GC::Ref<ByteLengthQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
 
     virtual ~ByteLengthQueuingStrategy() override;
 
@@ -32,7 +32,7 @@ public:
         return m_high_water_mark;
     }
 
-    JS::NonnullGCPtr<WebIDL::CallbackType> size();
+    GC::Ref<WebIDL::CallbackType> size();
 
 private:
     explicit ByteLengthQueuingStrategy(JS::Realm&, double high_water_mark);
diff --git a/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp b/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp
index 194e2e1a07d..c0a4e7c2147 100644
--- a/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp
+++ b/Libraries/LibWeb/Streams/CountQueuingStrategy.cpp
@@ -12,10 +12,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(CountQueuingStrategy);
+GC_DEFINE_ALLOCATOR(CountQueuingStrategy);
 
 // https://streams.spec.whatwg.org/#blqs-constructor
-JS::NonnullGCPtr<CountQueuingStrategy> CountQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
+GC::Ref<CountQueuingStrategy> CountQueuingStrategy::construct_impl(JS::Realm& realm, QueuingStrategyInit const& init)
 {
     // The new CountQueuingStrategy(init) constructor steps are:
     // 1. Set this.[[highWaterMark]] to init["highWaterMark"].
@@ -31,7 +31,7 @@ CountQueuingStrategy::CountQueuingStrategy(JS::Realm& realm, double high_water_m
 CountQueuingStrategy::~CountQueuingStrategy() = default;
 
 // https://streams.spec.whatwg.org/#cqs-size
-JS::NonnullGCPtr<WebIDL::CallbackType> CountQueuingStrategy::size()
+GC::Ref<WebIDL::CallbackType> CountQueuingStrategy::size()
 {
     // 1. Return this's relevant global object's count queuing strategy size function.
     return verify_cast<HTML::Window>(HTML::relevant_global_object(*this)).count_queuing_strategy_size_function();
diff --git a/Libraries/LibWeb/Streams/CountQueuingStrategy.h b/Libraries/LibWeb/Streams/CountQueuingStrategy.h
index 17cb26d1eb6..a19d6cc40c3 100644
--- a/Libraries/LibWeb/Streams/CountQueuingStrategy.h
+++ b/Libraries/LibWeb/Streams/CountQueuingStrategy.h
@@ -17,10 +17,10 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#countqueuingstrategy
 class CountQueuingStrategy final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(CountQueuingStrategy, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(CountQueuingStrategy);
+    GC_DECLARE_ALLOCATOR(CountQueuingStrategy);
 
 public:
-    static JS::NonnullGCPtr<CountQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
+    static GC::Ref<CountQueuingStrategy> construct_impl(JS::Realm&, QueuingStrategyInit const&);
 
     virtual ~CountQueuingStrategy() override;
 
@@ -32,7 +32,7 @@ public:
         return m_high_water_mark;
     }
 
-    JS::NonnullGCPtr<WebIDL::CallbackType> size();
+    GC::Ref<WebIDL::CallbackType> size();
 
 private:
     explicit CountQueuingStrategy(JS::Realm&, double high_water_mark);
diff --git a/Libraries/LibWeb/Streams/QueuingStrategy.h b/Libraries/LibWeb/Streams/QueuingStrategy.h
index 75c4e2f93e3..f4c81b7e6d6 100644
--- a/Libraries/LibWeb/Streams/QueuingStrategy.h
+++ b/Libraries/LibWeb/Streams/QueuingStrategy.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include <AK/Optional.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/WebIDL/CallbackType.h>
 
 namespace Web::Streams {
@@ -15,7 +15,7 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#dictdef-queuingstrategy
 struct QueuingStrategy {
     Optional<double> high_water_mark;
-    JS::GCPtr<WebIDL::CallbackType> size;
+    GC::Ptr<WebIDL::CallbackType> size;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableByteStreamController.cpp b/Libraries/LibWeb/Streams/ReadableByteStreamController.cpp
index 720f8930dd5..886bd529137 100644
--- a/Libraries/LibWeb/Streams/ReadableByteStreamController.cpp
+++ b/Libraries/LibWeb/Streams/ReadableByteStreamController.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableByteStreamController);
+GC_DEFINE_ALLOCATOR(ReadableByteStreamController);
 
 // https://streams.spec.whatwg.org/#rbs-controller-desired-size
 Optional<double> ReadableByteStreamController::desired_size() const
@@ -27,7 +27,7 @@ Optional<double> ReadableByteStreamController::desired_size() const
 }
 
 // https://streams.spec.whatwg.org/#rbs-controller-byob-request
-JS::GCPtr<ReadableStreamBYOBRequest> ReadableByteStreamController::byob_request()
+GC::Ptr<ReadableStreamBYOBRequest> ReadableByteStreamController::byob_request()
 {
     // 1. Return ! ReadableByteStreamControllerGetBYOBRequest(this).
     return readable_byte_stream_controller_get_byob_request(*this);
@@ -71,7 +71,7 @@ void ReadableByteStreamController::initialize(JS::Realm& realm)
 }
 
 // https://streams.spec.whatwg.org/#rbs-controller-enqueue
-WebIDL::ExceptionOr<void> ReadableByteStreamController::enqueue(JS::Handle<WebIDL::ArrayBufferView>& chunk)
+WebIDL::ExceptionOr<void> ReadableByteStreamController::enqueue(GC::Root<WebIDL::ArrayBufferView>& chunk)
 {
     // 1. If chunk.[[ByteLength]] is 0, throw a TypeError exception.
     // 2. If chunk.[[ViewedArrayBuffer]].[[ArrayBufferByteLength]] is 0, throw a TypeError exception.
@@ -91,7 +91,7 @@ WebIDL::ExceptionOr<void> ReadableByteStreamController::enqueue(JS::Handle<WebID
 }
 
 // https://streams.spec.whatwg.org/#rbs-controller-private-cancel
-JS::NonnullGCPtr<WebIDL::Promise> ReadableByteStreamController::cancel_steps(JS::Value reason)
+GC::Ref<WebIDL::Promise> ReadableByteStreamController::cancel_steps(JS::Value reason)
 {
     // 1. Perform ! ReadableByteStreamControllerClearPendingPullIntos(this).
     readable_byte_stream_controller_clear_pending_pull_intos(*this);
@@ -110,7 +110,7 @@ JS::NonnullGCPtr<WebIDL::Promise> ReadableByteStreamController::cancel_steps(JS:
 }
 
 // https://streams.spec.whatwg.org/#rbs-controller-private-pull
-void ReadableByteStreamController::pull_steps(JS::NonnullGCPtr<ReadRequest> read_request)
+void ReadableByteStreamController::pull_steps(GC::Ref<ReadRequest> read_request)
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/Streams/ReadableByteStreamController.h b/Libraries/LibWeb/Streams/ReadableByteStreamController.h
index 72bc8a221a6..9a9946abc37 100644
--- a/Libraries/LibWeb/Streams/ReadableByteStreamController.h
+++ b/Libraries/LibWeb/Streams/ReadableByteStreamController.h
@@ -23,7 +23,7 @@ enum class ReaderType {
 struct PullIntoDescriptor {
     // https://streams.spec.whatwg.org/#pull-into-descriptor-buffer
     // An ArrayBuffer
-    JS::NonnullGCPtr<JS::ArrayBuffer> buffer;
+    GC::Ref<JS::ArrayBuffer> buffer;
 
     // https://streams.spec.whatwg.org/#pull-into-descriptor-buffer-byte-length
     // A positive integer representing the initial byte length of buffer
@@ -51,7 +51,7 @@ struct PullIntoDescriptor {
 
     // https://streams.spec.whatwg.org/#pull-into-descriptor-view-constructor
     // A typed array constructor or %DataView%, which will be used for constructing a view with which to write into the buffer
-    JS::NonnullGCPtr<JS::NativeFunction> view_constructor;
+    GC::Ref<JS::NativeFunction> view_constructor;
 
     // https://streams.spec.whatwg.org/#pull-into-descriptor-reader-type
     // Either "default" or "byob", indicating what type of readable stream reader initiated this request, or "none" if the initiating reader was released
@@ -62,7 +62,7 @@ struct PullIntoDescriptor {
 struct ReadableByteStreamQueueEntry {
     // https://streams.spec.whatwg.org/#readable-byte-stream-queue-entry-buffer
     // An ArrayBuffer, which will be a transferred version of the one originally supplied by the underlying byte source
-    JS::NonnullGCPtr<JS::ArrayBuffer> buffer;
+    GC::Ref<JS::ArrayBuffer> buffer;
 
     // https://streams.spec.whatwg.org/#readable-byte-stream-queue-entry-byte-offset
     // A nonnegative integer number giving the byte offset derived from the view originally supplied by the underlying byte source
@@ -76,30 +76,30 @@ struct ReadableByteStreamQueueEntry {
 // https://streams.spec.whatwg.org/#readablebytestreamcontroller
 class ReadableByteStreamController : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ReadableByteStreamController, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableByteStreamController);
+    GC_DECLARE_ALLOCATOR(ReadableByteStreamController);
 
 public:
     virtual ~ReadableByteStreamController() override = default;
 
     // IDL getter, returns current [[byobRequest]] (if any), and otherwise the [[byobRequest]] for the next pending pull into request
-    JS::GCPtr<ReadableStreamBYOBRequest> byob_request();
+    GC::Ptr<ReadableStreamBYOBRequest> byob_request();
 
-    void set_byob_request(JS::GCPtr<ReadableStreamBYOBRequest> request) { m_byob_request = request; }
+    void set_byob_request(GC::Ptr<ReadableStreamBYOBRequest> request) { m_byob_request = request; }
 
     // Raw [[byobRequest]] slot
-    JS::GCPtr<ReadableStreamBYOBRequest const> raw_byob_request() const { return m_byob_request; }
-    JS::GCPtr<ReadableStreamBYOBRequest> raw_byob_request() { return m_byob_request; }
+    GC::Ptr<ReadableStreamBYOBRequest const> raw_byob_request() const { return m_byob_request; }
+    GC::Ptr<ReadableStreamBYOBRequest> raw_byob_request() { return m_byob_request; }
 
     Optional<double> desired_size() const;
     WebIDL::ExceptionOr<void> close();
     void error(JS::Value error);
-    WebIDL::ExceptionOr<void> enqueue(JS::Handle<WebIDL::ArrayBufferView>&);
+    WebIDL::ExceptionOr<void> enqueue(GC::Root<WebIDL::ArrayBufferView>&);
 
     Optional<u64> const& auto_allocate_chunk_size() { return m_auto_allocate_chunk_size; }
     void set_auto_allocate_chunk_size(Optional<u64> value) { m_auto_allocate_chunk_size = value; }
 
-    JS::GCPtr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
-    void set_cancel_algorithm(JS::GCPtr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
+    GC::Ptr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
+    void set_cancel_algorithm(GC::Ptr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
 
     bool close_requested() const { return m_close_requested; }
     void set_close_requested(bool value) { m_close_requested = value; }
@@ -107,8 +107,8 @@ public:
     bool pull_again() const { return m_pull_again; }
     void set_pull_again(bool value) { m_pull_again = value; }
 
-    JS::GCPtr<PullAlgorithm> pull_algorithm() { return m_pull_algorithm; }
-    void set_pull_algorithm(JS::GCPtr<PullAlgorithm> value) { m_pull_algorithm = value; }
+    GC::Ptr<PullAlgorithm> pull_algorithm() { return m_pull_algorithm; }
+    void set_pull_algorithm(GC::Ptr<PullAlgorithm> value) { m_pull_algorithm = value; }
 
     bool pulling() const { return m_pulling; }
     void set_pulling(bool value) { m_pulling = value; }
@@ -127,12 +127,12 @@ public:
     double strategy_hwm() const { return m_strategy_hwm; }
     void set_strategy_hwm(double value) { m_strategy_hwm = value; }
 
-    JS::GCPtr<ReadableStream const> stream() const { return m_stream; }
-    JS::GCPtr<ReadableStream> stream() { return m_stream; }
-    void set_stream(JS::GCPtr<ReadableStream> stream) { m_stream = stream; }
+    GC::Ptr<ReadableStream const> stream() const { return m_stream; }
+    GC::Ptr<ReadableStream> stream() { return m_stream; }
+    void set_stream(GC::Ptr<ReadableStream> stream) { m_stream = stream; }
 
-    JS::NonnullGCPtr<WebIDL::Promise> cancel_steps(JS::Value reason);
-    void pull_steps(JS::NonnullGCPtr<ReadRequest>);
+    GC::Ref<WebIDL::Promise> cancel_steps(JS::Value reason);
+    void pull_steps(GC::Ref<ReadRequest>);
     void release_steps();
 
 private:
@@ -148,11 +148,11 @@ private:
 
     // https://streams.spec.whatwg.org/#readablebytestreamcontroller-byobrequest
     // A ReadableStreamBYOBRequest instance representing the current BYOB pull request, or null if there are no pending requests
-    JS::GCPtr<ReadableStreamBYOBRequest> m_byob_request;
+    GC::Ptr<ReadableStreamBYOBRequest> m_byob_request;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-cancelalgorithm
     // A promise-returning algorithm, taking one argument (the cancel reason), which communicates a requested cancelation to the underlying source
-    JS::GCPtr<CancelAlgorithm> m_cancel_algorithm;
+    GC::Ptr<CancelAlgorithm> m_cancel_algorithm;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-closerequested
     // A boolean flag indicating whether the stream has been closed by its underlying source, but still has chunks in its internal queue that have not yet been read
@@ -164,7 +164,7 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-pullalgorithm
     // A promise-returning algorithm that pulls data from the underlying source
-    JS::GCPtr<PullAlgorithm> m_pull_algorithm;
+    GC::Ptr<PullAlgorithm> m_pull_algorithm;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-pulling
     // A boolean flag set to true while the underlying source's pull algorithm is executing and the returned promise has not yet fulfilled, used to prevent reentrant calls
@@ -192,7 +192,7 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-stream
     // The ReadableStream instance controlled
-    JS::GCPtr<ReadableStream> m_stream;
+    GC::Ptr<ReadableStream> m_stream;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStream.cpp b/Libraries/LibWeb/Streams/ReadableStream.cpp
index 0d4608bbc12..a18c9300c8b 100644
--- a/Libraries/LibWeb/Streams/ReadableStream.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStream.cpp
@@ -21,10 +21,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableStream);
+GC_DEFINE_ALLOCATOR(ReadableStream);
 
 // https://streams.spec.whatwg.org/#rs-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> const& underlying_source_object, QueuingStrategy const& strategy)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> ReadableStream::construct_impl(JS::Realm& realm, Optional<GC::Root<JS::Object>> const& underlying_source_object, QueuingStrategy const& strategy)
 {
     auto& vm = realm.vm();
 
@@ -69,7 +69,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::construct_
 }
 
 // https://streams.spec.whatwg.org/#rs-from
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::from(JS::VM& vm, JS::Value async_iterable)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> ReadableStream::from(JS::VM& vm, JS::Value async_iterable)
 {
     // 1. Return ? ReadableStreamFromIterable(asyncIterable).
     return TRY(readable_stream_from_iterable(vm, async_iterable));
@@ -90,7 +90,7 @@ bool ReadableStream::locked() const
 }
 
 // https://streams.spec.whatwg.org/#rs-cancel
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStream::cancel(JS::Value reason)
+GC::Ref<WebIDL::Promise> ReadableStream::cancel(JS::Value reason)
 {
     auto& realm = this->realm();
 
@@ -118,7 +118,7 @@ WebIDL::ExceptionOr<ReadableStreamReader> ReadableStream::get_reader(ReadableStr
     return ReadableStreamReader { TRY(acquire_readable_stream_byob_reader(*this)) };
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::pipe_through(ReadableWritablePair transform, StreamPipeOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<ReadableStream>> ReadableStream::pipe_through(ReadableWritablePair transform, StreamPipeOptions const& options)
 {
     // 1. If ! IsReadableStreamLocked(this) is true, throw a TypeError exception.
     if (is_readable_stream_locked(*this))
@@ -138,10 +138,10 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> ReadableStream::pipe_throu
     WebIDL::mark_promise_as_handled(*promise);
 
     // 6. Return transform["readable"].
-    return JS::NonnullGCPtr { *transform.readable };
+    return GC::Ref { *transform.readable };
 }
 
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)
+GC::Ref<WebIDL::Promise> ReadableStream::pipe_to(WritableStream& destination, StreamPipeOptions const& options)
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
@@ -175,7 +175,7 @@ void ReadableStream::close()
 {
     controller()->visit(
         // 1. If stream.[[controller]] implements ReadableByteStreamController
-        [&](JS::NonnullGCPtr<ReadableByteStreamController> controller) {
+        [&](GC::Ref<ReadableByteStreamController> controller) {
             // 1. Perform ! ReadableByteStreamControllerClose(stream.[[controller]]).
             MUST(readable_byte_stream_controller_close(controller));
 
@@ -185,7 +185,7 @@ void ReadableStream::close()
         },
 
         // 2. Otherwise, perform ! ReadableStreamDefaultControllerClose(stream.[[controller]]).
-        [&](JS::NonnullGCPtr<ReadableStreamDefaultController> controller) {
+        [&](GC::Ref<ReadableStreamDefaultController> controller) {
             readable_stream_default_controller_close(*controller);
         });
 }
@@ -196,12 +196,12 @@ void ReadableStream::error(JS::Value error)
     controller()->visit(
         // 1. If stream.[[controller]] implements ReadableByteStreamController, then perform
         //    ! ReadableByteStreamControllerError(stream.[[controller]], e).
-        [&](JS::NonnullGCPtr<ReadableByteStreamController> controller) {
+        [&](GC::Ref<ReadableByteStreamController> controller) {
             readable_byte_stream_controller_error(controller, error);
         },
 
         // 2. Otherwise, perform ! ReadableStreamDefaultControllerError(stream.[[controller]], e).
-        [&](JS::NonnullGCPtr<ReadableStreamDefaultController> controller) {
+        [&](GC::Ref<ReadableStreamDefaultController> controller) {
             readable_stream_default_controller_error(controller, error);
         });
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStream.h b/Libraries/LibWeb/Streams/ReadableStream.h
index 621af87a3b1..e260ef31393 100644
--- a/Libraries/LibWeb/Streams/ReadableStream.h
+++ b/Libraries/LibWeb/Streams/ReadableStream.h
@@ -17,10 +17,10 @@
 namespace Web::Streams {
 
 // https://streams.spec.whatwg.org/#typedefdef-readablestreamreader
-using ReadableStreamReader = Variant<JS::NonnullGCPtr<ReadableStreamDefaultReader>, JS::NonnullGCPtr<ReadableStreamBYOBReader>>;
+using ReadableStreamReader = Variant<GC::Ref<ReadableStreamDefaultReader>, GC::Ref<ReadableStreamBYOBReader>>;
 
 // https://streams.spec.whatwg.org/#typedefdef-readablestreamcontroller
-using ReadableStreamController = Variant<JS::NonnullGCPtr<ReadableStreamDefaultController>, JS::NonnullGCPtr<ReadableByteStreamController>>;
+using ReadableStreamController = Variant<GC::Ref<ReadableStreamDefaultController>, GC::Ref<ReadableByteStreamController>>;
 
 // https://streams.spec.whatwg.org/#dictdef-readablestreamgetreaderoptions
 struct ReadableStreamGetReaderOptions {
@@ -28,22 +28,22 @@ struct ReadableStreamGetReaderOptions {
 };
 
 struct ReadableWritablePair {
-    JS::GCPtr<ReadableStream> readable;
-    JS::GCPtr<WritableStream> writable;
+    GC::Ptr<ReadableStream> readable;
+    GC::Ptr<WritableStream> writable;
 };
 
 struct StreamPipeOptions {
     bool prevent_close { false };
     bool prevent_abort { false };
     bool prevent_cancel { false };
-    JS::GCPtr<DOM::AbortSignal> signal;
+    GC::Ptr<DOM::AbortSignal> signal;
 };
 
 struct ReadableStreamPair {
     // Define a couple container-like methods so this type may be used as the return type of the IDL `tee` implementation.
     size_t size() const { return 2; }
 
-    JS::NonnullGCPtr<ReadableStream>& at(size_t index)
+    GC::Ref<ReadableStream>& at(size_t index)
     {
         if (index == 0)
             return first;
@@ -52,14 +52,14 @@ struct ReadableStreamPair {
         VERIFY_NOT_REACHED();
     }
 
-    JS::NonnullGCPtr<ReadableStream> first;
-    JS::NonnullGCPtr<ReadableStream> second;
+    GC::Ref<ReadableStream> first;
+    GC::Ref<ReadableStream> second;
 };
 
 // https://streams.spec.whatwg.org/#readablestream
 class ReadableStream final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ReadableStream, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableStream);
+    GC_DECLARE_ALLOCATOR(ReadableStream);
 
 public:
     enum class State {
@@ -68,17 +68,17 @@ public:
         Errored,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> construct_impl(JS::Realm&, Optional<JS::Handle<JS::Object>> const& underlying_source, QueuingStrategy const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<ReadableStream>> construct_impl(JS::Realm&, Optional<GC::Root<JS::Object>> const& underlying_source, QueuingStrategy const& = {});
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> from(JS::VM& vm, JS::Value async_iterable);
+    static WebIDL::ExceptionOr<GC::Ref<ReadableStream>> from(JS::VM& vm, JS::Value async_iterable);
 
     virtual ~ReadableStream() override;
 
     bool locked() const;
-    JS::NonnullGCPtr<WebIDL::Promise> cancel(JS::Value reason);
+    GC::Ref<WebIDL::Promise> cancel(JS::Value reason);
     WebIDL::ExceptionOr<ReadableStreamReader> get_reader(ReadableStreamGetReaderOptions const& = {});
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStream>> pipe_through(ReadableWritablePair transform, StreamPipeOptions const& = {});
-    JS::NonnullGCPtr<WebIDL::Promise> pipe_to(WritableStream& destination, StreamPipeOptions const& = {});
+    WebIDL::ExceptionOr<GC::Ref<ReadableStream>> pipe_through(ReadableWritablePair transform, StreamPipeOptions const& = {});
+    GC::Ref<WebIDL::Promise> pipe_to(WritableStream& destination, StreamPipeOptions const& = {});
     WebIDL::ExceptionOr<ReadableStreamPair> tee();
 
     void close();
diff --git a/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp b/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp
index 4e57562e78e..a619e71a40f 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.cpp
@@ -17,7 +17,7 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableStreamBYOBReader);
+GC_DEFINE_ALLOCATOR(ReadableStreamBYOBReader);
 
 ReadableStreamBYOBReader::ReadableStreamBYOBReader(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -32,7 +32,7 @@ void ReadableStreamBYOBReader::initialize(JS::Realm& realm)
 }
 
 // https://streams.spec.whatwg.org/#byob-reader-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamBYOBReader>> ReadableStreamBYOBReader::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<ReadableStream> stream)
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamBYOBReader>> ReadableStreamBYOBReader::construct_impl(JS::Realm& realm, GC::Ref<ReadableStream> stream)
 {
     auto reader = realm.create<ReadableStreamBYOBReader>(realm);
 
@@ -61,8 +61,8 @@ void ReadableStreamBYOBReader::visit_edges(Cell::Visitor& visitor)
 }
 
 class BYOBReaderReadIntoRequest : public ReadIntoRequest {
-    JS_CELL(BYOBReaderReadIntoRequest, ReadIntoRequest);
-    JS_DECLARE_ALLOCATOR(BYOBReaderReadIntoRequest);
+    GC_CELL(BYOBReaderReadIntoRequest, ReadIntoRequest);
+    GC_DECLARE_ALLOCATOR(BYOBReaderReadIntoRequest);
 
 public:
     BYOBReaderReadIntoRequest(JS::Realm& realm, WebIDL::Promise& promise)
@@ -100,14 +100,14 @@ private:
         visitor.visit(m_promise);
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<WebIDL::Promise> m_promise;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<WebIDL::Promise> m_promise;
 };
 
-JS_DEFINE_ALLOCATOR(BYOBReaderReadIntoRequest);
+GC_DEFINE_ALLOCATOR(BYOBReaderReadIntoRequest);
 
 // https://streams.spec.whatwg.org/#byob-reader-read
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamBYOBReader::read(JS::Handle<WebIDL::ArrayBufferView>& view, ReadableStreamBYOBReaderReadOptions options)
+GC::Ref<WebIDL::Promise> ReadableStreamBYOBReader::read(GC::Root<WebIDL::ArrayBufferView>& view, ReadableStreamBYOBReaderReadOptions options)
 {
     auto& realm = this->realm();
 
@@ -137,7 +137,7 @@ JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamBYOBReader::read(JS::Handle<WebI
 
     // 5. If view has a [[TypedArrayName]] internal slot,
     if (view->is_typed_array_base()) {
-        auto const& typed_array = *view->bufferable_object().get<JS::NonnullGCPtr<JS::TypedArrayBase>>();
+        auto const& typed_array = *view->bufferable_object().get<GC::Ref<JS::TypedArrayBase>>();
 
         // 1. If options["min"] > view.[[ArrayLength]], return a promise rejected with a RangeError exception.
         if (options.min > typed_array.array_length().length()) {
diff --git a/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h b/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h
index 0cccd7f4795..ca7537e6484 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h
+++ b/Libraries/LibWeb/Streams/ReadableStreamBYOBReader.h
@@ -24,7 +24,7 @@ struct ReadableStreamBYOBReaderReadOptions {
 
 // https://streams.spec.whatwg.org/#read-into-request
 class ReadIntoRequest : public JS::Cell {
-    JS_CELL(ReadIntoRequest, JS::Cell);
+    GC_CELL(ReadIntoRequest, JS::Cell);
 
 public:
     virtual ~ReadIntoRequest() = default;
@@ -44,18 +44,18 @@ class ReadableStreamBYOBReader final
     : public Bindings::PlatformObject
     , public ReadableStreamGenericReaderMixin {
     WEB_PLATFORM_OBJECT(ReadableStreamBYOBReader, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableStreamBYOBReader);
+    GC_DECLARE_ALLOCATOR(ReadableStreamBYOBReader);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamBYOBReader>> construct_impl(JS::Realm&, JS::NonnullGCPtr<ReadableStream>);
+    static WebIDL::ExceptionOr<GC::Ref<ReadableStreamBYOBReader>> construct_impl(JS::Realm&, GC::Ref<ReadableStream>);
 
     virtual ~ReadableStreamBYOBReader() override = default;
 
-    JS::NonnullGCPtr<WebIDL::Promise> read(JS::Handle<WebIDL::ArrayBufferView>&, ReadableStreamBYOBReaderReadOptions options = {});
+    GC::Ref<WebIDL::Promise> read(GC::Root<WebIDL::ArrayBufferView>&, ReadableStreamBYOBReaderReadOptions options = {});
 
     void release_lock();
 
-    Vector<JS::NonnullGCPtr<ReadIntoRequest>>& read_into_requests() { return m_read_into_requests; }
+    Vector<GC::Ref<ReadIntoRequest>>& read_into_requests() { return m_read_into_requests; }
 
 private:
     explicit ReadableStreamBYOBReader(JS::Realm&);
@@ -66,7 +66,7 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreambyobreader-readintorequests
     // A list of read-into requests, used when a consumer requests chunks sooner than they are available
-    Vector<JS::NonnullGCPtr<ReadIntoRequest>> m_read_into_requests;
+    Vector<GC::Ref<ReadIntoRequest>> m_read_into_requests;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.cpp b/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.cpp
index d5e58db693c..e88ee5032d0 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.cpp
@@ -14,10 +14,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableStreamBYOBRequest);
+GC_DEFINE_ALLOCATOR(ReadableStreamBYOBRequest);
 
 // https://streams.spec.whatwg.org/#rs-byob-request-view
-JS::GCPtr<WebIDL::ArrayBufferView> ReadableStreamBYOBRequest::view()
+GC::Ptr<WebIDL::ArrayBufferView> ReadableStreamBYOBRequest::view()
 {
     // 1. Return this.[[view]].
     return m_view;
@@ -63,7 +63,7 @@ WebIDL::ExceptionOr<void> ReadableStreamBYOBRequest::respond(WebIDL::UnsignedLon
 }
 
 // https://streams.spec.whatwg.org/#rs-byob-request-respond-with-new-view
-WebIDL::ExceptionOr<void> ReadableStreamBYOBRequest::respond_with_new_view(JS::Handle<WebIDL::ArrayBufferView> const& view)
+WebIDL::ExceptionOr<void> ReadableStreamBYOBRequest::respond_with_new_view(GC::Root<WebIDL::ArrayBufferView> const& view)
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.h b/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.h
index e097e5521f5..d29a042337e 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.h
+++ b/Libraries/LibWeb/Streams/ReadableStreamBYOBRequest.h
@@ -17,19 +17,19 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#readablestreambyobrequest
 class ReadableStreamBYOBRequest : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ReadableStreamBYOBRequest, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableStreamBYOBRequest);
+    GC_DECLARE_ALLOCATOR(ReadableStreamBYOBRequest);
 
 public:
     virtual ~ReadableStreamBYOBRequest() override = default;
 
-    JS::GCPtr<WebIDL::ArrayBufferView> view();
+    GC::Ptr<WebIDL::ArrayBufferView> view();
 
-    void set_controller(JS::GCPtr<ReadableByteStreamController> value) { m_controller = value; }
+    void set_controller(GC::Ptr<ReadableByteStreamController> value) { m_controller = value; }
 
-    void set_view(JS::GCPtr<WebIDL::ArrayBufferView> value) { m_view = value; }
+    void set_view(GC::Ptr<WebIDL::ArrayBufferView> value) { m_view = value; }
 
     WebIDL::ExceptionOr<void> respond(WebIDL::UnsignedLongLong bytes_written);
-    WebIDL::ExceptionOr<void> respond_with_new_view(JS::Handle<WebIDL::ArrayBufferView> const& view);
+    WebIDL::ExceptionOr<void> respond_with_new_view(GC::Root<WebIDL::ArrayBufferView> const& view);
 
 private:
     explicit ReadableStreamBYOBRequest(JS::Realm&);
@@ -40,11 +40,11 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreambyobrequest-controller
     // The parent ReadableByteStreamController instance
-    JS::GCPtr<ReadableByteStreamController> m_controller;
+    GC::Ptr<ReadableByteStreamController> m_controller;
 
     // https://streams.spec.whatwg.org/#readablestreambyobrequest-view
     // A typed array representing the destination region to which the controller can write generated data, or null after the BYOB request has been invalidated.
-    JS::GCPtr<WebIDL::ArrayBufferView> m_view;
+    GC::Ptr<WebIDL::ArrayBufferView> m_view;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStreamDefaultController.cpp b/Libraries/LibWeb/Streams/ReadableStreamDefaultController.cpp
index 89f24efdf5a..049ec228076 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamDefaultController.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStreamDefaultController.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableStreamDefaultController);
+GC_DEFINE_ALLOCATOR(ReadableStreamDefaultController);
 
 ReadableStreamDefaultController::ReadableStreamDefaultController(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -64,7 +64,7 @@ void ReadableStreamDefaultController::error(JS::Value error)
 }
 
 // https://streams.spec.whatwg.org/#rs-default-controller-private-cancel
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamDefaultController::cancel_steps(JS::Value reason)
+GC::Ref<WebIDL::Promise> ReadableStreamDefaultController::cancel_steps(JS::Value reason)
 {
     // 1. Perform ! ResetQueue(this).
     reset_queue(*this);
diff --git a/Libraries/LibWeb/Streams/ReadableStreamDefaultController.h b/Libraries/LibWeb/Streams/ReadableStreamDefaultController.h
index 0140fd2a09d..9483ef4f024 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamDefaultController.h
+++ b/Libraries/LibWeb/Streams/ReadableStreamDefaultController.h
@@ -20,7 +20,7 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller
 class ReadableStreamDefaultController : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(ReadableStreamDefaultController, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableStreamDefaultController);
+    GC_DECLARE_ALLOCATOR(ReadableStreamDefaultController);
 
 public:
     explicit ReadableStreamDefaultController(JS::Realm&);
@@ -32,8 +32,8 @@ public:
     WebIDL::ExceptionOr<void> enqueue(JS::Value chunk);
     void error(JS::Value error);
 
-    JS::GCPtr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
-    void set_cancel_algorithm(JS::GCPtr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
+    GC::Ptr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
+    void set_cancel_algorithm(GC::Ptr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
 
     bool close_requested() const { return m_close_requested; }
     void set_close_requested(bool value) { m_close_requested = value; }
@@ -41,8 +41,8 @@ public:
     bool pull_again() const { return m_pull_again; }
     void set_pull_again(bool value) { m_pull_again = value; }
 
-    JS::GCPtr<PullAlgorithm> pull_algorithm() { return m_pull_algorithm; }
-    void set_pull_algorithm(JS::GCPtr<PullAlgorithm> value) { m_pull_algorithm = value; }
+    GC::Ptr<PullAlgorithm> pull_algorithm() { return m_pull_algorithm; }
+    void set_pull_algorithm(GC::Ptr<PullAlgorithm> value) { m_pull_algorithm = value; }
 
     bool pulling() const { return m_pulling; }
     void set_pulling(bool value) { m_pulling = value; }
@@ -58,13 +58,13 @@ public:
     double strategy_hwm() const { return m_strategy_hwm; }
     void set_strategy_hwm(double value) { m_strategy_hwm = value; }
 
-    JS::GCPtr<SizeAlgorithm> strategy_size_algorithm() { return m_strategy_size_algorithm; }
-    void set_strategy_size_algorithm(JS::GCPtr<SizeAlgorithm> value) { m_strategy_size_algorithm = value; }
+    GC::Ptr<SizeAlgorithm> strategy_size_algorithm() { return m_strategy_size_algorithm; }
+    void set_strategy_size_algorithm(GC::Ptr<SizeAlgorithm> value) { m_strategy_size_algorithm = value; }
 
-    JS::GCPtr<ReadableStream> stream() { return m_stream; }
-    void set_stream(JS::GCPtr<ReadableStream> value) { m_stream = value; }
+    GC::Ptr<ReadableStream> stream() { return m_stream; }
+    void set_stream(GC::Ptr<ReadableStream> value) { m_stream = value; }
 
-    JS::NonnullGCPtr<WebIDL::Promise> cancel_steps(JS::Value reason);
+    GC::Ref<WebIDL::Promise> cancel_steps(JS::Value reason);
     void pull_steps(ReadRequest&);
     void release_steps();
 
@@ -75,7 +75,7 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-cancelalgorithm
     // A promise-returning algorithm, taking one argument (the cancel reason), which communicates a requested cancelation to the underlying source
-    JS::GCPtr<CancelAlgorithm> m_cancel_algorithm;
+    GC::Ptr<CancelAlgorithm> m_cancel_algorithm;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-closerequested
     // A boolean flag indicating whether the stream has been closed by its underlying source, but still has chunks in its internal queue that have not yet been read
@@ -87,7 +87,7 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-pullalgorithm
     // A promise-returning algorithm that pulls data from the underlying source
-    JS::GCPtr<PullAlgorithm> m_pull_algorithm;
+    GC::Ptr<PullAlgorithm> m_pull_algorithm;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-pulling
     // A boolean flag set to true while the underlying source's pull algorithm is executing and the returned promise has not yet fulfilled, used to prevent reentrant calls
@@ -111,11 +111,11 @@ private:
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-strategysizealgorithm
     // An algorithm to calculate the size of enqueued chunks, as part of the stream’s queuing strategy
-    JS::GCPtr<SizeAlgorithm> m_strategy_size_algorithm;
+    GC::Ptr<SizeAlgorithm> m_strategy_size_algorithm;
 
     // https://streams.spec.whatwg.org/#readablestreamdefaultcontroller-stream
     // The ReadableStream instance controlled
-    JS::GCPtr<ReadableStream> m_stream;
+    GC::Ptr<ReadableStream> m_stream;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp b/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp
index ca08f8025d1..551449c6db3 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.cpp
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/ArrayBuffer.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibJS/Runtime/Iterator.h>
@@ -24,8 +24,8 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(ReadableStreamDefaultReader);
-JS_DEFINE_ALLOCATOR(ReadLoopReadRequest);
+GC_DEFINE_ALLOCATOR(ReadableStreamDefaultReader);
+GC_DEFINE_ALLOCATOR(ReadLoopReadRequest);
 
 void ReadLoopReadRequest::visit_edges(Visitor& visitor)
 {
@@ -38,7 +38,7 @@ void ReadLoopReadRequest::visit_edges(Visitor& visitor)
 }
 
 // https://streams.spec.whatwg.org/#default-reader-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamDefaultReader>> ReadableStreamDefaultReader::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<ReadableStream> stream)
+WebIDL::ExceptionOr<GC::Ref<ReadableStreamDefaultReader>> ReadableStreamDefaultReader::construct_impl(JS::Realm& realm, GC::Ref<ReadableStream> stream)
 {
     auto reader = realm.create<ReadableStreamDefaultReader>(realm);
 
@@ -69,7 +69,7 @@ void ReadableStreamDefaultReader::visit_edges(Cell::Visitor& visitor)
 }
 
 // https://streams.spec.whatwg.org/#read-loop
-ReadLoopReadRequest::ReadLoopReadRequest(JS::VM& vm, JS::Realm& realm, ReadableStreamDefaultReader& reader, JS::NonnullGCPtr<SuccessSteps> success_steps, JS::NonnullGCPtr<FailureSteps> failure_steps, JS::GCPtr<ChunkSteps> chunk_steps)
+ReadLoopReadRequest::ReadLoopReadRequest(JS::VM& vm, JS::Realm& realm, ReadableStreamDefaultReader& reader, GC::Ref<SuccessSteps> success_steps, GC::Ref<FailureSteps> failure_steps, GC::Ptr<ChunkSteps> chunk_steps)
     : m_vm(vm)
     , m_realm(realm)
     , m_reader(reader)
@@ -122,8 +122,8 @@ void ReadLoopReadRequest::on_error(JS::Value error)
 }
 
 class DefaultReaderReadRequest final : public ReadRequest {
-    JS_CELL(DefaultReaderReadRequest, ReadRequest);
-    JS_DECLARE_ALLOCATOR(DefaultReaderReadRequest);
+    GC_CELL(DefaultReaderReadRequest, ReadRequest);
+    GC_DECLARE_ALLOCATOR(DefaultReaderReadRequest);
 
 public:
     DefaultReaderReadRequest(JS::Realm& realm, WebIDL::Promise& promise)
@@ -155,14 +155,14 @@ private:
         visitor.visit(m_promise);
     }
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<WebIDL::Promise> m_promise;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<WebIDL::Promise> m_promise;
 };
 
-JS_DEFINE_ALLOCATOR(DefaultReaderReadRequest);
+GC_DEFINE_ALLOCATOR(DefaultReaderReadRequest);
 
 // https://streams.spec.whatwg.org/#default-reader-read
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamDefaultReader::read()
+GC::Ref<WebIDL::Promise> ReadableStreamDefaultReader::read()
 {
     auto& realm = this->realm();
 
@@ -199,7 +199,7 @@ void ReadableStreamDefaultReader::read_a_chunk(Fetch::Infrastructure::Incrementa
 }
 
 // https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
-void ReadableStreamDefaultReader::read_all_bytes(JS::NonnullGCPtr<ReadLoopReadRequest::SuccessSteps> success_steps, JS::NonnullGCPtr<ReadLoopReadRequest::FailureSteps> failure_steps)
+void ReadableStreamDefaultReader::read_all_bytes(GC::Ref<ReadLoopReadRequest::SuccessSteps> success_steps, GC::Ref<ReadLoopReadRequest::FailureSteps> failure_steps)
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
@@ -212,7 +212,7 @@ void ReadableStreamDefaultReader::read_all_bytes(JS::NonnullGCPtr<ReadLoopReadRe
     readable_stream_default_reader_read(*this, read_request);
 }
 
-void ReadableStreamDefaultReader::read_all_chunks(JS::NonnullGCPtr<ReadLoopReadRequest::ChunkSteps> chunk_steps, JS::NonnullGCPtr<ReadLoopReadRequest::SuccessSteps> success_steps, JS::NonnullGCPtr<ReadLoopReadRequest::FailureSteps> failure_steps)
+void ReadableStreamDefaultReader::read_all_chunks(GC::Ref<ReadLoopReadRequest::ChunkSteps> chunk_steps, GC::Ref<ReadLoopReadRequest::SuccessSteps> success_steps, GC::Ref<ReadLoopReadRequest::FailureSteps> failure_steps)
 {
     // AD-HOC: Some spec steps direct us to "read all chunks" from a stream, but there isn't an AO defined to do that.
     //         We implement those steps by using the "read all bytes" definition, with a custom callback to receive
@@ -231,18 +231,18 @@ void ReadableStreamDefaultReader::read_all_chunks(JS::NonnullGCPtr<ReadLoopReadR
 // FIXME: This function is a promise-based wrapper around "read all bytes". The spec changed this function to not use promises
 //        in https://github.com/whatwg/streams/commit/f894acdd417926a2121710803cef593e15127964 - however, it seems that the
 //        FileAPI blob specification has not been updated to match, see: https://github.com/w3c/FileAPI/issues/187.
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamDefaultReader::read_all_bytes_deprecated()
+GC::Ref<WebIDL::Promise> ReadableStreamDefaultReader::read_all_bytes_deprecated()
 {
     auto& realm = this->realm();
 
     auto promise = WebIDL::create_promise(realm);
 
-    auto success_steps = JS::create_heap_function(realm.heap(), [promise, &realm](ByteBuffer bytes) {
+    auto success_steps = GC::create_function(realm.heap(), [promise, &realm](ByteBuffer bytes) {
         auto buffer = JS::ArrayBuffer::create(realm, move(bytes));
         WebIDL::resolve_promise(realm, promise, buffer);
     });
 
-    auto failure_steps = JS::create_heap_function(realm.heap(), [promise, &realm](JS::Value error) {
+    auto failure_steps = GC::create_function(realm.heap(), [promise, &realm](JS::Value error) {
         WebIDL::reject_promise(realm, promise, error);
     });
 
diff --git a/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h b/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h
index ad2cdd75483..9639b7433c1 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h
+++ b/Libraries/LibWeb/Streams/ReadableStreamDefaultReader.h
@@ -21,7 +21,7 @@ struct ReadableStreamReadResult {
 };
 
 class ReadRequest : public JS::Cell {
-    JS_CELL(ReadRequest, JS::Cell);
+    GC_CELL(ReadRequest, JS::Cell);
 
 public:
     virtual ~ReadRequest() = default;
@@ -32,20 +32,20 @@ public:
 };
 
 class ReadLoopReadRequest final : public ReadRequest {
-    JS_CELL(ReadLoopReadRequest, ReadRequest);
-    JS_DECLARE_ALLOCATOR(ReadLoopReadRequest);
+    GC_CELL(ReadLoopReadRequest, ReadRequest);
+    GC_DECLARE_ALLOCATOR(ReadLoopReadRequest);
 
 public:
     // successSteps, which is an algorithm accepting a byte sequence
-    using SuccessSteps = JS::HeapFunction<void(ByteBuffer)>;
+    using SuccessSteps = GC::Function<void(ByteBuffer)>;
 
     // failureSteps, which is an algorithm accepting a JavaScript value
-    using FailureSteps = JS::HeapFunction<void(JS::Value error)>;
+    using FailureSteps = GC::Function<void(JS::Value error)>;
 
     // AD-HOC: callback triggered on every chunk received from the stream.
-    using ChunkSteps = JS::HeapFunction<void(ByteBuffer)>;
+    using ChunkSteps = GC::Function<void(ByteBuffer)>;
 
-    ReadLoopReadRequest(JS::VM& vm, JS::Realm& realm, ReadableStreamDefaultReader& reader, JS::NonnullGCPtr<SuccessSteps> success_steps, JS::NonnullGCPtr<FailureSteps> failure_steps, JS::GCPtr<ChunkSteps> chunk_steps = {});
+    ReadLoopReadRequest(JS::VM& vm, JS::Realm& realm, ReadableStreamDefaultReader& reader, GC::Ref<SuccessSteps> success_steps, GC::Ref<FailureSteps> failure_steps, GC::Ptr<ChunkSteps> chunk_steps = {});
 
     virtual void on_chunk(JS::Value chunk) override;
 
@@ -57,12 +57,12 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     JS::VM& m_vm;
-    JS::NonnullGCPtr<JS::Realm> m_realm;
-    JS::NonnullGCPtr<ReadableStreamDefaultReader> m_reader;
+    GC::Ref<JS::Realm> m_realm;
+    GC::Ref<ReadableStreamDefaultReader> m_reader;
     ByteBuffer m_bytes;
-    JS::NonnullGCPtr<SuccessSteps> m_success_steps;
-    JS::NonnullGCPtr<FailureSteps> m_failure_steps;
-    JS::GCPtr<ChunkSteps> m_chunk_steps;
+    GC::Ref<SuccessSteps> m_success_steps;
+    GC::Ref<FailureSteps> m_failure_steps;
+    GC::Ptr<ChunkSteps> m_chunk_steps;
 };
 
 // https://streams.spec.whatwg.org/#readablestreamdefaultreader
@@ -70,23 +70,23 @@ class ReadableStreamDefaultReader final
     : public Bindings::PlatformObject
     , public ReadableStreamGenericReaderMixin {
     WEB_PLATFORM_OBJECT(ReadableStreamDefaultReader, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(ReadableStreamDefaultReader);
+    GC_DECLARE_ALLOCATOR(ReadableStreamDefaultReader);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ReadableStreamDefaultReader>> construct_impl(JS::Realm&, JS::NonnullGCPtr<ReadableStream>);
+    static WebIDL::ExceptionOr<GC::Ref<ReadableStreamDefaultReader>> construct_impl(JS::Realm&, GC::Ref<ReadableStream>);
 
     virtual ~ReadableStreamDefaultReader() override = default;
 
-    JS::NonnullGCPtr<WebIDL::Promise> read();
+    GC::Ref<WebIDL::Promise> read();
 
     void read_a_chunk(Fetch::Infrastructure::IncrementalReadLoopReadRequest& read_request);
-    void read_all_bytes(JS::NonnullGCPtr<ReadLoopReadRequest::SuccessSteps>, JS::NonnullGCPtr<ReadLoopReadRequest::FailureSteps>);
-    void read_all_chunks(JS::NonnullGCPtr<ReadLoopReadRequest::ChunkSteps>, JS::NonnullGCPtr<ReadLoopReadRequest::SuccessSteps>, JS::NonnullGCPtr<ReadLoopReadRequest::FailureSteps>);
-    JS::NonnullGCPtr<WebIDL::Promise> read_all_bytes_deprecated();
+    void read_all_bytes(GC::Ref<ReadLoopReadRequest::SuccessSteps>, GC::Ref<ReadLoopReadRequest::FailureSteps>);
+    void read_all_chunks(GC::Ref<ReadLoopReadRequest::ChunkSteps>, GC::Ref<ReadLoopReadRequest::SuccessSteps>, GC::Ref<ReadLoopReadRequest::FailureSteps>);
+    GC::Ref<WebIDL::Promise> read_all_bytes_deprecated();
 
     void release_lock();
 
-    SinglyLinkedList<JS::NonnullGCPtr<ReadRequest>>& read_requests() { return m_read_requests; }
+    SinglyLinkedList<GC::Ref<ReadRequest>>& read_requests() { return m_read_requests; }
 
 private:
     explicit ReadableStreamDefaultReader(JS::Realm&);
@@ -95,7 +95,7 @@ private:
 
     virtual void visit_edges(Cell::Visitor&) override;
 
-    SinglyLinkedList<JS::NonnullGCPtr<ReadRequest>> m_read_requests;
+    SinglyLinkedList<GC::Ref<ReadRequest>> m_read_requests;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp b/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp
index 423293aac45..d54e63ba242 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp
+++ b/Libraries/LibWeb/Streams/ReadableStreamGenericReader.cpp
@@ -14,14 +14,14 @@
 namespace Web::Streams {
 
 // https://streams.spec.whatwg.org/#generic-reader-closed
-JS::GCPtr<WebIDL::Promise> ReadableStreamGenericReaderMixin::closed()
+GC::Ptr<WebIDL::Promise> ReadableStreamGenericReaderMixin::closed()
 {
     // 1. Return this.[[closedPromise]].
     return m_closed_promise;
 }
 
 // https://streams.spec.whatwg.org/#generic-reader-cancel
-JS::NonnullGCPtr<WebIDL::Promise> ReadableStreamGenericReaderMixin::cancel(JS::Value reason)
+GC::Ref<WebIDL::Promise> ReadableStreamGenericReaderMixin::cancel(JS::Value reason)
 {
     // 1. If this.[[stream]] is undefined, return a promise rejected with a TypeError exception.
     if (!m_stream) {
diff --git a/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h b/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h
index e59732ebb99..ffd2d6a303d 100644
--- a/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h
+++ b/Libraries/LibWeb/Streams/ReadableStreamGenericReader.h
@@ -19,15 +19,15 @@ class ReadableStreamGenericReaderMixin {
 public:
     virtual ~ReadableStreamGenericReaderMixin() = default;
 
-    JS::GCPtr<WebIDL::Promise> closed();
+    GC::Ptr<WebIDL::Promise> closed();
 
-    JS::NonnullGCPtr<WebIDL::Promise> cancel(JS::Value reason);
+    GC::Ref<WebIDL::Promise> cancel(JS::Value reason);
 
-    JS::GCPtr<ReadableStream> stream() const { return m_stream; }
-    void set_stream(JS::GCPtr<ReadableStream> stream) { m_stream = stream; }
+    GC::Ptr<ReadableStream> stream() const { return m_stream; }
+    void set_stream(GC::Ptr<ReadableStream> stream) { m_stream = stream; }
 
-    JS::GCPtr<WebIDL::Promise> closed_promise_capability() { return m_closed_promise; }
-    void set_closed_promise_capability(JS::GCPtr<WebIDL::Promise> promise) { m_closed_promise = promise; }
+    GC::Ptr<WebIDL::Promise> closed_promise_capability() { return m_closed_promise; }
+    void set_closed_promise_capability(GC::Ptr<WebIDL::Promise> promise) { m_closed_promise = promise; }
 
 protected:
     explicit ReadableStreamGenericReaderMixin(JS::Realm&);
@@ -36,13 +36,13 @@ protected:
 
     // https://streams.spec.whatwg.org/#readablestreamgenericreader-closedpromise
     // A promise returned by the reader's closed getter
-    JS::GCPtr<WebIDL::Promise> m_closed_promise;
+    GC::Ptr<WebIDL::Promise> m_closed_promise;
 
     // https://streams.spec.whatwg.org/#readablestreamgenericreader-stream
     // A ReadableStream instance that owns this reader
-    JS::GCPtr<ReadableStream> m_stream;
+    GC::Ptr<ReadableStream> m_stream;
 
-    JS::NonnullGCPtr<JS::Realm> m_realm;
+    GC::Ref<JS::Realm> m_realm;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/TransformStream.cpp b/Libraries/LibWeb/Streams/TransformStream.cpp
index dee27c37287..2387e6bc3f2 100644
--- a/Libraries/LibWeb/Streams/TransformStream.cpp
+++ b/Libraries/LibWeb/Streams/TransformStream.cpp
@@ -16,10 +16,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(TransformStream);
+GC_DEFINE_ALLOCATOR(TransformStream);
 
 // https://streams.spec.whatwg.org/#ts-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<TransformStream>> TransformStream::construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> transformer_object, QueuingStrategy const& writable_strategy, QueuingStrategy const& readable_strategy)
+WebIDL::ExceptionOr<GC::Ref<TransformStream>> TransformStream::construct_impl(JS::Realm& realm, Optional<GC::Root<JS::Object>> transformer_object, QueuingStrategy const& writable_strategy, QueuingStrategy const& readable_strategy)
 {
     auto& vm = realm.vm();
 
diff --git a/Libraries/LibWeb/Streams/TransformStream.h b/Libraries/LibWeb/Streams/TransformStream.h
index e41f15bded1..a1ba305222f 100644
--- a/Libraries/LibWeb/Streams/TransformStream.h
+++ b/Libraries/LibWeb/Streams/TransformStream.h
@@ -16,29 +16,29 @@ namespace Web::Streams {
 
 class TransformStream final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TransformStream, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TransformStream);
+    GC_DECLARE_ALLOCATOR(TransformStream);
 
 public:
     virtual ~TransformStream() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TransformStream>> construct_impl(JS::Realm&, Optional<JS::Handle<JS::Object>> transformer_object = {}, QueuingStrategy const& writable_strategy = {}, QueuingStrategy const& readable_strategy = {});
+    static WebIDL::ExceptionOr<GC::Ref<TransformStream>> construct_impl(JS::Realm&, Optional<GC::Root<JS::Object>> transformer_object = {}, QueuingStrategy const& writable_strategy = {}, QueuingStrategy const& readable_strategy = {});
 
     // https://streams.spec.whatwg.org/#ts-readable
-    JS::NonnullGCPtr<ReadableStream> readable() { return *m_readable; }
+    GC::Ref<ReadableStream> readable() { return *m_readable; }
     void set_readable(ReadableStream& readable) { m_readable = readable; }
 
     // https://streams.spec.whatwg.org/#ts-writable
-    JS::NonnullGCPtr<WritableStream> writable() { return *m_writable; }
+    GC::Ref<WritableStream> writable() { return *m_writable; }
     void set_writable(WritableStream& writable) { m_writable = writable; }
 
     Optional<bool> backpressure() const { return m_backpressure; }
     void set_backpressure(Optional<bool> value) { m_backpressure = move(value); }
 
-    JS::GCPtr<WebIDL::Promise> backpressure_change_promise() const { return m_backpressure_change_promise; }
-    void set_backpressure_change_promise(JS::GCPtr<WebIDL::Promise> value) { m_backpressure_change_promise = value; }
+    GC::Ptr<WebIDL::Promise> backpressure_change_promise() const { return m_backpressure_change_promise; }
+    void set_backpressure_change_promise(GC::Ptr<WebIDL::Promise> value) { m_backpressure_change_promise = value; }
 
-    JS::GCPtr<TransformStreamDefaultController> controller() const { return m_controller; }
-    void set_controller(JS::GCPtr<TransformStreamDefaultController> value) { m_controller = value; }
+    GC::Ptr<TransformStreamDefaultController> controller() const { return m_controller; }
+    void set_controller(GC::Ptr<TransformStreamDefaultController> value) { m_controller = value; }
 
 private:
     explicit TransformStream(JS::Realm& realm);
@@ -53,11 +53,11 @@ private:
 
     // https://streams.spec.whatwg.org/#transformstream-backpressurechangepromise
     // A promise which is fulfilled and replaced every time the value of [[backpressure]] changes
-    JS::GCPtr<WebIDL::Promise> m_backpressure_change_promise;
+    GC::Ptr<WebIDL::Promise> m_backpressure_change_promise;
 
     // https://streams.spec.whatwg.org/#transformstream-controller
     // A TransformStreamDefaultController created with the ability to control [[readable]] and [[writable]]
-    JS::GCPtr<TransformStreamDefaultController> m_controller;
+    GC::Ptr<TransformStreamDefaultController> m_controller;
 
     // https://streams.spec.whatwg.org/#transformstream-detached
     // A boolean flag set to true when the stream is transferred
@@ -65,11 +65,11 @@ private:
 
     // https://streams.spec.whatwg.org/#transformstream-readable
     // The ReadableStream instance controlled by this object
-    JS::GCPtr<ReadableStream> m_readable;
+    GC::Ptr<ReadableStream> m_readable;
 
     // https://streams.spec.whatwg.org/#transformstream-writable
     // The WritableStream instance controlled by this object
-    JS::GCPtr<WritableStream> m_writable;
+    GC::Ptr<WritableStream> m_writable;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/TransformStreamDefaultController.cpp b/Libraries/LibWeb/Streams/TransformStreamDefaultController.cpp
index 4798fe80d19..b6dee756d7a 100644
--- a/Libraries/LibWeb/Streams/TransformStreamDefaultController.cpp
+++ b/Libraries/LibWeb/Streams/TransformStreamDefaultController.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(TransformStreamDefaultController);
+GC_DEFINE_ALLOCATOR(TransformStreamDefaultController);
 
 TransformStreamDefaultController::TransformStreamDefaultController(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -39,10 +39,10 @@ void TransformStreamDefaultController::visit_edges(Cell::Visitor& visitor)
 // https://streams.spec.whatwg.org/#ts-default-controller-desired-size
 Optional<double> TransformStreamDefaultController::desired_size()
 {
-    VERIFY(stream()->readable()->controller().has_value() && stream()->readable()->controller()->has<JS::NonnullGCPtr<ReadableStreamDefaultController>>());
+    VERIFY(stream()->readable()->controller().has_value() && stream()->readable()->controller()->has<GC::Ref<ReadableStreamDefaultController>>());
 
     // 1. Let readableController be this.[[stream]].[[readable]].[[controller]].
-    auto readable_controller = stream()->readable()->controller()->get<JS::NonnullGCPtr<ReadableStreamDefaultController>>();
+    auto readable_controller = stream()->readable()->controller()->get<GC::Ref<ReadableStreamDefaultController>>();
 
     // 2. Return ! ReadableStreamDefaultControllerGetDesiredSize(readableController).
     return readable_stream_default_controller_get_desired_size(*readable_controller);
diff --git a/Libraries/LibWeb/Streams/TransformStreamDefaultController.h b/Libraries/LibWeb/Streams/TransformStreamDefaultController.h
index 83ba771a64a..ba712a334b1 100644
--- a/Libraries/LibWeb/Streams/TransformStreamDefaultController.h
+++ b/Libraries/LibWeb/Streams/TransformStreamDefaultController.h
@@ -13,7 +13,7 @@ namespace Web::Streams {
 
 class TransformStreamDefaultController : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(TransformStreamDefaultController, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(TransformStreamDefaultController);
+    GC_DECLARE_ALLOCATOR(TransformStreamDefaultController);
 
 public:
     explicit TransformStreamDefaultController(JS::Realm&);
@@ -24,20 +24,20 @@ public:
     void error(Optional<JS::Value> reason = {});
     void terminate();
 
-    JS::GCPtr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
-    void set_cancel_algorithm(JS::GCPtr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
+    GC::Ptr<CancelAlgorithm> cancel_algorithm() { return m_cancel_algorithm; }
+    void set_cancel_algorithm(GC::Ptr<CancelAlgorithm> value) { m_cancel_algorithm = value; }
 
-    JS::GCPtr<JS::PromiseCapability> finish_promise() { return m_finish_promise; }
-    void set_finish_promise(JS::GCPtr<JS::PromiseCapability> value) { m_finish_promise = value; }
+    GC::Ptr<JS::PromiseCapability> finish_promise() { return m_finish_promise; }
+    void set_finish_promise(GC::Ptr<JS::PromiseCapability> value) { m_finish_promise = value; }
 
-    JS::GCPtr<FlushAlgorithm> flush_algorithm() { return m_flush_algorithm; }
-    void set_flush_algorithm(JS::GCPtr<FlushAlgorithm>&& value) { m_flush_algorithm = move(value); }
+    GC::Ptr<FlushAlgorithm> flush_algorithm() { return m_flush_algorithm; }
+    void set_flush_algorithm(GC::Ptr<FlushAlgorithm>&& value) { m_flush_algorithm = move(value); }
 
-    JS::GCPtr<TransformAlgorithm> transform_algorithm() { return m_transform_algorithm; }
-    void set_transform_algorithm(JS::GCPtr<TransformAlgorithm>&& value) { m_transform_algorithm = move(value); }
+    GC::Ptr<TransformAlgorithm> transform_algorithm() { return m_transform_algorithm; }
+    void set_transform_algorithm(GC::Ptr<TransformAlgorithm>&& value) { m_transform_algorithm = move(value); }
 
-    JS::GCPtr<TransformStream> stream() { return m_stream; }
-    void set_stream(JS::GCPtr<TransformStream> stream) { m_stream = stream; }
+    GC::Ptr<TransformStream> stream() { return m_stream; }
+    void set_stream(GC::Ptr<TransformStream> stream) { m_stream = stream; }
 
 private:
     virtual void initialize(JS::Realm&) override;
@@ -45,19 +45,19 @@ private:
     virtual void visit_edges(Cell::Visitor&) override;
 
     // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller-cancelalgorithm
-    JS::GCPtr<CancelAlgorithm> m_cancel_algorithm;
+    GC::Ptr<CancelAlgorithm> m_cancel_algorithm;
 
     // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller-finishpromise
-    JS::GCPtr<JS::PromiseCapability> m_finish_promise;
+    GC::Ptr<JS::PromiseCapability> m_finish_promise;
 
     // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller-flushalgorithm
-    JS::GCPtr<FlushAlgorithm> m_flush_algorithm;
+    GC::Ptr<FlushAlgorithm> m_flush_algorithm;
 
     // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller-transformalgorithm
-    JS::GCPtr<TransformAlgorithm> m_transform_algorithm;
+    GC::Ptr<TransformAlgorithm> m_transform_algorithm;
 
     // https://streams.spec.whatwg.org/#transformstreamdefaultcontroller-stream
-    JS::GCPtr<TransformStream> m_stream;
+    GC::Ptr<TransformStream> m_stream;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/Transformer.h b/Libraries/LibWeb/Streams/Transformer.h
index df33bd327e6..565abb9631a 100644
--- a/Libraries/LibWeb/Streams/Transformer.h
+++ b/Libraries/LibWeb/Streams/Transformer.h
@@ -6,8 +6,8 @@
 
 #pragma once
 
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::Streams {
@@ -15,13 +15,13 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#dictdef-transformer
 struct Transformer {
     // https://streams.spec.whatwg.org/#dom-transformer-start
-    JS::Handle<WebIDL::CallbackType> start;
+    GC::Root<WebIDL::CallbackType> start;
     // https://streams.spec.whatwg.org/#dom-transformer-transform
-    JS::Handle<WebIDL::CallbackType> transform;
+    GC::Root<WebIDL::CallbackType> transform;
     // https://streams.spec.whatwg.org/#dom-transformer-flush
-    JS::Handle<WebIDL::CallbackType> flush;
+    GC::Root<WebIDL::CallbackType> flush;
     // https://streams.spec.whatwg.org/#dom-transformer-cancel
-    JS::Handle<WebIDL::CallbackType> cancel;
+    GC::Root<WebIDL::CallbackType> cancel;
 
     // https://streams.spec.whatwg.org/#dom-transformer-readabletype
     Optional<JS::Value> readable_type;
diff --git a/Libraries/LibWeb/Streams/UnderlyingSink.h b/Libraries/LibWeb/Streams/UnderlyingSink.h
index 766ebcd1b67..90e20bddbab 100644
--- a/Libraries/LibWeb/Streams/UnderlyingSink.h
+++ b/Libraries/LibWeb/Streams/UnderlyingSink.h
@@ -14,10 +14,10 @@ namespace Web::Streams {
 
 // https://streams.spec.whatwg.org/#dictdef-underlyingsink
 struct UnderlyingSink {
-    JS::Handle<WebIDL::CallbackType> start;
-    JS::Handle<WebIDL::CallbackType> write;
-    JS::Handle<WebIDL::CallbackType> close;
-    JS::Handle<WebIDL::CallbackType> abort;
+    GC::Root<WebIDL::CallbackType> start;
+    GC::Root<WebIDL::CallbackType> write;
+    GC::Root<WebIDL::CallbackType> close;
+    GC::Root<WebIDL::CallbackType> abort;
     Optional<JS::Value> type;
 
     static JS::ThrowCompletionOr<UnderlyingSink> from_value(JS::VM&, JS::Value);
diff --git a/Libraries/LibWeb/Streams/UnderlyingSource.h b/Libraries/LibWeb/Streams/UnderlyingSource.h
index 2e282867bab..36d7af54974 100644
--- a/Libraries/LibWeb/Streams/UnderlyingSource.h
+++ b/Libraries/LibWeb/Streams/UnderlyingSource.h
@@ -19,9 +19,9 @@ enum class ReadableStreamType {
 };
 
 struct UnderlyingSource {
-    JS::Handle<WebIDL::CallbackType> start;
-    JS::Handle<WebIDL::CallbackType> pull;
-    JS::Handle<WebIDL::CallbackType> cancel;
+    GC::Root<WebIDL::CallbackType> start;
+    GC::Root<WebIDL::CallbackType> pull;
+    GC::Root<WebIDL::CallbackType> cancel;
     Optional<ReadableStreamType> type;
     Optional<u64> auto_allocate_chunk_size;
 
diff --git a/Libraries/LibWeb/Streams/WritableStream.cpp b/Libraries/LibWeb/Streams/WritableStream.cpp
index 8863c079253..b1727ace990 100644
--- a/Libraries/LibWeb/Streams/WritableStream.cpp
+++ b/Libraries/LibWeb/Streams/WritableStream.cpp
@@ -16,10 +16,10 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(WritableStream);
+GC_DEFINE_ALLOCATOR(WritableStream);
 
 // https://streams.spec.whatwg.org/#ws-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStream>> WritableStream::construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> const& underlying_sink_object, QueuingStrategy const& strategy)
+WebIDL::ExceptionOr<GC::Ref<WritableStream>> WritableStream::construct_impl(JS::Realm& realm, Optional<GC::Root<JS::Object>> const& underlying_sink_object, QueuingStrategy const& strategy)
 {
     auto& vm = realm.vm();
 
@@ -58,7 +58,7 @@ bool WritableStream::locked() const
 }
 
 // https://streams.spec.whatwg.org/#ws-close
-JS::GCPtr<WebIDL::Promise> WritableStream::close()
+GC::Ptr<WebIDL::Promise> WritableStream::close()
 {
     auto& realm = this->realm();
 
@@ -79,7 +79,7 @@ JS::GCPtr<WebIDL::Promise> WritableStream::close()
 }
 
 // https://streams.spec.whatwg.org/#ws-abort
-JS::GCPtr<WebIDL::Promise> WritableStream::abort(JS::Value reason)
+GC::Ptr<WebIDL::Promise> WritableStream::abort(JS::Value reason)
 {
     auto& realm = this->realm();
 
@@ -94,7 +94,7 @@ JS::GCPtr<WebIDL::Promise> WritableStream::abort(JS::Value reason)
 }
 
 // https://streams.spec.whatwg.org/#ws-get-writer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> WritableStream::get_writer()
+WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> WritableStream::get_writer()
 {
     // 1. Return ? AcquireWritableStreamDefaultWriter(this).
     return acquire_writable_stream_default_writer(*this);
diff --git a/Libraries/LibWeb/Streams/WritableStream.h b/Libraries/LibWeb/Streams/WritableStream.h
index 43f416f10ad..df5e531d8ee 100644
--- a/Libraries/LibWeb/Streams/WritableStream.h
+++ b/Libraries/LibWeb/Streams/WritableStream.h
@@ -20,7 +20,7 @@ namespace Web::Streams {
 struct PendingAbortRequest {
     // https://streams.spec.whatwg.org/#pending-abort-request-promise
     // A promise returned from WritableStreamAbort
-    JS::NonnullGCPtr<WebIDL::Promise> promise;
+    GC::Ref<WebIDL::Promise> promise;
 
     // https://streams.spec.whatwg.org/#pending-abort-request-reason
     // A JavaScript value that was passed as the abort reason to WritableStreamAbort
@@ -34,7 +34,7 @@ struct PendingAbortRequest {
 // https://streams.spec.whatwg.org/#writablestream
 class WritableStream final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(WritableStream, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WritableStream);
+    GC_DECLARE_ALLOCATOR(WritableStream);
 
 public:
     enum class State {
@@ -44,31 +44,31 @@ public:
         Errored,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStream>> construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> const& underlying_sink, QueuingStrategy const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<WritableStream>> construct_impl(JS::Realm& realm, Optional<GC::Root<JS::Object>> const& underlying_sink, QueuingStrategy const& = {});
 
     virtual ~WritableStream() = default;
 
     bool locked() const;
-    JS::GCPtr<WebIDL::Promise> abort(JS::Value reason);
-    JS::GCPtr<WebIDL::Promise> close();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> get_writer();
+    GC::Ptr<WebIDL::Promise> abort(JS::Value reason);
+    GC::Ptr<WebIDL::Promise> close();
+    WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> get_writer();
 
     bool backpressure() const { return m_backpressure; }
     void set_backpressure(bool value) { m_backpressure = value; }
 
-    JS::GCPtr<WebIDL::Promise const> close_request() const { return m_close_request; }
-    JS::GCPtr<WebIDL::Promise> close_request() { return m_close_request; }
-    void set_close_request(JS::GCPtr<WebIDL::Promise> value) { m_close_request = value; }
+    GC::Ptr<WebIDL::Promise const> close_request() const { return m_close_request; }
+    GC::Ptr<WebIDL::Promise> close_request() { return m_close_request; }
+    void set_close_request(GC::Ptr<WebIDL::Promise> value) { m_close_request = value; }
 
-    JS::GCPtr<WritableStreamDefaultController const> controller() const { return m_controller; }
-    JS::GCPtr<WritableStreamDefaultController> controller() { return m_controller; }
-    void set_controller(JS::GCPtr<WritableStreamDefaultController> value) { m_controller = value; }
+    GC::Ptr<WritableStreamDefaultController const> controller() const { return m_controller; }
+    GC::Ptr<WritableStreamDefaultController> controller() { return m_controller; }
+    void set_controller(GC::Ptr<WritableStreamDefaultController> value) { m_controller = value; }
 
-    JS::GCPtr<WebIDL::Promise const> in_flight_write_request() const { return m_in_flight_write_request; }
-    void set_in_flight_write_request(JS::GCPtr<WebIDL::Promise> value) { m_in_flight_write_request = value; }
+    GC::Ptr<WebIDL::Promise const> in_flight_write_request() const { return m_in_flight_write_request; }
+    void set_in_flight_write_request(GC::Ptr<WebIDL::Promise> value) { m_in_flight_write_request = value; }
 
-    JS::GCPtr<WebIDL::Promise const> in_flight_close_request() const { return m_in_flight_close_request; }
-    void set_in_flight_close_request(JS::GCPtr<WebIDL::Promise> value) { m_in_flight_close_request = value; }
+    GC::Ptr<WebIDL::Promise const> in_flight_close_request() const { return m_in_flight_close_request; }
+    void set_in_flight_close_request(GC::Ptr<WebIDL::Promise> value) { m_in_flight_close_request = value; }
 
     Optional<PendingAbortRequest>& pending_abort_request() { return m_pending_abort_request; }
     void set_pending_abort_request(Optional<PendingAbortRequest>&& value) { m_pending_abort_request = move(value); }
@@ -79,11 +79,11 @@ public:
     JS::Value stored_error() const { return m_stored_error; }
     void set_stored_error(JS::Value value) { m_stored_error = value; }
 
-    JS::GCPtr<WritableStreamDefaultWriter const> writer() const { return m_writer; }
-    JS::GCPtr<WritableStreamDefaultWriter> writer() { return m_writer; }
-    void set_writer(JS::GCPtr<WritableStreamDefaultWriter> value) { m_writer = value; }
+    GC::Ptr<WritableStreamDefaultWriter const> writer() const { return m_writer; }
+    GC::Ptr<WritableStreamDefaultWriter> writer() { return m_writer; }
+    void set_writer(GC::Ptr<WritableStreamDefaultWriter> value) { m_writer = value; }
 
-    SinglyLinkedList<JS::NonnullGCPtr<WebIDL::Promise>>& write_requests() { return m_write_requests; }
+    SinglyLinkedList<GC::Ref<WebIDL::Promise>>& write_requests() { return m_write_requests; }
 
 private:
     explicit WritableStream(JS::Realm&);
@@ -98,11 +98,11 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestream-closerequest
     // The promise returned from the writer’s close() method
-    JS::GCPtr<WebIDL::Promise> m_close_request;
+    GC::Ptr<WebIDL::Promise> m_close_request;
 
     // https://streams.spec.whatwg.org/#writablestream-controller
     // A WritableStreamDefaultController created with the ability to control the state and queue of this stream
-    JS::GCPtr<WritableStreamDefaultController> m_controller;
+    GC::Ptr<WritableStreamDefaultController> m_controller;
 
     // https://streams.spec.whatwg.org/#writablestream-detached
     // A boolean flag set to true when the stream is transferred
@@ -110,11 +110,11 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestream-inflightwriterequest
     // A slot set to the promise for the current in-flight write operation while the underlying sink's write algorithm is executing and has not yet fulfilled, used to prevent reentrant calls
-    JS::GCPtr<WebIDL::Promise> m_in_flight_write_request;
+    GC::Ptr<WebIDL::Promise> m_in_flight_write_request;
 
     // https://streams.spec.whatwg.org/#writablestream-inflightcloserequest
     // A slot set to the promise for the current in-flight close operation while the underlying sink's close algorithm is executing and has not yet fulfilled, used to prevent the abort() method from interrupting close
-    JS::GCPtr<WebIDL::Promise> m_in_flight_close_request;
+    GC::Ptr<WebIDL::Promise> m_in_flight_close_request;
 
     // https://streams.spec.whatwg.org/#writablestream-pendingabortrequest
     // A pending abort request
@@ -130,11 +130,11 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestream-writer
     // A WritableStreamDefaultWriter instance, if the stream is locked to a writer, or undefined if it is not
-    JS::GCPtr<WritableStreamDefaultWriter> m_writer;
+    GC::Ptr<WritableStreamDefaultWriter> m_writer;
 
     // https://streams.spec.whatwg.org/#writablestream-writerequests
     // A list of promises representing the stream’s internal queue of write requests not yet processed by the underlying sink
-    SinglyLinkedList<JS::NonnullGCPtr<WebIDL::Promise>> m_write_requests;
+    SinglyLinkedList<GC::Ref<WebIDL::Promise>> m_write_requests;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/WritableStreamDefaultController.cpp b/Libraries/LibWeb/Streams/WritableStreamDefaultController.cpp
index 535cbc75fca..75d791fafd1 100644
--- a/Libraries/LibWeb/Streams/WritableStreamDefaultController.cpp
+++ b/Libraries/LibWeb/Streams/WritableStreamDefaultController.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(WritableStreamDefaultController);
+GC_DEFINE_ALLOCATOR(WritableStreamDefaultController);
 
 void WritableStreamDefaultController::visit_edges(Visitor& visitor)
 {
@@ -41,7 +41,7 @@ void WritableStreamDefaultController::error(JS::Value error)
 }
 
 // https://streams.spec.whatwg.org/#ws-default-controller-private-abort
-JS::NonnullGCPtr<WebIDL::Promise> WritableStreamDefaultController::abort_steps(JS::Value reason)
+GC::Ref<WebIDL::Promise> WritableStreamDefaultController::abort_steps(JS::Value reason)
 {
     // 1. Let result be the result of performing this.[[abortAlgorithm]], passing reason.
     auto result = m_abort_algorithm->function()(reason);
diff --git a/Libraries/LibWeb/Streams/WritableStreamDefaultController.h b/Libraries/LibWeb/Streams/WritableStreamDefaultController.h
index 9baa2a2c1cf..1a80253d65b 100644
--- a/Libraries/LibWeb/Streams/WritableStreamDefaultController.h
+++ b/Libraries/LibWeb/Streams/WritableStreamDefaultController.h
@@ -15,20 +15,20 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller
 class WritableStreamDefaultController final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(WritableStreamDefaultController, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WritableStreamDefaultController);
+    GC_DECLARE_ALLOCATOR(WritableStreamDefaultController);
 
 public:
     virtual ~WritableStreamDefaultController() override = default;
 
     void error(JS::Value error);
-    JS::NonnullGCPtr<DOM::AbortSignal> signal() { return *m_signal; }
-    void set_signal(JS::NonnullGCPtr<DOM::AbortSignal> value) { m_signal = value; }
+    GC::Ref<DOM::AbortSignal> signal() { return *m_signal; }
+    void set_signal(GC::Ref<DOM::AbortSignal> value) { m_signal = value; }
 
-    JS::GCPtr<AbortAlgorithm> abort_algorithm() { return m_abort_algorithm; }
-    void set_abort_algorithm(JS::GCPtr<AbortAlgorithm> value) { m_abort_algorithm = value; }
+    GC::Ptr<AbortAlgorithm> abort_algorithm() { return m_abort_algorithm; }
+    void set_abort_algorithm(GC::Ptr<AbortAlgorithm> value) { m_abort_algorithm = value; }
 
-    JS::GCPtr<CloseAlgorithm> close_algorithm() { return m_close_algorithm; }
-    void set_close_algorithm(JS::GCPtr<CloseAlgorithm> value) { m_close_algorithm = value; }
+    GC::Ptr<CloseAlgorithm> close_algorithm() { return m_close_algorithm; }
+    void set_close_algorithm(GC::Ptr<CloseAlgorithm> value) { m_close_algorithm = value; }
 
     SinglyLinkedList<ValueWithSize>& queue() { return m_queue; }
 
@@ -41,16 +41,16 @@ public:
     size_t strategy_hwm() const { return m_strategy_hwm; }
     void set_strategy_hwm(size_t value) { m_strategy_hwm = value; }
 
-    JS::GCPtr<SizeAlgorithm> strategy_size_algorithm() { return m_strategy_size_algorithm; }
-    void set_strategy_size_algorithm(JS::GCPtr<SizeAlgorithm> value) { m_strategy_size_algorithm = value; }
+    GC::Ptr<SizeAlgorithm> strategy_size_algorithm() { return m_strategy_size_algorithm; }
+    void set_strategy_size_algorithm(GC::Ptr<SizeAlgorithm> value) { m_strategy_size_algorithm = value; }
 
-    JS::NonnullGCPtr<WritableStream> stream() { return *m_stream; }
-    void set_stream(JS::NonnullGCPtr<WritableStream> value) { m_stream = value; }
+    GC::Ref<WritableStream> stream() { return *m_stream; }
+    void set_stream(GC::Ref<WritableStream> value) { m_stream = value; }
 
-    JS::GCPtr<WriteAlgorithm> write_algorithm() { return m_write_algorithm; }
-    void set_write_algorithm(JS::GCPtr<WriteAlgorithm> value) { m_write_algorithm = value; }
+    GC::Ptr<WriteAlgorithm> write_algorithm() { return m_write_algorithm; }
+    void set_write_algorithm(GC::Ptr<WriteAlgorithm> value) { m_write_algorithm = value; }
 
-    JS::NonnullGCPtr<WebIDL::Promise> abort_steps(JS::Value reason);
+    GC::Ref<WebIDL::Promise> abort_steps(JS::Value reason);
     void error_steps();
 
 private:
@@ -60,11 +60,11 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-abortalgorithm
     // A promise-returning algorithm, taking one argument (the abort reason), which communicates a requested abort to the underlying sink
-    JS::GCPtr<AbortAlgorithm> m_abort_algorithm;
+    GC::Ptr<AbortAlgorithm> m_abort_algorithm;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-closealgorithm
     // A promise-returning algorithm which communicates a requested close to the underlying sink
-    JS::GCPtr<CloseAlgorithm> m_close_algorithm;
+    GC::Ptr<CloseAlgorithm> m_close_algorithm;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-queue
     // A list representing the stream’s internal queue of chunks
@@ -76,7 +76,7 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-signal
     // An AbortSignal that can be used to abort the pending write or close operation when the stream is aborted.
-    JS::GCPtr<DOM::AbortSignal> m_signal;
+    GC::Ptr<DOM::AbortSignal> m_signal;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-started
     // A boolean flag indicating whether the underlying sink has finished starting
@@ -88,15 +88,15 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-strategysizealgorithm
     // An algorithm to calculate the size of enqueued chunks, as part of the stream’s queuing strategy
-    JS::GCPtr<SizeAlgorithm> m_strategy_size_algorithm;
+    GC::Ptr<SizeAlgorithm> m_strategy_size_algorithm;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-stream
     // The WritableStream instance controlled
-    JS::GCPtr<WritableStream> m_stream;
+    GC::Ptr<WritableStream> m_stream;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultcontroller-writealgorithm
     // A promise-returning algorithm, taking one argument (the chunk to write), which writes data to the underlying sink
-    JS::GCPtr<WriteAlgorithm> m_write_algorithm;
+    GC::Ptr<WriteAlgorithm> m_write_algorithm;
 };
 
 }
diff --git a/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.cpp b/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.cpp
index 080fa32e291..7f5f63fc587 100644
--- a/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.cpp
+++ b/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.cpp
@@ -14,9 +14,9 @@
 
 namespace Web::Streams {
 
-JS_DEFINE_ALLOCATOR(WritableStreamDefaultWriter);
+GC_DEFINE_ALLOCATOR(WritableStreamDefaultWriter);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> WritableStreamDefaultWriter::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<WritableStream> stream)
+WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> WritableStreamDefaultWriter::construct_impl(JS::Realm& realm, GC::Ref<WritableStream> stream)
 {
     auto writer = realm.create<WritableStreamDefaultWriter>(realm);
 
@@ -27,7 +27,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> WritableStrea
 }
 
 // https://streams.spec.whatwg.org/#default-writer-closed
-JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::closed()
+GC::Ptr<WebIDL::Promise> WritableStreamDefaultWriter::closed()
 {
     // 1. Return this.[[closedPromise]].
     return m_closed_promise;
@@ -45,14 +45,14 @@ WebIDL::ExceptionOr<Optional<double>> WritableStreamDefaultWriter::desired_size(
 }
 
 // https://streams.spec.whatwg.org/#default-writer-ready
-JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::ready()
+GC::Ptr<WebIDL::Promise> WritableStreamDefaultWriter::ready()
 {
     // 1. Return this.[[readyPromise]].
     return m_ready_promise;
 }
 
 // https://streams.spec.whatwg.org/#default-writer-abort
-JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::abort(JS::Value reason)
+GC::Ptr<WebIDL::Promise> WritableStreamDefaultWriter::abort(JS::Value reason)
 {
     auto& realm = this->realm();
 
@@ -67,7 +67,7 @@ JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::abort(JS::Value reason)
 }
 
 // https://streams.spec.whatwg.org/#default-writer-close
-JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::close()
+GC::Ptr<WebIDL::Promise> WritableStreamDefaultWriter::close()
 {
     auto& realm = this->realm();
 
@@ -106,7 +106,7 @@ void WritableStreamDefaultWriter::release_lock()
 }
 
 // https://streams.spec.whatwg.org/#default-writer-write
-JS::GCPtr<WebIDL::Promise> WritableStreamDefaultWriter::write(JS::Value chunk)
+GC::Ptr<WebIDL::Promise> WritableStreamDefaultWriter::write(JS::Value chunk)
 {
     auto& realm = this->realm();
 
diff --git a/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.h b/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.h
index 1f06f257ac3..fe3ac5718f8 100644
--- a/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.h
+++ b/Libraries/LibWeb/Streams/WritableStreamDefaultWriter.h
@@ -18,30 +18,30 @@ namespace Web::Streams {
 // https://streams.spec.whatwg.org/#writablestreamdefaultwriter
 class WritableStreamDefaultWriter final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(WritableStreamDefaultWriter, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WritableStreamDefaultWriter);
+    GC_DECLARE_ALLOCATOR(WritableStreamDefaultWriter);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<WritableStreamDefaultWriter>> construct_impl(JS::Realm&, JS::NonnullGCPtr<WritableStream>);
+    static WebIDL::ExceptionOr<GC::Ref<WritableStreamDefaultWriter>> construct_impl(JS::Realm&, GC::Ref<WritableStream>);
 
     virtual ~WritableStreamDefaultWriter() override = default;
 
-    JS::GCPtr<WebIDL::Promise> closed();
+    GC::Ptr<WebIDL::Promise> closed();
     WebIDL::ExceptionOr<Optional<double>> desired_size() const;
-    JS::GCPtr<WebIDL::Promise> ready();
-    JS::GCPtr<WebIDL::Promise> abort(JS::Value reason);
-    JS::GCPtr<WebIDL::Promise> close();
+    GC::Ptr<WebIDL::Promise> ready();
+    GC::Ptr<WebIDL::Promise> abort(JS::Value reason);
+    GC::Ptr<WebIDL::Promise> close();
     void release_lock();
-    JS::GCPtr<WebIDL::Promise> write(JS::Value chunk);
+    GC::Ptr<WebIDL::Promise> write(JS::Value chunk);
 
-    JS::GCPtr<WebIDL::Promise> closed_promise() { return m_closed_promise; }
-    void set_closed_promise(JS::GCPtr<WebIDL::Promise> value) { m_closed_promise = value; }
+    GC::Ptr<WebIDL::Promise> closed_promise() { return m_closed_promise; }
+    void set_closed_promise(GC::Ptr<WebIDL::Promise> value) { m_closed_promise = value; }
 
-    JS::GCPtr<WebIDL::Promise> ready_promise() { return m_ready_promise; }
-    void set_ready_promise(JS::GCPtr<WebIDL::Promise> value) { m_ready_promise = value; }
+    GC::Ptr<WebIDL::Promise> ready_promise() { return m_ready_promise; }
+    void set_ready_promise(GC::Ptr<WebIDL::Promise> value) { m_ready_promise = value; }
 
-    JS::GCPtr<WritableStream const> stream() const { return m_stream; }
-    JS::GCPtr<WritableStream> stream() { return m_stream; }
-    void set_stream(JS::GCPtr<WritableStream> value) { m_stream = value; }
+    GC::Ptr<WritableStream const> stream() const { return m_stream; }
+    GC::Ptr<WritableStream> stream() { return m_stream; }
+    void set_stream(GC::Ptr<WritableStream> value) { m_stream = value; }
 
 private:
     explicit WritableStreamDefaultWriter(JS::Realm&);
@@ -52,15 +52,15 @@ private:
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultwriter-closedpromise
     // A promise returned by the writer’s closed getter
-    JS::GCPtr<WebIDL::Promise> m_closed_promise;
+    GC::Ptr<WebIDL::Promise> m_closed_promise;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultwriter-readypromise
     // A promise returned by the writer’s ready getter
-    JS::GCPtr<WebIDL::Promise> m_ready_promise;
+    GC::Ptr<WebIDL::Promise> m_ready_promise;
 
     // https://streams.spec.whatwg.org/#writablestreamdefaultwriter-stream
     // A WritableStream instance that owns this reader
-    JS::GCPtr<WritableStream> m_stream;
+    GC::Ptr<WritableStream> m_stream;
 };
 
 }
diff --git a/Libraries/LibWeb/TreeNode.h b/Libraries/LibWeb/TreeNode.h
index 1e428873c03..7aaf0fc8403 100644
--- a/Libraries/LibWeb/TreeNode.h
+++ b/Libraries/LibWeb/TreeNode.h
@@ -8,8 +8,8 @@
 
 #include <AK/Assertions.h>
 #include <AK/TypeCasts.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/TraversalDecision.h>
 
@@ -62,10 +62,10 @@ public:
     bool is_ancestor_of(TreeNode const&) const;
     bool is_inclusive_ancestor_of(TreeNode const&) const;
 
-    void append_child(JS::NonnullGCPtr<T> node);
-    void prepend_child(JS::NonnullGCPtr<T> node);
-    void insert_before(JS::NonnullGCPtr<T> node, JS::GCPtr<T> child);
-    void remove_child(JS::NonnullGCPtr<T> node);
+    void append_child(GC::Ref<T> node);
+    void prepend_child(GC::Ref<T> node);
+    void insert_before(GC::Ref<T> node, GC::Ptr<T> child);
+    void remove_child(GC::Ref<T> node);
 
     T* next_in_pre_order()
     {
@@ -351,7 +351,7 @@ private:
 };
 
 template<typename T>
-inline void TreeNode<T>::remove_child(JS::NonnullGCPtr<T> node)
+inline void TreeNode<T>::remove_child(GC::Ref<T> node)
 {
     VERIFY(node->m_parent == this);
 
@@ -373,7 +373,7 @@ inline void TreeNode<T>::remove_child(JS::NonnullGCPtr<T> node)
 }
 
 template<typename T>
-inline void TreeNode<T>::append_child(JS::NonnullGCPtr<T> node)
+inline void TreeNode<T>::append_child(GC::Ref<T> node)
 {
     VERIFY(!node->m_parent);
 
@@ -387,7 +387,7 @@ inline void TreeNode<T>::append_child(JS::NonnullGCPtr<T> node)
 }
 
 template<typename T>
-inline void TreeNode<T>::insert_before(JS::NonnullGCPtr<T> node, JS::GCPtr<T> child)
+inline void TreeNode<T>::insert_before(GC::Ref<T> node, GC::Ptr<T> child)
 {
     if (!child)
         return append_child(move(node));
@@ -410,7 +410,7 @@ inline void TreeNode<T>::insert_before(JS::NonnullGCPtr<T> node, JS::GCPtr<T> ch
 }
 
 template<typename T>
-inline void TreeNode<T>::prepend_child(JS::NonnullGCPtr<T> node)
+inline void TreeNode<T>::prepend_child(GC::Ref<T> node)
 {
     VERIFY(!node->m_parent);
 
diff --git a/Libraries/LibWeb/UIEvents/CompositionEvent.cpp b/Libraries/LibWeb/UIEvents/CompositionEvent.cpp
index 9266859808b..150d5c57700 100644
--- a/Libraries/LibWeb/UIEvents/CompositionEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/CompositionEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(CompositionEvent);
+GC_DEFINE_ALLOCATOR(CompositionEvent);
 
-JS::NonnullGCPtr<CompositionEvent> CompositionEvent::create(JS::Realm& realm, FlyString const& event_name, CompositionEventInit const& event_init)
+GC::Ref<CompositionEvent> CompositionEvent::create(JS::Realm& realm, FlyString const& event_name, CompositionEventInit const& event_init)
 {
     return realm.create<CompositionEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<CompositionEvent>> CompositionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CompositionEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<CompositionEvent>> CompositionEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, CompositionEventInit const& event_init)
 {
     return realm.create<CompositionEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/CompositionEvent.h b/Libraries/LibWeb/UIEvents/CompositionEvent.h
index ce16a87a310..86edff9fe0b 100644
--- a/Libraries/LibWeb/UIEvents/CompositionEvent.h
+++ b/Libraries/LibWeb/UIEvents/CompositionEvent.h
@@ -16,11 +16,11 @@ struct CompositionEventInit : public UIEventInit {
 
 class CompositionEvent final : public UIEvent {
     WEB_PLATFORM_OBJECT(CompositionEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(CompositionEvent);
+    GC_DECLARE_ALLOCATOR(CompositionEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<CompositionEvent> create(JS::Realm&, FlyString const& event_name, CompositionEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<CompositionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CompositionEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<CompositionEvent> create(JS::Realm&, FlyString const& event_name, CompositionEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<CompositionEvent>> construct_impl(JS::Realm&, FlyString const& event_name, CompositionEventInit const& event_init);
 
     virtual ~CompositionEvent() override;
 
diff --git a/Libraries/LibWeb/UIEvents/FocusEvent.cpp b/Libraries/LibWeb/UIEvents/FocusEvent.cpp
index d4858753f75..4681bfe2cfc 100644
--- a/Libraries/LibWeb/UIEvents/FocusEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/FocusEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(FocusEvent);
+GC_DEFINE_ALLOCATOR(FocusEvent);
 
-JS::NonnullGCPtr<FocusEvent> FocusEvent::create(JS::Realm& realm, FlyString const& event_name, FocusEventInit const& event_init)
+GC::Ref<FocusEvent> FocusEvent::create(JS::Realm& realm, FlyString const& event_name, FocusEventInit const& event_init)
 {
     return realm.create<FocusEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FocusEvent>> FocusEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, FocusEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<FocusEvent>> FocusEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, FocusEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/FocusEvent.h b/Libraries/LibWeb/UIEvents/FocusEvent.h
index 40101c9f068..3d397af352d 100644
--- a/Libraries/LibWeb/UIEvents/FocusEvent.h
+++ b/Libraries/LibWeb/UIEvents/FocusEvent.h
@@ -12,16 +12,16 @@
 namespace Web::UIEvents {
 
 struct FocusEventInit : public UIEventInit {
-    JS::GCPtr<DOM::EventTarget> related_target;
+    GC::Ptr<DOM::EventTarget> related_target;
 };
 
 class FocusEvent final : public UIEvent {
     WEB_PLATFORM_OBJECT(FocusEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(FocusEvent);
+    GC_DECLARE_ALLOCATOR(FocusEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FocusEvent> create(JS::Realm&, FlyString const& event_name, FocusEventInit const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<FocusEvent>> construct_impl(JS::Realm&, FlyString const& event_name, FocusEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<FocusEvent> create(JS::Realm&, FlyString const& event_name, FocusEventInit const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<FocusEvent>> construct_impl(JS::Realm&, FlyString const& event_name, FocusEventInit const& event_init);
 
     virtual ~FocusEvent() override;
 
diff --git a/Libraries/LibWeb/UIEvents/InputEvent.cpp b/Libraries/LibWeb/UIEvents/InputEvent.cpp
index 22d46159acb..43b89b15c8a 100644
--- a/Libraries/LibWeb/UIEvents/InputEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/InputEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(InputEvent);
+GC_DEFINE_ALLOCATOR(InputEvent);
 
-JS::NonnullGCPtr<InputEvent> InputEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, InputEventInit const& event_init)
+GC::Ref<InputEvent> InputEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, InputEventInit const& event_init)
 {
     auto event = realm.create<InputEvent>(realm, event_name, event_init);
     event->set_bubbles(true);
@@ -22,7 +22,7 @@ JS::NonnullGCPtr<InputEvent> InputEvent::create_from_platform_event(JS::Realm& r
     return event;
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<InputEvent>> InputEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, InputEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<InputEvent>> InputEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, InputEventInit const& event_init)
 {
     return realm.create<InputEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/InputEvent.h b/Libraries/LibWeb/UIEvents/InputEvent.h
index de35fe1291a..c46e204dd6d 100644
--- a/Libraries/LibWeb/UIEvents/InputEvent.h
+++ b/Libraries/LibWeb/UIEvents/InputEvent.h
@@ -19,11 +19,11 @@ struct InputEventInit : public UIEventInit {
 
 class InputEvent final : public UIEvent {
     WEB_PLATFORM_OBJECT(InputEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(InputEvent);
+    GC_DECLARE_ALLOCATOR(InputEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<InputEvent> create_from_platform_event(JS::Realm&, FlyString const& type, InputEventInit const& event_init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<InputEvent>> construct_impl(JS::Realm&, FlyString const& event_name, InputEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<InputEvent> create_from_platform_event(JS::Realm&, FlyString const& type, InputEventInit const& event_init);
+    static WebIDL::ExceptionOr<GC::Ref<InputEvent>> construct_impl(JS::Realm&, FlyString const& event_name, InputEventInit const& event_init);
 
     virtual ~InputEvent() override;
 
diff --git a/Libraries/LibWeb/UIEvents/KeyboardEvent.cpp b/Libraries/LibWeb/UIEvents/KeyboardEvent.cpp
index d50a217d01b..412bc7131f4 100644
--- a/Libraries/LibWeb/UIEvents/KeyboardEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/KeyboardEvent.cpp
@@ -13,7 +13,7 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(KeyboardEvent);
+GC_DEFINE_ALLOCATOR(KeyboardEvent);
 
 // https://www.w3.org/TR/uievents/#determine-keydown-keyup-keyCode
 static unsigned long determine_key_code(KeyCode platform_key, u32 code_point)
@@ -668,7 +668,7 @@ static DOMKeyLocation get_event_location(KeyCode platform_key, unsigned modifier
     return DOMKeyLocation::Standard;
 }
 
-JS::NonnullGCPtr<KeyboardEvent> KeyboardEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, KeyCode platform_key, unsigned modifiers, u32 code_point, bool repeat)
+GC::Ref<KeyboardEvent> KeyboardEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, KeyCode platform_key, unsigned modifiers, u32 code_point, bool repeat)
 {
     auto event_key = MUST(get_event_key(platform_key, code_point));
     auto event_code = MUST(get_event_code(platform_key, modifiers));
@@ -752,12 +752,12 @@ void KeyboardEvent::init_keyboard_event(String const& type, bool bubbles, bool c
     m_meta_key = meta_key;
 }
 
-JS::NonnullGCPtr<KeyboardEvent> KeyboardEvent::create(JS::Realm& realm, FlyString const& event_name, KeyboardEventInit const& event_init)
+GC::Ref<KeyboardEvent> KeyboardEvent::create(JS::Realm& realm, FlyString const& event_name, KeyboardEventInit const& event_init)
 {
     return realm.create<KeyboardEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyboardEvent>> KeyboardEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, KeyboardEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<KeyboardEvent>> KeyboardEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, KeyboardEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/KeyboardEvent.h b/Libraries/LibWeb/UIEvents/KeyboardEvent.h
index c90978b7113..a90eac16898 100644
--- a/Libraries/LibWeb/UIEvents/KeyboardEvent.h
+++ b/Libraries/LibWeb/UIEvents/KeyboardEvent.h
@@ -34,12 +34,12 @@ enum class DOMKeyLocation {
 // https://www.w3.org/TR/uievents/#interface-keyboardevent
 class KeyboardEvent final : public UIEvent {
     WEB_PLATFORM_OBJECT(KeyboardEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(KeyboardEvent);
+    GC_DECLARE_ALLOCATOR(KeyboardEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<KeyboardEvent> create(JS::Realm&, FlyString const& event_name, KeyboardEventInit const& = {});
-    [[nodiscard]] static JS::NonnullGCPtr<KeyboardEvent> create_from_platform_event(JS::Realm&, FlyString const& event_name, KeyCode, unsigned modifiers, u32 code_point, bool repeat);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<KeyboardEvent>> construct_impl(JS::Realm&, FlyString const& event_name, KeyboardEventInit const&);
+    [[nodiscard]] static GC::Ref<KeyboardEvent> create(JS::Realm&, FlyString const& event_name, KeyboardEventInit const& = {});
+    [[nodiscard]] static GC::Ref<KeyboardEvent> create_from_platform_event(JS::Realm&, FlyString const& event_name, KeyCode, unsigned modifiers, u32 code_point, bool repeat);
+    static WebIDL::ExceptionOr<GC::Ref<KeyboardEvent>> construct_impl(JS::Realm&, FlyString const& event_name, KeyboardEventInit const&);
 
     virtual ~KeyboardEvent() override;
 
diff --git a/Libraries/LibWeb/UIEvents/MouseEvent.cpp b/Libraries/LibWeb/UIEvents/MouseEvent.cpp
index c0f2b980661..f032ed7fe60 100644
--- a/Libraries/LibWeb/UIEvents/MouseEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/MouseEvent.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(MouseEvent);
+GC_DEFINE_ALLOCATOR(MouseEvent);
 
 MouseEvent::MouseEvent(JS::Realm& realm, FlyString const& event_name, MouseEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
     : UIEvent(realm, event_name, event_init)
@@ -123,17 +123,17 @@ void MouseEvent::init_mouse_event(String const& type, bool bubbles, bool cancela
     m_related_target = related_target;
 }
 
-JS::NonnullGCPtr<MouseEvent> MouseEvent::create(JS::Realm& realm, FlyString const& event_name, MouseEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
+GC::Ref<MouseEvent> MouseEvent::create(JS::Realm& realm, FlyString const& event_name, MouseEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
 {
     return realm.create<MouseEvent>(realm, event_name, event_init, page_x, page_y, offset_x, offset_y);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MouseEvent>> MouseEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MouseEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<MouseEvent>> MouseEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, MouseEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<MouseEvent>> MouseEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, Optional<CSSPixelPoint> movement, unsigned button, unsigned buttons, unsigned modifiers)
+WebIDL::ExceptionOr<GC::Ref<MouseEvent>> MouseEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, Optional<CSSPixelPoint> movement, unsigned button, unsigned buttons, unsigned modifiers)
 {
     MouseEventInit event_init {};
     event_init.ctrl_key = modifiers & Mod_Ctrl;
diff --git a/Libraries/LibWeb/UIEvents/MouseEvent.h b/Libraries/LibWeb/UIEvents/MouseEvent.h
index 0c8fd679b54..45044b5f06d 100644
--- a/Libraries/LibWeb/UIEvents/MouseEvent.h
+++ b/Libraries/LibWeb/UIEvents/MouseEvent.h
@@ -22,17 +22,17 @@ struct MouseEventInit : public EventModifierInit {
     double movement_y = 0;
     i16 button = 0;
     u16 buttons = 0;
-    JS::GCPtr<DOM::EventTarget> related_target = nullptr;
+    GC::Ptr<DOM::EventTarget> related_target = nullptr;
 };
 
 class MouseEvent : public UIEvent {
     WEB_PLATFORM_OBJECT(MouseEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(MouseEvent);
+    GC_DECLARE_ALLOCATOR(MouseEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<MouseEvent> create(JS::Realm&, FlyString const& event_name, MouseEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<MouseEvent>> create_from_platform_event(JS::Realm&, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, Optional<CSSPixelPoint> movement, unsigned button, unsigned buttons, unsigned modifiers);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<MouseEvent>> construct_impl(JS::Realm&, FlyString const& event_name, MouseEventInit const&);
+    [[nodiscard]] static GC::Ref<MouseEvent> create(JS::Realm&, FlyString const& event_name, MouseEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
+    static WebIDL::ExceptionOr<GC::Ref<MouseEvent>> create_from_platform_event(JS::Realm&, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, Optional<CSSPixelPoint> movement, unsigned button, unsigned buttons, unsigned modifiers);
+    static WebIDL::ExceptionOr<GC::Ref<MouseEvent>> construct_impl(JS::Realm&, FlyString const& event_name, MouseEventInit const&);
 
     virtual ~MouseEvent() override;
 
@@ -71,7 +71,7 @@ public:
     i16 button() const { return m_button; }
     u16 buttons() const { return m_buttons; }
 
-    JS::GCPtr<DOM::EventTarget> related_target() const { return m_related_target; }
+    GC::Ptr<DOM::EventTarget> related_target() const { return m_related_target; }
 
     bool get_modifier_state(String const& key_arg) const;
 
@@ -114,7 +114,7 @@ private:
     double m_movement_y { 0 };
     i16 m_button { 0 };
     u16 m_buttons { 0 };
-    JS::GCPtr<DOM::EventTarget> m_related_target { nullptr };
+    GC::Ptr<DOM::EventTarget> m_related_target { nullptr };
 };
 
 }
diff --git a/Libraries/LibWeb/UIEvents/PointerEvent.cpp b/Libraries/LibWeb/UIEvents/PointerEvent.cpp
index d37b96e4ae5..d6fbe73d59d 100644
--- a/Libraries/LibWeb/UIEvents/PointerEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/PointerEvent.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(PointerEvent);
+GC_DEFINE_ALLOCATOR(PointerEvent);
 
 PointerEvent::PointerEvent(JS::Realm& realm, FlyString const& type, PointerEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
     : MouseEvent(realm, type, event_init, page_x, page_y, offset_x, offset_y)
@@ -51,12 +51,12 @@ void PointerEvent::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_predicted_events);
 }
 
-JS::NonnullGCPtr<PointerEvent> PointerEvent::create(JS::Realm& realm, FlyString const& type, PointerEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
+GC::Ref<PointerEvent> PointerEvent::create(JS::Realm& realm, FlyString const& type, PointerEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
 {
     return realm.create<PointerEvent>(realm, type, event_init, page_x, page_y, offset_x, offset_y);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PointerEvent>> PointerEvent::construct_impl(JS::Realm& realm, FlyString const& type, PointerEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<PointerEvent>> PointerEvent::construct_impl(JS::Realm& realm, FlyString const& type, PointerEventInit const& event_init)
 {
     return create(realm, type, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/PointerEvent.h b/Libraries/LibWeb/UIEvents/PointerEvent.h
index 4cfd9a51414..316372f2080 100644
--- a/Libraries/LibWeb/UIEvents/PointerEvent.h
+++ b/Libraries/LibWeb/UIEvents/PointerEvent.h
@@ -25,18 +25,18 @@ struct PointerEventInit : public MouseEventInit {
     String pointer_type;
     bool is_primary { false };
     WebIDL::Long persistent_device_id { 0 };
-    AK::Vector<JS::Handle<PointerEvent>> coalesced_events;
-    AK::Vector<JS::Handle<PointerEvent>> predicted_events;
+    AK::Vector<GC::Root<PointerEvent>> coalesced_events;
+    AK::Vector<GC::Root<PointerEvent>> predicted_events;
 };
 
 // https://w3c.github.io/pointerevents/#pointerevent-interface
 class PointerEvent : public MouseEvent {
     WEB_PLATFORM_OBJECT(PointerEvent, MouseEvent);
-    JS_DECLARE_ALLOCATOR(PointerEvent);
+    GC_DECLARE_ALLOCATOR(PointerEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<PointerEvent> create(JS::Realm&, FlyString const& type, PointerEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PointerEvent>> construct_impl(JS::Realm&, FlyString const& type, PointerEventInit const&);
+    [[nodiscard]] static GC::Ref<PointerEvent> create(JS::Realm&, FlyString const& type, PointerEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
+    static WebIDL::ExceptionOr<GC::Ref<PointerEvent>> construct_impl(JS::Realm&, FlyString const& type, PointerEventInit const&);
 
     virtual ~PointerEvent() override;
 
@@ -53,8 +53,8 @@ public:
     String const& pointer_type() const { return m_pointer_type; }
     bool is_primary() const { return m_is_primary; }
     WebIDL::Long persistent_device_id() const { return m_persistent_device_id; }
-    AK::ReadonlySpan<JS::NonnullGCPtr<PointerEvent>> get_coalesced_events() const { return m_coalesced_events; }
-    AK::ReadonlySpan<JS::NonnullGCPtr<PointerEvent>> get_predicted_events() const { return m_predicted_events; }
+    AK::ReadonlySpan<GC::Ref<PointerEvent>> get_coalesced_events() const { return m_coalesced_events; }
+    AK::ReadonlySpan<GC::Ref<PointerEvent>> get_predicted_events() const { return m_predicted_events; }
 
     // https://w3c.github.io/pointerevents/#dom-pointerevent-pressure
     // For hardware and platforms that do not support pressure, the value MUST be 0.5 when in the active buttons state and 0 otherwise.
@@ -132,10 +132,10 @@ private:
     WebIDL::Long m_persistent_device_id { 0 };
 
     // https://w3c.github.io/pointerevents/#dom-pointerevent-getcoalescedevents
-    AK::Vector<JS::NonnullGCPtr<PointerEvent>> m_coalesced_events;
+    AK::Vector<GC::Ref<PointerEvent>> m_coalesced_events;
 
     // https://w3c.github.io/pointerevents/#dom-pointerevent-getpredictedevents
-    AK::Vector<JS::NonnullGCPtr<PointerEvent>> m_predicted_events;
+    AK::Vector<GC::Ref<PointerEvent>> m_predicted_events;
 };
 
 }
diff --git a/Libraries/LibWeb/UIEvents/TextEvent.cpp b/Libraries/LibWeb/UIEvents/TextEvent.cpp
index 8a9e63794bb..1b8ed6632ff 100644
--- a/Libraries/LibWeb/UIEvents/TextEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/TextEvent.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(TextEvent);
+GC_DEFINE_ALLOCATOR(TextEvent);
 
-JS::NonnullGCPtr<TextEvent> TextEvent::create(JS::Realm& realm, FlyString const& event_name)
+GC::Ref<TextEvent> TextEvent::create(JS::Realm& realm, FlyString const& event_name)
 {
     return realm.create<TextEvent>(realm, event_name);
 }
diff --git a/Libraries/LibWeb/UIEvents/TextEvent.h b/Libraries/LibWeb/UIEvents/TextEvent.h
index 884e340ea0c..47819ce92c1 100644
--- a/Libraries/LibWeb/UIEvents/TextEvent.h
+++ b/Libraries/LibWeb/UIEvents/TextEvent.h
@@ -12,10 +12,10 @@ namespace Web::UIEvents {
 
 class TextEvent final : public UIEvent {
     WEB_PLATFORM_OBJECT(TextEvent, UIEvent);
-    JS_DECLARE_ALLOCATOR(TextEvent);
+    GC_DECLARE_ALLOCATOR(TextEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<TextEvent> create(JS::Realm&, FlyString const& event_name);
+    [[nodiscard]] static GC::Ref<TextEvent> create(JS::Realm&, FlyString const& event_name);
 
     virtual ~TextEvent() override;
 
diff --git a/Libraries/LibWeb/UIEvents/UIEvent.cpp b/Libraries/LibWeb/UIEvents/UIEvent.cpp
index bed33e65a28..51fbfd78440 100644
--- a/Libraries/LibWeb/UIEvents/UIEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/UIEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(UIEvent);
+GC_DEFINE_ALLOCATOR(UIEvent);
 
-JS::NonnullGCPtr<UIEvent> UIEvent::create(JS::Realm& realm, FlyString const& event_name)
+GC::Ref<UIEvent> UIEvent::create(JS::Realm& realm, FlyString const& event_name)
 {
     return realm.create<UIEvent>(realm, event_name);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<UIEvent>> UIEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, UIEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<UIEvent>> UIEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, UIEventInit const& event_init)
 {
     return realm.create<UIEvent>(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/UIEvents/UIEvent.h b/Libraries/LibWeb/UIEvents/UIEvent.h
index 0ab9625a40b..64c0e1902c2 100644
--- a/Libraries/LibWeb/UIEvents/UIEvent.h
+++ b/Libraries/LibWeb/UIEvents/UIEvent.h
@@ -13,17 +13,17 @@
 namespace Web::UIEvents {
 
 struct UIEventInit : public DOM::EventInit {
-    JS::GCPtr<HTML::Window> view;
+    GC::Ptr<HTML::Window> view;
     int detail { 0 };
 };
 
 class UIEvent : public DOM::Event {
     WEB_PLATFORM_OBJECT(UIEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(UIEvent);
+    GC_DECLARE_ALLOCATOR(UIEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<UIEvent> create(JS::Realm&, FlyString const& type);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<UIEvent>> construct_impl(JS::Realm&, FlyString const& event_name, UIEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<UIEvent> create(JS::Realm&, FlyString const& type);
+    static WebIDL::ExceptionOr<GC::Ref<UIEvent>> construct_impl(JS::Realm&, FlyString const& event_name, UIEventInit const& event_init);
 
     virtual ~UIEvent() override;
 
@@ -54,7 +54,7 @@ protected:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::GCPtr<HTML::Window> m_view;
+    GC::Ptr<HTML::Window> m_view;
     int m_detail { 0 };
 };
 
diff --git a/Libraries/LibWeb/UIEvents/WheelEvent.cpp b/Libraries/LibWeb/UIEvents/WheelEvent.cpp
index 8016f8a1f79..4d936b505da 100644
--- a/Libraries/LibWeb/UIEvents/WheelEvent.cpp
+++ b/Libraries/LibWeb/UIEvents/WheelEvent.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::UIEvents {
 
-JS_DEFINE_ALLOCATOR(WheelEvent);
+GC_DEFINE_ALLOCATOR(WheelEvent);
 
 WheelEvent::WheelEvent(JS::Realm& realm, FlyString const& event_name, WheelEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
     : MouseEvent(realm, event_name, event_init, page_x, page_y, offset_x, offset_y)
@@ -33,17 +33,17 @@ void WheelEvent::initialize(JS::Realm& realm)
     WEB_SET_PROTOTYPE_FOR_INTERFACE(WheelEvent);
 }
 
-JS::NonnullGCPtr<WheelEvent> WheelEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, WheelEventInit const& wheel_event_init)
+GC::Ref<WheelEvent> WheelEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, WheelEventInit const& wheel_event_init)
 {
     return create(realm, event_name, wheel_event_init);
 }
 
-JS::NonnullGCPtr<WheelEvent> WheelEvent::create(JS::Realm& realm, FlyString const& event_name, WheelEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
+GC::Ref<WheelEvent> WheelEvent::create(JS::Realm& realm, FlyString const& event_name, WheelEventInit const& event_init, double page_x, double page_y, double offset_x, double offset_y)
 {
     return realm.create<WheelEvent>(realm, event_name, event_init, page_x, page_y, offset_x, offset_y);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WheelEvent>> WheelEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, double delta_x, double delta_y, unsigned button, unsigned buttons, unsigned modifiers)
+WebIDL::ExceptionOr<GC::Ref<WheelEvent>> WheelEvent::create_from_platform_event(JS::Realm& realm, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, double delta_x, double delta_y, unsigned button, unsigned buttons, unsigned modifiers)
 {
     WheelEventInit event_init {};
     event_init.ctrl_key = modifiers & Mod_Ctrl;
diff --git a/Libraries/LibWeb/UIEvents/WheelEvent.h b/Libraries/LibWeb/UIEvents/WheelEvent.h
index 8660f69db2e..ac28fd7f8b9 100644
--- a/Libraries/LibWeb/UIEvents/WheelEvent.h
+++ b/Libraries/LibWeb/UIEvents/WheelEvent.h
@@ -28,13 +28,13 @@ struct WheelEventInit : public MouseEventInit {
 
 class WheelEvent final : public MouseEvent {
     WEB_PLATFORM_OBJECT(WheelEvent, MouseEvent);
-    JS_DECLARE_ALLOCATOR(WheelEvent);
+    GC_DECLARE_ALLOCATOR(WheelEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<WheelEvent> create(JS::Realm&, FlyString const& event_name, WheelEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
-    [[nodiscard]] static JS::NonnullGCPtr<WheelEvent> construct_impl(JS::Realm&, FlyString const& event_name, WheelEventInit const& = {});
+    [[nodiscard]] static GC::Ref<WheelEvent> create(JS::Realm&, FlyString const& event_name, WheelEventInit const& = {}, double page_x = 0, double page_y = 0, double offset_x = 0, double offset_y = 0);
+    [[nodiscard]] static GC::Ref<WheelEvent> construct_impl(JS::Realm&, FlyString const& event_name, WheelEventInit const& = {});
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<WheelEvent>> create_from_platform_event(JS::Realm&, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, double delta_x, double delta_y, unsigned button, unsigned buttons, unsigned modifiers);
+    static WebIDL::ExceptionOr<GC::Ref<WheelEvent>> create_from_platform_event(JS::Realm&, FlyString const& event_name, CSSPixelPoint screen, CSSPixelPoint page, CSSPixelPoint client, CSSPixelPoint offset, double delta_x, double delta_y, unsigned button, unsigned buttons, unsigned modifiers);
 
     virtual ~WheelEvent() override;
 
diff --git a/Libraries/LibWeb/UserTiming/PerformanceMark.cpp b/Libraries/LibWeb/UserTiming/PerformanceMark.cpp
index 526f44f7ae7..40e40af47cc 100644
--- a/Libraries/LibWeb/UserTiming/PerformanceMark.cpp
+++ b/Libraries/LibWeb/UserTiming/PerformanceMark.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::UserTiming {
 
-JS_DEFINE_ALLOCATOR(PerformanceMark);
+GC_DEFINE_ALLOCATOR(PerformanceMark);
 
 PerformanceMark::PerformanceMark(JS::Realm& realm, String const& name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail)
     : PerformanceTimeline::PerformanceEntry(realm, name, start_time, duration)
@@ -27,7 +27,7 @@ PerformanceMark::PerformanceMark(JS::Realm& realm, String const& name, HighResol
 PerformanceMark::~PerformanceMark() = default;
 
 // https://w3c.github.io/user-timing/#dfn-performancemark-constructor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PerformanceMark>> PerformanceMark::construct_impl(JS::Realm& realm, String const& mark_name, Web::UserTiming::PerformanceMarkOptions const& mark_options)
+WebIDL::ExceptionOr<GC::Ref<PerformanceMark>> PerformanceMark::construct_impl(JS::Realm& realm, String const& mark_name, Web::UserTiming::PerformanceMarkOptions const& mark_options)
 {
     auto& current_principal_global_object = HTML::current_principal_global_object();
     auto& vm = realm.vm();
diff --git a/Libraries/LibWeb/UserTiming/PerformanceMark.h b/Libraries/LibWeb/UserTiming/PerformanceMark.h
index f251d3e5ef7..d43e93811c5 100644
--- a/Libraries/LibWeb/UserTiming/PerformanceMark.h
+++ b/Libraries/LibWeb/UserTiming/PerformanceMark.h
@@ -19,12 +19,12 @@ struct PerformanceMarkOptions {
 // https://w3c.github.io/user-timing/#dom-performancemark
 class PerformanceMark final : public PerformanceTimeline::PerformanceEntry {
     WEB_PLATFORM_OBJECT(PerformanceMark, PerformanceTimeline::PerformanceEntry);
-    JS_DECLARE_ALLOCATOR(PerformanceMark);
+    GC_DECLARE_ALLOCATOR(PerformanceMark);
 
 public:
     virtual ~PerformanceMark();
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PerformanceMark>> construct_impl(JS::Realm&, String const& mark_name, PerformanceMarkOptions const& mark_options = {});
+    static WebIDL::ExceptionOr<GC::Ref<PerformanceMark>> construct_impl(JS::Realm&, String const& mark_name, PerformanceMarkOptions const& mark_options = {});
 
     // NOTE: These three functions are answered by the registry for the given entry type.
     // https://w3c.github.io/timing-entrytypes-registry/#registry
diff --git a/Libraries/LibWeb/UserTiming/PerformanceMeasure.cpp b/Libraries/LibWeb/UserTiming/PerformanceMeasure.cpp
index 7a83c7de33c..47434cb442f 100644
--- a/Libraries/LibWeb/UserTiming/PerformanceMeasure.cpp
+++ b/Libraries/LibWeb/UserTiming/PerformanceMeasure.cpp
@@ -16,7 +16,7 @@
 
 namespace Web::UserTiming {
 
-JS_DEFINE_ALLOCATOR(PerformanceMeasure);
+GC_DEFINE_ALLOCATOR(PerformanceMeasure);
 
 PerformanceMeasure::PerformanceMeasure(JS::Realm& realm, String const& name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail)
     : PerformanceTimeline::PerformanceEntry(realm, name, start_time, duration)
@@ -26,7 +26,7 @@ PerformanceMeasure::PerformanceMeasure(JS::Realm& realm, String const& name, Hig
 
 PerformanceMeasure::~PerformanceMeasure() = default;
 
-JS::NonnullGCPtr<PerformanceMeasure> PerformanceMeasure::create(JS::Realm& realm, String const& measure_name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail)
+GC::Ref<PerformanceMeasure> PerformanceMeasure::create(JS::Realm& realm, String const& measure_name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail)
 {
     return realm.create<PerformanceMeasure>(realm, measure_name, start_time, duration, detail);
 }
diff --git a/Libraries/LibWeb/UserTiming/PerformanceMeasure.h b/Libraries/LibWeb/UserTiming/PerformanceMeasure.h
index cc423fdf5c6..e5fe485955e 100644
--- a/Libraries/LibWeb/UserTiming/PerformanceMeasure.h
+++ b/Libraries/LibWeb/UserTiming/PerformanceMeasure.h
@@ -21,12 +21,12 @@ struct PerformanceMeasureOptions {
 // https://w3c.github.io/user-timing/#dom-performancemeasure
 class PerformanceMeasure final : public PerformanceTimeline::PerformanceEntry {
     WEB_PLATFORM_OBJECT(PerformanceMeasure, PerformanceTimeline::PerformanceEntry);
-    JS_DECLARE_ALLOCATOR(PerformanceMeasure);
+    GC_DECLARE_ALLOCATOR(PerformanceMeasure);
 
 public:
     virtual ~PerformanceMeasure();
 
-    [[nodiscard]] static JS::NonnullGCPtr<PerformanceMeasure> create(JS::Realm&, String const& measure_name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail);
+    [[nodiscard]] static GC::Ref<PerformanceMeasure> create(JS::Realm&, String const& measure_name, HighResolutionTime::DOMHighResTimeStamp start_time, HighResolutionTime::DOMHighResTimeStamp duration, JS::Value detail);
 
     // NOTE: These three functions are answered by the registry for the given entry type.
     // https://w3c.github.io/timing-entrytypes-registry/#registry
diff --git a/Libraries/LibWeb/WebAssembly/Instance.cpp b/Libraries/LibWeb/WebAssembly/Instance.cpp
index 868e685320c..0413d27b263 100644
--- a/Libraries/LibWeb/WebAssembly/Instance.cpp
+++ b/Libraries/LibWeb/WebAssembly/Instance.cpp
@@ -19,11 +19,11 @@
 
 namespace Web::WebAssembly {
 
-JS_DEFINE_ALLOCATOR(Instance);
+GC_DEFINE_ALLOCATOR(Instance);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Instance>> Instance::construct_impl(JS::Realm& realm, Module& module, Optional<JS::Handle<JS::Object>>& import_object_handle)
+WebIDL::ExceptionOr<GC::Ref<Instance>> Instance::construct_impl(JS::Realm& realm, Module& module, Optional<GC::Root<JS::Object>>& import_object_handle)
 {
-    JS::GCPtr<JS::Object> import_object = import_object_handle.has_value() ? import_object_handle.value().ptr() : nullptr;
+    GC::Ptr<JS::Object> import_object = import_object_handle.has_value() ? import_object_handle.value().ptr() : nullptr;
 
     auto& vm = realm.vm();
 
@@ -48,7 +48,7 @@ void Instance::initialize(JS::Realm& realm)
     for (auto& export_ : m_module_instance->exports()) {
         export_.value().visit(
             [&](Wasm::FunctionAddress const& address) {
-                Optional<JS::GCPtr<JS::FunctionObject>> object = m_function_instances.get(address);
+                Optional<GC::Ptr<JS::FunctionObject>> object = m_function_instances.get(address);
                 if (!object.has_value()) {
                     object = Detail::create_native_function(vm, address, export_.name(), this);
                     m_function_instances.set(address, *object);
@@ -57,7 +57,7 @@ void Instance::initialize(JS::Realm& realm)
                 m_exports->define_direct_property(export_.name(), *object, JS::default_attributes);
             },
             [&](Wasm::MemoryAddress const& address) {
-                Optional<JS::GCPtr<Memory>> object = m_memory_instances.get(address);
+                Optional<GC::Ptr<Memory>> object = m_memory_instances.get(address);
                 if (!object.has_value()) {
                     object = realm.create<Memory>(realm, address);
                     m_memory_instances.set(address, *object);
@@ -66,7 +66,7 @@ void Instance::initialize(JS::Realm& realm)
                 m_exports->define_direct_property(export_.name(), *object, JS::default_attributes);
             },
             [&](Wasm::TableAddress const& address) {
-                Optional<JS::GCPtr<Table>> object = m_table_instances.get(address);
+                Optional<GC::Ptr<Table>> object = m_table_instances.get(address);
                 if (!object.has_value()) {
                     object = realm.create<Table>(realm, address);
                     m_table_instances.set(address, *object);
diff --git a/Libraries/LibWeb/WebAssembly/Instance.h b/Libraries/LibWeb/WebAssembly/Instance.h
index 1d5d13d3576..8cfc378481d 100644
--- a/Libraries/LibWeb/WebAssembly/Instance.h
+++ b/Libraries/LibWeb/WebAssembly/Instance.h
@@ -8,9 +8,9 @@
 #pragma once
 
 #include <AK/Optional.h>
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWasm/AbstractMachine/AbstractMachine.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Bindings/PlatformObject.h>
@@ -20,10 +20,10 @@ namespace Web::WebAssembly {
 
 class Instance : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Instance, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Instance);
+    GC_DECLARE_ALLOCATOR(Instance);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Instance>> construct_impl(JS::Realm&, Module& module, Optional<JS::Handle<JS::Object>>& import_object);
+    static WebIDL::ExceptionOr<GC::Ref<Instance>> construct_impl(JS::Realm&, Module& module, Optional<GC::Root<JS::Object>>& import_object);
 
     Object const* exports() const { return m_exports.ptr(); }
 
@@ -33,11 +33,11 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor&) override;
 
-    JS::NonnullGCPtr<Object> m_exports;
+    GC::Ref<Object> m_exports;
     NonnullOwnPtr<Wasm::ModuleInstance> m_module_instance;
-    HashMap<Wasm::FunctionAddress, JS::GCPtr<JS::FunctionObject>> m_function_instances;
-    HashMap<Wasm::MemoryAddress, JS::GCPtr<WebAssembly::Memory>> m_memory_instances;
-    HashMap<Wasm::TableAddress, JS::GCPtr<WebAssembly::Table>> m_table_instances;
+    HashMap<Wasm::FunctionAddress, GC::Ptr<JS::FunctionObject>> m_function_instances;
+    HashMap<Wasm::MemoryAddress, GC::Ptr<WebAssembly::Memory>> m_memory_instances;
+    HashMap<Wasm::TableAddress, GC::Ptr<WebAssembly::Table>> m_table_instances;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAssembly/Memory.cpp b/Libraries/LibWeb/WebAssembly/Memory.cpp
index 4485eafb0dd..75a2ee84b99 100644
--- a/Libraries/LibWeb/WebAssembly/Memory.cpp
+++ b/Libraries/LibWeb/WebAssembly/Memory.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::WebAssembly {
 
-JS_DEFINE_ALLOCATOR(Memory);
+GC_DEFINE_ALLOCATOR(Memory);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Memory>> Memory::construct_impl(JS::Realm& realm, MemoryDescriptor& descriptor)
+WebIDL::ExceptionOr<GC::Ref<Memory>> Memory::construct_impl(JS::Realm& realm, MemoryDescriptor& descriptor)
 {
     auto& vm = realm.vm();
 
@@ -92,7 +92,7 @@ WebIDL::ExceptionOr<void> Memory::reset_the_memory_buffer()
 }
 
 // https://webassembly.github.io/spec/js-api/#dom-memory-buffer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> Memory::buffer() const
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> Memory::buffer() const
 {
     auto& vm = this->vm();
     auto& realm = *vm.current_realm();
@@ -100,11 +100,11 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> Memory::buffer() const
     if (!m_buffer)
         m_buffer = TRY(create_a_memory_buffer(vm, realm, m_address));
 
-    return JS::NonnullGCPtr(*m_buffer);
+    return GC::Ref(*m_buffer);
 }
 
 // https://webassembly.github.io/spec/js-api/#create-a-memory-buffer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> Memory::create_a_memory_buffer(JS::VM& vm, JS::Realm& realm, Wasm::MemoryAddress address)
+WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> Memory::create_a_memory_buffer(JS::VM& vm, JS::Realm& realm, Wasm::MemoryAddress address)
 {
     auto& context = Detail::get_cache(realm);
     auto* memory = context.abstract_machine().store().get(address);
@@ -114,7 +114,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> Memory::create_a_memory_b
     auto array_buffer = JS::ArrayBuffer::create(realm, &memory->data());
     array_buffer->set_detach_key(JS::PrimitiveString::create(vm, "WebAssembly.Memory"_string));
 
-    return JS::NonnullGCPtr(*array_buffer);
+    return GC::Ref(*array_buffer);
 }
 
 }
diff --git a/Libraries/LibWeb/WebAssembly/Memory.h b/Libraries/LibWeb/WebAssembly/Memory.h
index bb4f832c15a..085a445b2b0 100644
--- a/Libraries/LibWeb/WebAssembly/Memory.h
+++ b/Libraries/LibWeb/WebAssembly/Memory.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Optional.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibJS/Runtime/ArrayBuffer.h>
 #include <LibWasm/AbstractMachine/AbstractMachine.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
@@ -24,13 +24,13 @@ struct MemoryDescriptor {
 
 class Memory : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Memory, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Memory);
+    GC_DECLARE_ALLOCATOR(Memory);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Memory>> construct_impl(JS::Realm&, MemoryDescriptor& descriptor);
+    static WebIDL::ExceptionOr<GC::Ref<Memory>> construct_impl(JS::Realm&, MemoryDescriptor& descriptor);
 
     WebIDL::ExceptionOr<u32> grow(u32 delta);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> buffer() const;
+    WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> buffer() const;
 
     Wasm::MemoryAddress address() const { return m_address; }
 
@@ -41,10 +41,10 @@ private:
     virtual void visit_edges(Visitor&) override;
 
     WebIDL::ExceptionOr<void> reset_the_memory_buffer();
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::ArrayBuffer>> create_a_memory_buffer(JS::VM&, JS::Realm&, Wasm::MemoryAddress);
+    static WebIDL::ExceptionOr<GC::Ref<JS::ArrayBuffer>> create_a_memory_buffer(JS::VM&, JS::Realm&, Wasm::MemoryAddress);
 
     Wasm::MemoryAddress m_address;
-    mutable JS::GCPtr<JS::ArrayBuffer> m_buffer;
+    mutable GC::Ptr<JS::ArrayBuffer> m_buffer;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAssembly/Module.cpp b/Libraries/LibWeb/WebAssembly/Module.cpp
index 709ad5cd82d..77750e51b82 100644
--- a/Libraries/LibWeb/WebAssembly/Module.cpp
+++ b/Libraries/LibWeb/WebAssembly/Module.cpp
@@ -16,9 +16,9 @@
 
 namespace Web::WebAssembly {
 
-JS_DEFINE_ALLOCATOR(Module);
+GC_DEFINE_ALLOCATOR(Module);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Module>> Module::construct_impl(JS::Realm& realm, JS::Handle<WebIDL::BufferSource>& bytes)
+WebIDL::ExceptionOr<GC::Ref<Module>> Module::construct_impl(JS::Realm& realm, GC::Root<WebIDL::BufferSource>& bytes)
 {
     auto& vm = realm.vm();
 
diff --git a/Libraries/LibWeb/WebAssembly/Module.h b/Libraries/LibWeb/WebAssembly/Module.h
index e4339edbab0..9ab7a3cd948 100644
--- a/Libraries/LibWeb/WebAssembly/Module.h
+++ b/Libraries/LibWeb/WebAssembly/Module.h
@@ -7,9 +7,9 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWasm/Types.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
 #include <LibWeb/Bindings/PlatformObject.h>
@@ -19,10 +19,10 @@ namespace Web::WebAssembly {
 
 class Module : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Module, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Module);
+    GC_DECLARE_ALLOCATOR(Module);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Module>> construct_impl(JS::Realm&, JS::Handle<WebIDL::BufferSource>& bytes);
+    static WebIDL::ExceptionOr<GC::Ref<Module>> construct_impl(JS::Realm&, GC::Root<WebIDL::BufferSource>& bytes);
 
     NonnullRefPtr<Detail::CompiledWebAssemblyModule> compiled_module() const { return m_compiled_module; }
 
diff --git a/Libraries/LibWeb/WebAssembly/Table.cpp b/Libraries/LibWeb/WebAssembly/Table.cpp
index aeefc809b90..357525fa1c0 100644
--- a/Libraries/LibWeb/WebAssembly/Table.cpp
+++ b/Libraries/LibWeb/WebAssembly/Table.cpp
@@ -15,7 +15,7 @@
 
 namespace Web::WebAssembly {
 
-JS_DEFINE_ALLOCATOR(Table);
+GC_DEFINE_ALLOCATOR(Table);
 
 static Wasm::ValueType table_kind_to_value_type(Bindings::TableKind kind)
 {
@@ -29,7 +29,7 @@ static Wasm::ValueType table_kind_to_value_type(Bindings::TableKind kind)
     VERIFY_NOT_REACHED();
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<Table>> Table::construct_impl(JS::Realm& realm, TableDescriptor& descriptor, JS::Value value)
+WebIDL::ExceptionOr<GC::Ref<Table>> Table::construct_impl(JS::Realm& realm, TableDescriptor& descriptor, JS::Value value)
 {
     auto& vm = realm.vm();
 
diff --git a/Libraries/LibWeb/WebAssembly/Table.h b/Libraries/LibWeb/WebAssembly/Table.h
index 98a72835586..e8ac48b2811 100644
--- a/Libraries/LibWeb/WebAssembly/Table.h
+++ b/Libraries/LibWeb/WebAssembly/Table.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Optional.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWasm/AbstractMachine/AbstractMachine.h>
 #include <LibWeb/Bindings/ExceptionOrUtils.h>
@@ -26,10 +26,10 @@ struct TableDescriptor {
 
 class Table : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(Table, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(Table);
+    GC_DECLARE_ALLOCATOR(Table);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<Table>> construct_impl(JS::Realm&, TableDescriptor& descriptor, JS::Value value);
+    static WebIDL::ExceptionOr<GC::Ref<Table>> construct_impl(JS::Realm&, TableDescriptor& descriptor, JS::Value value);
 
     WebIDL::ExceptionOr<u32> grow(u32 delta, JS::Value value);
 
diff --git a/Libraries/LibWeb/WebAssembly/WebAssembly.cpp b/Libraries/LibWeb/WebAssembly/WebAssembly.cpp
index e918e5bcef6..edfd0d17f21 100644
--- a/Libraries/LibWeb/WebAssembly/WebAssembly.cpp
+++ b/Libraries/LibWeb/WebAssembly/WebAssembly.cpp
@@ -34,14 +34,14 @@
 
 namespace Web::WebAssembly {
 
-static JS::NonnullGCPtr<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM&, ByteBuffer, HTML::Task::Source = HTML::Task::Source::Unspecified);
-static JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM&, JS::NonnullGCPtr<WebIDL::Promise>, JS::GCPtr<JS::Object> import_object);
-static JS::NonnullGCPtr<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM&, JS::NonnullGCPtr<Module>, JS::GCPtr<JS::Object> import_object);
-static JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&, JS::NonnullGCPtr<WebIDL::Promise>);
+static GC::Ref<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM&, ByteBuffer, HTML::Task::Source = HTML::Task::Source::Unspecified);
+static GC::Ref<WebIDL::Promise> instantiate_promise_of_module(JS::VM&, GC::Ref<WebIDL::Promise>, GC::Ptr<JS::Object> import_object);
+static GC::Ref<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM&, GC::Ref<Module>, GC::Ptr<JS::Object> import_object);
+static GC::Ref<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&, GC::Ref<WebIDL::Promise>);
 
 namespace Detail {
 
-HashMap<JS::GCPtr<JS::Object>, WebAssemblyCache> s_caches;
+HashMap<GC::Ptr<JS::Object>, WebAssemblyCache> s_caches;
 
 WebAssemblyCache& get_cache(JS::Realm& realm)
 {
@@ -68,7 +68,7 @@ void finalize(JS::Object& object)
 }
 
 // https://webassembly.github.io/spec/js-api/#dom-webassembly-validate
-bool validate(JS::VM& vm, JS::Handle<WebIDL::BufferSource>& bytes)
+bool validate(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes)
 {
     // 1. Let stableBytes be a copy of the bytes held by the buffer bytes.
     auto stable_bytes = WebIDL::get_buffer_source_copy(*bytes->raw_object());
@@ -89,7 +89,7 @@ bool validate(JS::VM& vm, JS::Handle<WebIDL::BufferSource>& bytes)
 }
 
 // https://webassembly.github.io/spec/js-api/#dom-webassembly-compile
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> compile(JS::VM& vm, JS::Handle<WebIDL::BufferSource>& bytes)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes)
 {
     auto& realm = *vm.current_realm();
 
@@ -105,14 +105,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> compile(JS::VM& vm, JS::H
 }
 
 // https://webassembly.github.io/spec/web-api/index.html#dom-webassembly-compilestreaming
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> compile_streaming(JS::VM& vm, JS::Handle<WebIDL::Promise> source)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile_streaming(JS::VM& vm, GC::Root<WebIDL::Promise> source)
 {
     //  The compileStreaming(source) method, when invoked, returns the result of compiling a potential WebAssembly response with source.
     return compile_potential_webassembly_response(vm, *source);
 }
 
 // https://webassembly.github.io/spec/js-api/#dom-webassembly-instantiate
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate(JS::VM& vm, JS::Handle<WebIDL::BufferSource>& bytes, Optional<JS::Handle<JS::Object>>& import_object_handle)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM& vm, GC::Root<WebIDL::BufferSource>& bytes, Optional<GC::Root<JS::Object>>& import_object_handle)
 {
     auto& realm = *vm.current_realm();
 
@@ -127,21 +127,21 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate(JS::VM& vm, J
     auto promise_of_module = asynchronously_compile_webassembly_module(vm, stable_bytes.release_value());
 
     // 3. Instantiate promiseOfModule with imports importObject and return the result.
-    JS::GCPtr<JS::Object> const import_object = import_object_handle.has_value() ? import_object_handle.value().ptr() : nullptr;
+    GC::Ptr<JS::Object> const import_object = import_object_handle.has_value() ? import_object_handle.value().ptr() : nullptr;
     return instantiate_promise_of_module(vm, promise_of_module, import_object);
 }
 
 // https://webassembly.github.io/spec/js-api/#dom-webassembly-instantiate-moduleobject-importobject
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate(JS::VM& vm, Module const& module_object, Optional<JS::Handle<JS::Object>>& import_object)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM& vm, Module const& module_object, Optional<GC::Root<JS::Object>>& import_object)
 {
     // 1. Asynchronously instantiate the WebAssembly module moduleObject importing importObject, and return the result.
-    JS::NonnullGCPtr<Module> module { const_cast<Module&>(module_object) };
-    JS::GCPtr<JS::Object> const imports = import_object.has_value() ? import_object.value().ptr() : nullptr;
+    GC::Ref<Module> module { const_cast<Module&>(module_object) };
+    GC::Ptr<JS::Object> const imports = import_object.has_value() ? import_object.value().ptr() : nullptr;
     return asynchronously_instantiate_webassembly_module(vm, module, imports);
 }
 
 // https://webassembly.github.io/spec/web-api/index.html#dom-webassembly-instantiatestreaming
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate_streaming(JS::VM& vm, JS::Handle<WebIDL::Promise> source, Optional<JS::Handle<JS::Object>>& import_object)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate_streaming(JS::VM& vm, GC::Root<WebIDL::Promise> source, Optional<GC::Root<JS::Object>>& import_object)
 {
     // The instantiateStreaming(source, importObject) method, when invoked, performs the following steps:
 
@@ -149,13 +149,13 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate_streaming(JS:
     auto promise_of_module = compile_potential_webassembly_response(vm, *source);
 
     // 2. Return the result of instantiating the promise of a module promiseOfModule with imports importObject.
-    auto imports = JS::GCPtr { import_object.has_value() ? import_object.value().ptr() : nullptr };
+    auto imports = GC::Ptr { import_object.has_value() ? import_object.value().ptr() : nullptr };
     return instantiate_promise_of_module(vm, promise_of_module, imports);
 }
 
 namespace Detail {
 
-JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS::VM& vm, Wasm::Module const& module, JS::GCPtr<JS::Object> import_object)
+JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS::VM& vm, Wasm::Module const& module, GC::Ptr<JS::Object> import_object)
 {
     Wasm::Linker linker { module };
     HashMap<Wasm::Linker::Name, Wasm::ExternValue> resolved_imports;
@@ -189,7 +189,7 @@ JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS
                     //        just extract its address and resolve to that.
                     Wasm::HostFunction host_function {
                         [&](auto&, auto& arguments) -> Wasm::Result {
-                            JS::MarkedVector<JS::Value> argument_values { vm.heap() };
+                            GC::MarkedVector<JS::Value> argument_values { vm.heap() };
                             size_t index = 0;
                             for (auto& entry : arguments) {
                                 argument_values.append(to_js_value(vm, entry, type.parameters()[index]));
@@ -359,7 +359,7 @@ JS::NativeFunction* create_native_function(JS::VM& vm, Wasm::FunctionAddress add
                 return to_js_value(vm, result.values().first(), type.results().first());
 
             // Put result values into a JS::Array in reverse order.
-            auto js_result_values = JS::MarkedVector<JS::Value> { realm.heap() };
+            auto js_result_values = GC::MarkedVector<JS::Value> { realm.heap() };
             js_result_values.ensure_capacity(result.values().size());
 
             for (size_t i = result.values().size(); i > 0; i--) {
@@ -498,7 +498,7 @@ JS::Value to_js_value(JS::VM& vm, Wasm::Value& wasm_value, Wasm::ValueType type)
 }
 
 // https://webassembly.github.io/spec/js-api/#asynchronously-compile-a-webassembly-module
-JS::NonnullGCPtr<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM& vm, ByteBuffer bytes, HTML::Task::Source task_source)
+GC::Ref<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::VM& vm, ByteBuffer bytes, HTML::Task::Source task_source)
 {
     auto& realm = *vm.current_realm();
 
@@ -506,13 +506,13 @@ JS::NonnullGCPtr<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::
     auto promise = WebIDL::create_promise(realm);
 
     // 2. Run the following steps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(vm.heap(), [&vm, &realm, bytes = move(bytes), promise, task_source]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(vm.heap(), [&vm, &realm, bytes = move(bytes), promise, task_source]() mutable {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         // 1. Compile the WebAssembly module bytes and store the result as module.
         auto module_or_error = Detail::compile_a_webassembly_module(vm, move(bytes));
 
         // 2. Queue a task to perform the following steps. If taskSource was provided, queue the task on that task source.
-        HTML::queue_a_task(task_source, nullptr, nullptr, JS::create_heap_function(vm.heap(), [&realm, promise, module_or_error = move(module_or_error)]() mutable {
+        HTML::queue_a_task(task_source, nullptr, nullptr, GC::create_function(vm.heap(), [&realm, promise, module_or_error = move(module_or_error)]() mutable {
             HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
             auto& realm = HTML::relevant_realm(*promise->promise());
 
@@ -538,7 +538,7 @@ JS::NonnullGCPtr<WebIDL::Promise> asynchronously_compile_webassembly_module(JS::
 }
 
 // https://webassembly.github.io/spec/js-api/#asynchronously-instantiate-a-webassembly-module
-JS::NonnullGCPtr<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM& vm, JS::NonnullGCPtr<Module> module_object, JS::GCPtr<JS::Object> import_object)
+GC::Ref<WebIDL::Promise> asynchronously_instantiate_webassembly_module(JS::VM& vm, GC::Ref<Module> module_object, GC::Ptr<JS::Object> import_object)
 {
     auto& realm = *vm.current_realm();
 
@@ -554,7 +554,7 @@ JS::NonnullGCPtr<WebIDL::Promise> asynchronously_instantiate_webassembly_module(
 
     // 4. Run the following steps in parallel:
     //   1. Queue a task to perform the following steps: Note: Implementation-specific work may be performed here.
-    HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(vm.heap(), [&vm, &realm, promise, module, import_object]() {
+    HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(vm.heap(), [&vm, &realm, promise, module, import_object]() {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
         auto& realm = HTML::relevant_realm(*promise->promise());
 
@@ -581,7 +581,7 @@ JS::NonnullGCPtr<WebIDL::Promise> asynchronously_instantiate_webassembly_module(
 }
 
 // https://webassembly.github.io/spec/js-api/#instantiate-a-promise-of-a-module
-JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, JS::NonnullGCPtr<WebIDL::Promise> promise_of_module, JS::GCPtr<JS::Object> import_object)
+GC::Ref<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, GC::Ref<WebIDL::Promise> promise_of_module, GC::Ptr<JS::Object> import_object)
 {
     auto& realm = *vm.current_realm();
 
@@ -591,19 +591,19 @@ JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, JS::
     // FIXME: Spec should use react to promise here instead of separate upon fulfillment and upon rejection steps
 
     // 2. Upon fulfillment of promiseOfModule with value module:
-    auto fulfillment_steps = JS::create_heap_function(vm.heap(), [&vm, promise, import_object](JS::Value module_value) -> WebIDL::ExceptionOr<JS::Value> {
+    auto fulfillment_steps = GC::create_function(vm.heap(), [&vm, promise, import_object](JS::Value module_value) -> WebIDL::ExceptionOr<JS::Value> {
         VERIFY(module_value.is_object() && is<Module>(module_value.as_object()));
-        auto module = JS::NonnullGCPtr { static_cast<Module&>(module_value.as_object()) };
+        auto module = GC::Ref { static_cast<Module&>(module_value.as_object()) };
 
         // 1. Instantiate the WebAssembly module module importing importObject, and let innerPromise be the result.
         auto inner_promise = asynchronously_instantiate_webassembly_module(vm, module, import_object);
 
         // 2. Upon fulfillment of innerPromise with value instance.
-        auto instantiate_fulfillment_steps = JS::create_heap_function(vm.heap(), [promise, module](JS::Value instance_value) -> WebIDL::ExceptionOr<JS::Value> {
+        auto instantiate_fulfillment_steps = GC::create_function(vm.heap(), [promise, module](JS::Value instance_value) -> WebIDL::ExceptionOr<JS::Value> {
             auto& realm = HTML::relevant_realm(*promise->promise());
 
             VERIFY(instance_value.is_object() && is<Instance>(instance_value.as_object()));
-            auto instance = JS::NonnullGCPtr { static_cast<Instance&>(instance_value.as_object()) };
+            auto instance = GC::Ref { static_cast<Instance&>(instance_value.as_object()) };
 
             // 1. Let result be the WebAssemblyInstantiatedSource value «[ "module" → module, "instance" → instance ]».
             auto result = JS::Object::create(realm, nullptr);
@@ -617,7 +617,7 @@ JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, JS::
         });
 
         // 3. Upon rejection of innerPromise with reason reason.
-        auto instantiate_rejection_steps = JS::create_heap_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        auto instantiate_rejection_steps = GC::create_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             auto& realm = HTML::relevant_realm(*promise->promise());
 
             // 1. Reject promise with reason.
@@ -632,7 +632,7 @@ JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, JS::
     });
 
     // 3. Upon rejection of promiseOfModule with reason reason:
-    auto rejection_steps = JS::create_heap_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    auto rejection_steps = GC::create_function(vm.heap(), [promise](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         auto& realm = HTML::relevant_realm(*promise->promise());
 
         // 1. Reject promise with reason.
@@ -648,7 +648,7 @@ JS::NonnullGCPtr<WebIDL::Promise> instantiate_promise_of_module(JS::VM& vm, JS::
 }
 
 // https://webassembly.github.io/spec/web-api/index.html#compile-a-potential-webassembly-response
-JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM& vm, JS::NonnullGCPtr<WebIDL::Promise> source)
+GC::Ref<WebIDL::Promise> compile_potential_webassembly_response(JS::VM& vm, GC::Ref<WebIDL::Promise> source)
 {
     auto& realm = *vm.current_realm();
 
@@ -662,7 +662,7 @@ JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&
     auto return_value = WebIDL::create_promise(realm);
 
     // 2. Upon fulfillment of source with value unwrappedSource:
-    auto fulfillment_steps = JS::create_heap_function(vm.heap(), [&vm, return_value](JS::Value unwrapped_source) -> WebIDL::ExceptionOr<JS::Value> {
+    auto fulfillment_steps = GC::create_function(vm.heap(), [&vm, return_value](JS::Value unwrapped_source) -> WebIDL::ExceptionOr<JS::Value> {
         auto& realm = HTML::relevant_realm(*return_value->promise());
 
         // 1. Let response be unwrappedSource’s response.
@@ -708,7 +708,7 @@ JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&
         auto body_promise = body_promise_or_error.release_value();
 
         // 9. Upon fulfillment of bodyPromise with value bodyArrayBuffer:
-        auto body_fulfillment_steps = JS::create_heap_function(vm.heap(), [&vm, return_value](JS::Value body_array_buffer) -> WebIDL::ExceptionOr<JS::Value> {
+        auto body_fulfillment_steps = GC::create_function(vm.heap(), [&vm, return_value](JS::Value body_array_buffer) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. Let stableBytes be a copy of the bytes held by the buffer bodyArrayBuffer.
             VERIFY(body_array_buffer.is_object());
             auto stable_bytes = WebIDL::get_buffer_source_copy(body_array_buffer.as_object());
@@ -728,7 +728,7 @@ JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&
         });
 
         // 10. Upon rejection of bodyPromise with reason reason:
-        auto body_rejection_steps = JS::create_heap_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+        auto body_rejection_steps = GC::create_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
             // 1. Reject returnValue with reason.
             WebIDL::reject_promise(HTML::relevant_realm(*return_value->promise()), return_value, reason);
             return JS::js_undefined();
@@ -740,7 +740,7 @@ JS::NonnullGCPtr<WebIDL::Promise> compile_potential_webassembly_response(JS::VM&
     });
 
     // 3. Upon rejection of source with reason reason:
-    auto rejection_steps = JS::create_heap_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
+    auto rejection_steps = GC::create_function(vm.heap(), [return_value](JS::Value reason) -> WebIDL::ExceptionOr<JS::Value> {
         // 1. Reject returnValue with reason.
         WebIDL::reject_promise(HTML::relevant_realm(*return_value->promise()), return_value, reason);
 
diff --git a/Libraries/LibWeb/WebAssembly/WebAssembly.h b/Libraries/LibWeb/WebAssembly/WebAssembly.h
index 85a3a706c70..9c43ad9ed4f 100644
--- a/Libraries/LibWeb/WebAssembly/WebAssembly.h
+++ b/Libraries/LibWeb/WebAssembly/WebAssembly.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Optional.h>
+#include <LibGC/Root.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibJS/Runtime/Completion.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWasm/AbstractMachine/AbstractMachine.h>
@@ -21,13 +21,13 @@ namespace Web::WebAssembly {
 void visit_edges(JS::Object&, JS::Cell::Visitor&);
 void finalize(JS::Object&);
 
-bool validate(JS::VM&, JS::Handle<WebIDL::BufferSource>& bytes);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> compile(JS::VM&, JS::Handle<WebIDL::BufferSource>& bytes);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> compile_streaming(JS::VM&, JS::Handle<WebIDL::Promise> source);
+bool validate(JS::VM&, GC::Root<WebIDL::BufferSource>& bytes);
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile(JS::VM&, GC::Root<WebIDL::BufferSource>& bytes);
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> compile_streaming(JS::VM&, GC::Root<WebIDL::Promise> source);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate(JS::VM&, JS::Handle<WebIDL::BufferSource>& bytes, Optional<JS::Handle<JS::Object>>& import_object);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate(JS::VM&, Module const& module_object, Optional<JS::Handle<JS::Object>>& import_object);
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> instantiate_streaming(JS::VM&, JS::Handle<WebIDL::Promise> source, Optional<JS::Handle<JS::Object>>& import_object);
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM&, GC::Root<WebIDL::BufferSource>& bytes, Optional<GC::Root<JS::Object>>& import_object);
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate(JS::VM&, Module const& module_object, Optional<GC::Root<JS::Object>>& import_object);
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> instantiate_streaming(JS::VM&, GC::Root<WebIDL::Promise> source, Optional<GC::Root<JS::Object>>& import_object);
 
 namespace Detail {
 struct CompiledWebAssemblyModule : public RefCounted<CompiledWebAssemblyModule> {
@@ -42,36 +42,36 @@ struct CompiledWebAssemblyModule : public RefCounted<CompiledWebAssemblyModule>
 class WebAssemblyCache {
 public:
     void add_compiled_module(NonnullRefPtr<CompiledWebAssemblyModule> module) { m_compiled_modules.append(module); }
-    void add_function_instance(Wasm::FunctionAddress address, JS::GCPtr<JS::NativeFunction> function) { m_function_instances.set(address, function); }
-    void add_imported_object(JS::GCPtr<JS::Object> object) { m_imported_objects.set(object); }
+    void add_function_instance(Wasm::FunctionAddress address, GC::Ptr<JS::NativeFunction> function) { m_function_instances.set(address, function); }
+    void add_imported_object(GC::Ptr<JS::Object> object) { m_imported_objects.set(object); }
     void add_extern_value(Wasm::ExternAddress address, JS::Value value) { m_extern_values.set(address, value); }
 
-    Optional<JS::GCPtr<JS::NativeFunction>> get_function_instance(Wasm::FunctionAddress address) { return m_function_instances.get(address); }
+    Optional<GC::Ptr<JS::NativeFunction>> get_function_instance(Wasm::FunctionAddress address) { return m_function_instances.get(address); }
     Optional<JS::Value> get_extern_value(Wasm::ExternAddress address) { return m_extern_values.get(address); }
 
-    HashMap<Wasm::FunctionAddress, JS::GCPtr<JS::NativeFunction>> function_instances() const { return m_function_instances; }
+    HashMap<Wasm::FunctionAddress, GC::Ptr<JS::NativeFunction>> function_instances() const { return m_function_instances; }
     HashMap<Wasm::ExternAddress, JS::Value> extern_values() const { return m_extern_values; }
-    HashTable<JS::GCPtr<JS::Object>> imported_objects() const { return m_imported_objects; }
+    HashTable<GC::Ptr<JS::Object>> imported_objects() const { return m_imported_objects; }
     Wasm::AbstractMachine& abstract_machine() { return m_abstract_machine; }
 
 private:
-    HashMap<Wasm::FunctionAddress, JS::GCPtr<JS::NativeFunction>> m_function_instances;
+    HashMap<Wasm::FunctionAddress, GC::Ptr<JS::NativeFunction>> m_function_instances;
     HashMap<Wasm::ExternAddress, JS::Value> m_extern_values;
     Vector<NonnullRefPtr<CompiledWebAssemblyModule>> m_compiled_modules;
-    HashTable<JS::GCPtr<JS::Object>> m_imported_objects;
+    HashTable<GC::Ptr<JS::Object>> m_imported_objects;
     Wasm::AbstractMachine m_abstract_machine;
 };
 
 WebAssemblyCache& get_cache(JS::Realm&);
 
-JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS::VM&, Wasm::Module const&, JS::GCPtr<JS::Object> import_object);
+JS::ThrowCompletionOr<NonnullOwnPtr<Wasm::ModuleInstance>> instantiate_module(JS::VM&, Wasm::Module const&, GC::Ptr<JS::Object> import_object);
 JS::ThrowCompletionOr<NonnullRefPtr<CompiledWebAssemblyModule>> compile_a_webassembly_module(JS::VM&, ByteBuffer);
 JS::NativeFunction* create_native_function(JS::VM&, Wasm::FunctionAddress address, ByteString const& name, Instance* instance = nullptr);
 JS::ThrowCompletionOr<Wasm::Value> to_webassembly_value(JS::VM&, JS::Value value, Wasm::ValueType const& type);
 Wasm::Value default_webassembly_value(JS::VM&, Wasm::ValueType type);
 JS::Value to_js_value(JS::VM&, Wasm::Value& wasm_value, Wasm::ValueType type);
 
-extern HashMap<JS::GCPtr<JS::Object>, WebAssemblyCache> s_caches;
+extern HashMap<GC::Ptr<JS::Object>, WebAssemblyCache> s_caches;
 
 }
 
diff --git a/Libraries/LibWeb/WebAudio/AudioBuffer.cpp b/Libraries/LibWeb/WebAudio/AudioBuffer.cpp
index 8213e500090..6a3d88f2064 100644
--- a/Libraries/LibWeb/WebAudio/AudioBuffer.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioBuffer.cpp
@@ -16,14 +16,14 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioBuffer);
+GC_DEFINE_ALLOCATOR(AudioBuffer);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> AudioBuffer::create(JS::Realm& realm, WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate)
+WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> AudioBuffer::create(JS::Realm& realm, WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate)
 {
     return construct_impl(realm, { number_of_channels, length, sample_rate });
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> AudioBuffer::construct_impl(JS::Realm& realm, AudioBufferOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> AudioBuffer::construct_impl(JS::Realm& realm, AudioBufferOptions const& options)
 {
     // 1. If any of the values in options lie outside its nominal range, throw a NotSupportedError exception and abort the following steps.
     TRY(BaseAudioContext::verify_audio_options_inside_nominal_range(realm, options.number_of_channels, options.length, options.sample_rate));
@@ -73,7 +73,7 @@ WebIDL::UnsignedLong AudioBuffer::number_of_channels() const
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffer-getchanneldata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Float32Array>> AudioBuffer::get_channel_data(WebIDL::UnsignedLong channel) const
+WebIDL::ExceptionOr<GC::Ref<JS::Float32Array>> AudioBuffer::get_channel_data(WebIDL::UnsignedLong channel) const
 {
     if (channel >= m_channels.size())
         return WebIDL::IndexSizeError::create(realm(), "Channel index is out of range"_string);
@@ -82,7 +82,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Float32Array>> AudioBuffer::get_channel
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffer-copyfromchannel
-WebIDL::ExceptionOr<void> AudioBuffer::copy_from_channel(JS::Handle<WebIDL::BufferSource> const& destination, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset) const
+WebIDL::ExceptionOr<void> AudioBuffer::copy_from_channel(GC::Root<WebIDL::BufferSource> const& destination, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset) const
 {
     // The copyFromChannel() method copies the samples from the specified channel of the AudioBuffer to the destination array.
     //
@@ -108,7 +108,7 @@ WebIDL::ExceptionOr<void> AudioBuffer::copy_from_channel(JS::Handle<WebIDL::Buff
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffer-copytochannel
-WebIDL::ExceptionOr<void> AudioBuffer::copy_to_channel(JS::Handle<WebIDL::BufferSource> const& source, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset)
+WebIDL::ExceptionOr<void> AudioBuffer::copy_to_channel(GC::Root<WebIDL::BufferSource> const& source, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset)
 {
     // The copyToChannel() method copies the samples to the specified channel of the AudioBuffer from the source array.
     //
diff --git a/Libraries/LibWeb/WebAudio/AudioBuffer.h b/Libraries/LibWeb/WebAudio/AudioBuffer.h
index 5b550dda19f..d98e367bbda 100644
--- a/Libraries/LibWeb/WebAudio/AudioBuffer.h
+++ b/Libraries/LibWeb/WebAudio/AudioBuffer.h
@@ -24,11 +24,11 @@ struct AudioBufferOptions {
 // https://webaudio.github.io/web-audio-api/#AudioBuffer
 class AudioBuffer final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AudioBuffer, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AudioBuffer);
+    GC_DECLARE_ALLOCATOR(AudioBuffer);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> create(JS::Realm&, WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> construct_impl(JS::Realm&, AudioBufferOptions const&);
+    static WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> create(JS::Realm&, WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
+    static WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> construct_impl(JS::Realm&, AudioBufferOptions const&);
 
     virtual ~AudioBuffer() override;
 
@@ -36,9 +36,9 @@ public:
     WebIDL::UnsignedLong length() const;
     double duration() const;
     WebIDL::UnsignedLong number_of_channels() const;
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<JS::Float32Array>> get_channel_data(WebIDL::UnsignedLong channel) const;
-    WebIDL::ExceptionOr<void> copy_from_channel(JS::Handle<WebIDL::BufferSource> const&, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset = 0) const;
-    WebIDL::ExceptionOr<void> copy_to_channel(JS::Handle<WebIDL::BufferSource> const&, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset = 0);
+    WebIDL::ExceptionOr<GC::Ref<JS::Float32Array>> get_channel_data(WebIDL::UnsignedLong channel) const;
+    WebIDL::ExceptionOr<void> copy_from_channel(GC::Root<WebIDL::BufferSource> const&, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset = 0) const;
+    WebIDL::ExceptionOr<void> copy_to_channel(GC::Root<WebIDL::BufferSource> const&, WebIDL::UnsignedLong channel_number, WebIDL::UnsignedLong buffer_offset = 0);
 
 private:
     explicit AudioBuffer(JS::Realm&, AudioBufferOptions const&);
@@ -51,7 +51,7 @@ private:
     //
     // https://webaudio.github.io/web-audio-api/#dom-audiobuffer-internal-data-slot
     // A data block holding the audio sample data.
-    Vector<JS::NonnullGCPtr<JS::Float32Array>> m_channels; // [[internal data]] / [[number_of_channels]]
+    Vector<GC::Ref<JS::Float32Array>> m_channels; // [[internal data]] / [[number_of_channels]]
 
     // https://webaudio.github.io/web-audio-api/#dom-audiobuffer-length-slot
     // The length of each channel of this AudioBuffer, which is an unsigned long.
diff --git a/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.cpp b/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.cpp
index 1c38059c0a6..b694cf8cece 100644
--- a/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioBufferSourceNode);
+GC_DEFINE_ALLOCATOR(AudioBufferSourceNode);
 
-AudioBufferSourceNode::AudioBufferSourceNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, AudioBufferSourceOptions const& options)
+AudioBufferSourceNode::AudioBufferSourceNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context, AudioBufferSourceOptions const& options)
     : AudioScheduledSourceNode(realm, context)
     , m_buffer(options.buffer)
     , m_playback_rate(AudioParam::create(realm, options.playback_rate, NumericLimits<float>::lowest(), NumericLimits<float>::max(), Bindings::AutomationRate::ARate))
@@ -29,26 +29,26 @@ AudioBufferSourceNode::AudioBufferSourceNode(JS::Realm& realm, JS::NonnullGCPtr<
 AudioBufferSourceNode::~AudioBufferSourceNode() = default;
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffersourcenode-buffer
-WebIDL::ExceptionOr<void> AudioBufferSourceNode::set_buffer(JS::GCPtr<AudioBuffer> buffer)
+WebIDL::ExceptionOr<void> AudioBufferSourceNode::set_buffer(GC::Ptr<AudioBuffer> buffer)
 {
     m_buffer = buffer;
     return {};
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffersourcenode-buffer
-JS::GCPtr<AudioBuffer> AudioBufferSourceNode::buffer() const
+GC::Ptr<AudioBuffer> AudioBufferSourceNode::buffer() const
 {
     return m_buffer;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffersourcenode-playbackrate
-JS::NonnullGCPtr<AudioParam> AudioBufferSourceNode::playback_rate() const
+GC::Ref<AudioParam> AudioBufferSourceNode::playback_rate() const
 {
     return m_playback_rate;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffersourcenode-detune
-JS::NonnullGCPtr<AudioParam> AudioBufferSourceNode::detune() const
+GC::Ref<AudioParam> AudioBufferSourceNode::detune() const
 {
     return m_detune;
 }
@@ -102,13 +102,13 @@ WebIDL::ExceptionOr<void> AudioBufferSourceNode::start(Optional<double> when, Op
     return {};
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> AudioBufferSourceNode::create(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, AudioBufferSourceOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> AudioBufferSourceNode::create(JS::Realm& realm, GC::Ref<BaseAudioContext> context, AudioBufferSourceOptions const& options)
 {
     return construct_impl(realm, context, options);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audiobuffersourcenode-audiobuffersourcenode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> AudioBufferSourceNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, AudioBufferSourceOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> AudioBufferSourceNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context, AudioBufferSourceOptions const& options)
 {
     // When the constructor is called with a BaseAudioContext c and an option object option, the user agent
     // MUST initialize the AudioNode this, with context and options as arguments.
diff --git a/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.h b/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.h
index c6cb9bbe412..69517bf5d7b 100644
--- a/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.h
+++ b/Libraries/LibWeb/WebAudio/AudioBufferSourceNode.h
@@ -15,7 +15,7 @@ namespace Web::WebAudio {
 
 // https://webaudio.github.io/web-audio-api/#AudioBufferSourceOptions
 struct AudioBufferSourceOptions {
-    JS::GCPtr<AudioBuffer> buffer;
+    GC::Ptr<AudioBuffer> buffer;
     float detune { 0 };
     bool loop { false };
     double loop_end { 0 };
@@ -26,15 +26,15 @@ struct AudioBufferSourceOptions {
 // https://webaudio.github.io/web-audio-api/#AudioBufferSourceNode
 class AudioBufferSourceNode : public AudioScheduledSourceNode {
     WEB_PLATFORM_OBJECT(AudioBufferSourceNode, AudioScheduledSourceNode);
-    JS_DECLARE_ALLOCATOR(AudioBufferSourceNode);
+    GC_DECLARE_ALLOCATOR(AudioBufferSourceNode);
 
 public:
     virtual ~AudioBufferSourceNode() override;
 
-    WebIDL::ExceptionOr<void> set_buffer(JS::GCPtr<AudioBuffer>);
-    JS::GCPtr<AudioBuffer> buffer() const;
-    JS::NonnullGCPtr<AudioParam> playback_rate() const;
-    JS::NonnullGCPtr<AudioParam> detune() const;
+    WebIDL::ExceptionOr<void> set_buffer(GC::Ptr<AudioBuffer>);
+    GC::Ptr<AudioBuffer> buffer() const;
+    GC::Ref<AudioParam> playback_rate() const;
+    GC::Ref<AudioParam> detune() const;
     WebIDL::ExceptionOr<void> set_loop(bool);
     bool loop() const;
     WebIDL::ExceptionOr<void> set_loop_start(double);
@@ -46,19 +46,19 @@ public:
 
     WebIDL::ExceptionOr<void> start(Optional<double>, Optional<double>, Optional<double>);
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> create(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, AudioBufferSourceOptions const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, AudioBufferSourceOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> create(JS::Realm&, GC::Ref<BaseAudioContext>, AudioBufferSourceOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, AudioBufferSourceOptions const& = {});
 
 protected:
-    AudioBufferSourceNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, AudioBufferSourceOptions const& = {});
+    AudioBufferSourceNode(JS::Realm&, GC::Ref<BaseAudioContext>, AudioBufferSourceOptions const& = {});
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
-    JS::GCPtr<AudioBuffer> m_buffer;
-    JS::NonnullGCPtr<AudioParam> m_playback_rate;
-    JS::NonnullGCPtr<AudioParam> m_detune;
+    GC::Ptr<AudioBuffer> m_buffer;
+    GC::Ref<AudioParam> m_playback_rate;
+    GC::Ref<AudioParam> m_detune;
     bool m_loop { false };
     double m_loop_start { 0.0 };
     double m_loop_end { 0.0 };
diff --git a/Libraries/LibWeb/WebAudio/AudioContext.cpp b/Libraries/LibWeb/WebAudio/AudioContext.cpp
index 39e452e19c3..d90ca6dec65 100644
--- a/Libraries/LibWeb/WebAudio/AudioContext.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioContext.cpp
@@ -15,10 +15,10 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioContext);
+GC_DEFINE_ALLOCATOR(AudioContext);
 
 // https://webaudio.github.io/web-audio-api/#dom-audiocontext-audiocontext
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioContext>> AudioContext::construct_impl(JS::Realm& realm, AudioContextOptions const& context_options)
+WebIDL::ExceptionOr<GC::Ref<AudioContext>> AudioContext::construct_impl(JS::Realm& realm, AudioContextOptions const& context_options)
 {
     return realm.create<AudioContext>(realm, context_options);
 }
@@ -72,7 +72,7 @@ AudioContext::AudioContext(JS::Realm& realm, AudioContextOptions const& context_
         BaseAudioContext::set_rendering_state(Bindings::AudioContextState::Running);
 
         // 5.3: queue a media element task to execute the following steps:
-        queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, this]() {
+        queue_a_media_element_task(GC::create_function(heap(), [&realm, this]() {
             // 5.3.1: Set the state attribute of the AudioContext to "running".
             BaseAudioContext::set_control_state(Bindings::AudioContextState::Running);
 
@@ -104,7 +104,7 @@ AudioTimestamp AudioContext::get_output_timestamp()
 }
 
 // https://www.w3.org/TR/webaudio/#dom-audiocontext-resume
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::resume()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> AudioContext::resume()
 {
     auto& realm = this->realm();
 
@@ -145,7 +145,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::resume()
     // 7.3: Start rendering the audio graph.
     if (!start_rendering_audio_graph()) {
         // 7.4: In case of failure, queue a media element task to execute the following steps:
-        queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, this]() {
+        queue_a_media_element_task(GC::create_function(heap(), [&realm, this]() {
             HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
             // 7.4.1: Reject all promises from [[pending resume promises]] in order, then clear [[pending resume promises]].
@@ -162,7 +162,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::resume()
     }
 
     // 7.5: queue a media element task to execute the following steps:
-    queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, promise, this]() {
+    queue_a_media_element_task(GC::create_function(heap(), [&realm, promise, this]() {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
         // 7.5.1: Resolve all promises from [[pending resume promises]] in order.
@@ -185,7 +185,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::resume()
             set_control_state(Bindings::AudioContextState::Running);
 
             // 7.5.4.2: queue a media element task to fire an event named statechange at the AudioContext.
-            queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, this]() {
+            queue_a_media_element_task(GC::create_function(heap(), [&realm, this]() {
                 this->dispatch_event(DOM::Event::create(realm, HTML::EventNames::statechange));
             }));
         }
@@ -196,7 +196,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::resume()
 }
 
 // https://www.w3.org/TR/webaudio/#dom-audiocontext-suspend
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::suspend()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> AudioContext::suspend()
 {
     auto& realm = this->realm();
 
@@ -232,7 +232,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::suspend()
     set_rendering_state(Bindings::AudioContextState::Suspended);
 
     // 7.3: queue a media element task to execute the following steps:
-    queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, promise, this]() {
+    queue_a_media_element_task(GC::create_function(heap(), [&realm, promise, this]() {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
         // 7.3.1: Resolve promise.
@@ -244,7 +244,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::suspend()
             set_control_state(Bindings::AudioContextState::Suspended);
 
             // 7.3.2.2: queue a media element task to fire an event named statechange at the AudioContext.
-            queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, this]() {
+            queue_a_media_element_task(GC::create_function(heap(), [&realm, this]() {
                 this->dispatch_event(DOM::Event::create(realm, HTML::EventNames::statechange));
             }));
         }
@@ -255,7 +255,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::suspend()
 }
 
 // https://www.w3.org/TR/webaudio/#dom-audiocontext-close
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::close()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> AudioContext::close()
 {
     auto& realm = this->realm();
 
@@ -287,7 +287,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> AudioContext::close()
     // FIXME: 5.3: If this control message is being run in a reaction to the document being unloaded, abort this algorithm.
 
     // 5.4: queue a media element task to execute the following steps:
-    queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, promise, this]() {
+    queue_a_media_element_task(GC::create_function(heap(), [&realm, promise, this]() {
         HTML::TemporaryExecutionContext context(realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes);
 
         // 5.4.1: Resolve promise.
diff --git a/Libraries/LibWeb/WebAudio/AudioContext.h b/Libraries/LibWeb/WebAudio/AudioContext.h
index 9c67c3656bb..7cdd8feecc0 100644
--- a/Libraries/LibWeb/WebAudio/AudioContext.h
+++ b/Libraries/LibWeb/WebAudio/AudioContext.h
@@ -25,19 +25,19 @@ struct AudioTimestamp {
 // https://webaudio.github.io/web-audio-api/#AudioContext
 class AudioContext final : public BaseAudioContext {
     WEB_PLATFORM_OBJECT(AudioContext, BaseAudioContext);
-    JS_DECLARE_ALLOCATOR(AudioContext);
+    GC_DECLARE_ALLOCATOR(AudioContext);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioContext>> construct_impl(JS::Realm&, AudioContextOptions const& context_options = {});
+    static WebIDL::ExceptionOr<GC::Ref<AudioContext>> construct_impl(JS::Realm&, AudioContextOptions const& context_options = {});
 
     virtual ~AudioContext() override;
 
     double base_latency() const { return m_base_latency; }
     double output_latency() const { return m_output_latency; }
     AudioTimestamp get_output_timestamp();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> resume();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> suspend();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> close();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> resume();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> suspend();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> close();
 
 private:
     explicit AudioContext(JS::Realm&, AudioContextOptions const& context_options);
@@ -49,7 +49,7 @@ private:
     double m_output_latency { 0 };
 
     bool m_allowed_to_start = true;
-    Vector<JS::NonnullGCPtr<WebIDL::Promise>> m_pending_resume_promises;
+    Vector<GC::Ref<WebIDL::Promise>> m_pending_resume_promises;
     bool m_suspended_by_user = false;
 
     bool start_rendering_audio_graph();
diff --git a/Libraries/LibWeb/WebAudio/AudioDestinationNode.cpp b/Libraries/LibWeb/WebAudio/AudioDestinationNode.cpp
index 814819ec3a5..869aa4f0c19 100644
--- a/Libraries/LibWeb/WebAudio/AudioDestinationNode.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioDestinationNode.cpp
@@ -15,9 +15,9 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioDestinationNode);
+GC_DEFINE_ALLOCATOR(AudioDestinationNode);
 
-AudioDestinationNode::AudioDestinationNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context)
+AudioDestinationNode::AudioDestinationNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context)
     : AudioNode(realm, context)
 {
 }
@@ -31,7 +31,7 @@ WebIDL::UnsignedLong AudioDestinationNode::max_channel_count()
     return 2;
 }
 
-JS::NonnullGCPtr<AudioDestinationNode> AudioDestinationNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context)
+GC::Ref<AudioDestinationNode> AudioDestinationNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context)
 {
     return realm.create<AudioDestinationNode>(realm, context);
 }
diff --git a/Libraries/LibWeb/WebAudio/AudioDestinationNode.h b/Libraries/LibWeb/WebAudio/AudioDestinationNode.h
index 0a1c1aad736..25cea0576c3 100644
--- a/Libraries/LibWeb/WebAudio/AudioDestinationNode.h
+++ b/Libraries/LibWeb/WebAudio/AudioDestinationNode.h
@@ -17,7 +17,7 @@ namespace Web::WebAudio {
 // https://webaudio.github.io/web-audio-api/#AudioDestinationNode
 class AudioDestinationNode : public AudioNode {
     WEB_PLATFORM_OBJECT(AudioDestinationNode, AudioNode);
-    JS_DECLARE_ALLOCATOR(AudioDestinationNode);
+    GC_DECLARE_ALLOCATOR(AudioDestinationNode);
 
 public:
     virtual ~AudioDestinationNode() override;
@@ -27,10 +27,10 @@ public:
     WebIDL::UnsignedLong number_of_outputs() override { return 1; }
     WebIDL::ExceptionOr<void> set_channel_count(WebIDL::UnsignedLong) override;
 
-    static JS::NonnullGCPtr<AudioDestinationNode> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>);
+    static GC::Ref<AudioDestinationNode> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>);
 
 protected:
-    AudioDestinationNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>);
+    AudioDestinationNode(JS::Realm&, GC::Ref<BaseAudioContext>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
diff --git a/Libraries/LibWeb/WebAudio/AudioListener.cpp b/Libraries/LibWeb/WebAudio/AudioListener.cpp
index 171e43152f8..5ff515d1575 100644
--- a/Libraries/LibWeb/WebAudio/AudioListener.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioListener.cpp
@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#include <LibJS/Heap/CellAllocator.h>
+#include <LibGC/CellAllocator.h>
 #include <LibWeb/Bindings/Intrinsics.h>
 #include <LibWeb/WebAudio/AudioListener.h>
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioListener);
+GC_DEFINE_ALLOCATOR(AudioListener);
 
 AudioListener::AudioListener(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
@@ -26,7 +26,7 @@ AudioListener::AudioListener(JS::Realm& realm)
 {
 }
 
-JS::NonnullGCPtr<AudioListener> AudioListener::create(JS::Realm& realm)
+GC::Ref<AudioListener> AudioListener::create(JS::Realm& realm)
 {
     return realm.create<AudioListener>(realm);
 }
diff --git a/Libraries/LibWeb/WebAudio/AudioListener.h b/Libraries/LibWeb/WebAudio/AudioListener.h
index ba4a361097a..9d44e3ac2bd 100644
--- a/Libraries/LibWeb/WebAudio/AudioListener.h
+++ b/Libraries/LibWeb/WebAudio/AudioListener.h
@@ -17,21 +17,21 @@ namespace Web::WebAudio {
 // https://webaudio.github.io/web-audio-api/#AudioListener
 class AudioListener final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AudioListener, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AudioListener);
+    GC_DECLARE_ALLOCATOR(AudioListener);
 
 public:
-    static JS::NonnullGCPtr<AudioListener> create(JS::Realm&);
+    static GC::Ref<AudioListener> create(JS::Realm&);
     virtual ~AudioListener() override;
 
-    JS::NonnullGCPtr<AudioParam> forward_x() const { return m_forward_x; }
-    JS::NonnullGCPtr<AudioParam> forward_y() const { return m_forward_y; }
-    JS::NonnullGCPtr<AudioParam> forward_z() const { return m_forward_z; }
-    JS::NonnullGCPtr<AudioParam> position_x() const { return m_position_x; }
-    JS::NonnullGCPtr<AudioParam> position_y() const { return m_position_y; }
-    JS::NonnullGCPtr<AudioParam> position_z() const { return m_position_z; }
-    JS::NonnullGCPtr<AudioParam> up_x() const { return m_up_x; }
-    JS::NonnullGCPtr<AudioParam> up_y() const { return m_up_y; }
-    JS::NonnullGCPtr<AudioParam> up_z() const { return m_up_z; }
+    GC::Ref<AudioParam> forward_x() const { return m_forward_x; }
+    GC::Ref<AudioParam> forward_y() const { return m_forward_y; }
+    GC::Ref<AudioParam> forward_z() const { return m_forward_z; }
+    GC::Ref<AudioParam> position_x() const { return m_position_x; }
+    GC::Ref<AudioParam> position_y() const { return m_position_y; }
+    GC::Ref<AudioParam> position_z() const { return m_position_z; }
+    GC::Ref<AudioParam> up_x() const { return m_up_x; }
+    GC::Ref<AudioParam> up_y() const { return m_up_y; }
+    GC::Ref<AudioParam> up_z() const { return m_up_z; }
 
     WebIDL::ExceptionOr<void> set_position(float x, float y, float z);
     WebIDL::ExceptionOr<void> set_orientation(float x, float y, float z, float x_up, float y_up, float z_up);
@@ -42,15 +42,15 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<AudioParam> m_forward_x;
-    JS::NonnullGCPtr<AudioParam> m_forward_y;
-    JS::NonnullGCPtr<AudioParam> m_forward_z;
-    JS::NonnullGCPtr<AudioParam> m_position_x;
-    JS::NonnullGCPtr<AudioParam> m_position_y;
-    JS::NonnullGCPtr<AudioParam> m_position_z;
-    JS::NonnullGCPtr<AudioParam> m_up_x;
-    JS::NonnullGCPtr<AudioParam> m_up_y;
-    JS::NonnullGCPtr<AudioParam> m_up_z;
+    GC::Ref<AudioParam> m_forward_x;
+    GC::Ref<AudioParam> m_forward_y;
+    GC::Ref<AudioParam> m_forward_z;
+    GC::Ref<AudioParam> m_position_x;
+    GC::Ref<AudioParam> m_position_y;
+    GC::Ref<AudioParam> m_position_z;
+    GC::Ref<AudioParam> m_up_x;
+    GC::Ref<AudioParam> m_up_y;
+    GC::Ref<AudioParam> m_up_z;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAudio/AudioNode.cpp b/Libraries/LibWeb/WebAudio/AudioNode.cpp
index a19104e4832..13b27f355b3 100644
--- a/Libraries/LibWeb/WebAudio/AudioNode.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioNode.cpp
@@ -10,9 +10,9 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioNode);
+GC_DEFINE_ALLOCATOR(AudioNode);
 
-AudioNode::AudioNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context)
+AudioNode::AudioNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context)
     : DOM::EventTarget(realm)
     , m_context(context)
 
@@ -48,7 +48,7 @@ WebIDL::ExceptionOr<void> AudioNode::initialize_audio_node_options(AudioNodeOpti
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-connect
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioNode>> AudioNode::connect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input)
+WebIDL::ExceptionOr<GC::Ref<AudioNode>> AudioNode::connect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input)
 {
     // There can only be one connection between a given output of one specific node and a given input of another specific node.
     // Multiple connections with the same termini are ignored.
@@ -65,7 +65,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioNode>> AudioNode::connect(JS::NonnullG
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-connect-destinationparam-output
-void AudioNode::connect(JS::NonnullGCPtr<AudioParam> destination_param, WebIDL::UnsignedLong output)
+void AudioNode::connect(GC::Ref<AudioParam> destination_param, WebIDL::UnsignedLong output)
 {
     (void)destination_param;
     (void)output;
@@ -86,14 +86,14 @@ void AudioNode::disconnect(WebIDL::UnsignedLong output)
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-disconnect-destinationnode
-void AudioNode::disconnect(JS::NonnullGCPtr<AudioNode> destination_node)
+void AudioNode::disconnect(GC::Ref<AudioNode> destination_node)
 {
     (void)destination_node;
     dbgln("FIXME: Implement AudioNode::disconnect(destination_node)");
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-disconnect-destinationnode-output
-void AudioNode::disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output)
+void AudioNode::disconnect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output)
 {
     (void)destination_node;
     (void)output;
@@ -101,7 +101,7 @@ void AudioNode::disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL:
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-disconnect-destinationnode-output-input
-void AudioNode::disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input)
+void AudioNode::disconnect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input)
 {
     (void)destination_node;
     (void)output;
@@ -110,14 +110,14 @@ void AudioNode::disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL:
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-disconnect-destinationparam
-void AudioNode::disconnect(JS::NonnullGCPtr<AudioParam> destination_param)
+void AudioNode::disconnect(GC::Ref<AudioParam> destination_param)
 {
     (void)destination_param;
     dbgln("FIXME: Implement AudioNode::disconnect(destination_param)");
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audionode-disconnect-destinationparam-output
-void AudioNode::disconnect(JS::NonnullGCPtr<AudioParam> destination_param, WebIDL::UnsignedLong output)
+void AudioNode::disconnect(GC::Ref<AudioParam> destination_param, WebIDL::UnsignedLong output)
 {
     (void)destination_param;
     (void)output;
diff --git a/Libraries/LibWeb/WebAudio/AudioNode.h b/Libraries/LibWeb/WebAudio/AudioNode.h
index fa63a679351..4818e7cbe99 100644
--- a/Libraries/LibWeb/WebAudio/AudioNode.h
+++ b/Libraries/LibWeb/WebAudio/AudioNode.h
@@ -31,24 +31,24 @@ struct AudioNodeDefaultOptions {
 // https://webaudio.github.io/web-audio-api/#AudioNode
 class AudioNode : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(AudioNode, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(AudioNode);
+    GC_DECLARE_ALLOCATOR(AudioNode);
 
 public:
     virtual ~AudioNode() override;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioNode>> connect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output = 0, WebIDL::UnsignedLong input = 0);
-    void connect(JS::NonnullGCPtr<AudioParam> destination_param, WebIDL::UnsignedLong output = 0);
+    WebIDL::ExceptionOr<GC::Ref<AudioNode>> connect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output = 0, WebIDL::UnsignedLong input = 0);
+    void connect(GC::Ref<AudioParam> destination_param, WebIDL::UnsignedLong output = 0);
 
     void disconnect();
     void disconnect(WebIDL::UnsignedLong output);
-    void disconnect(JS::NonnullGCPtr<AudioNode> destination_node);
-    void disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output);
-    void disconnect(JS::NonnullGCPtr<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input);
-    void disconnect(JS::NonnullGCPtr<AudioParam> destination_param);
-    void disconnect(JS::NonnullGCPtr<AudioParam> destination_param, WebIDL::UnsignedLong output);
+    void disconnect(GC::Ref<AudioNode> destination_node);
+    void disconnect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output);
+    void disconnect(GC::Ref<AudioNode> destination_node, WebIDL::UnsignedLong output, WebIDL::UnsignedLong input);
+    void disconnect(GC::Ref<AudioParam> destination_param);
+    void disconnect(GC::Ref<AudioParam> destination_param, WebIDL::UnsignedLong output);
 
     // https://webaudio.github.io/web-audio-api/#dom-audionode-context
-    JS::NonnullGCPtr<BaseAudioContext const> context() const
+    GC::Ref<BaseAudioContext const> context() const
     {
         // The BaseAudioContext which owns this AudioNode.
         return m_context;
@@ -71,13 +71,13 @@ public:
     WebIDL::ExceptionOr<void> initialize_audio_node_options(AudioNodeOptions const& given_options, AudioNodeDefaultOptions const& default_options);
 
 protected:
-    AudioNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>);
+    AudioNode(JS::Realm&, GC::Ref<BaseAudioContext>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
-    JS::NonnullGCPtr<BaseAudioContext> m_context;
+    GC::Ref<BaseAudioContext> m_context;
     WebIDL::UnsignedLong m_channel_count { 2 };
     Bindings::ChannelCountMode m_channel_count_mode { Bindings::ChannelCountMode::Max };
     Bindings::ChannelInterpretation m_channel_interpretation { Bindings::ChannelInterpretation::Speakers };
diff --git a/Libraries/LibWeb/WebAudio/AudioParam.cpp b/Libraries/LibWeb/WebAudio/AudioParam.cpp
index ccf6f2e3713..7ed53fa5098 100644
--- a/Libraries/LibWeb/WebAudio/AudioParam.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioParam.cpp
@@ -11,7 +11,7 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioParam);
+GC_DEFINE_ALLOCATOR(AudioParam);
 
 AudioParam::AudioParam(JS::Realm& realm, float default_value, float min_value, float max_value, Bindings::AutomationRate automation_rate)
     : Bindings::PlatformObject(realm)
@@ -23,7 +23,7 @@ AudioParam::AudioParam(JS::Realm& realm, float default_value, float min_value, f
 {
 }
 
-JS::NonnullGCPtr<AudioParam> AudioParam::create(JS::Realm& realm, float default_value, float min_value, float max_value, Bindings::AutomationRate automation_rate)
+GC::Ref<AudioParam> AudioParam::create(JS::Realm& realm, float default_value, float min_value, float max_value, Bindings::AutomationRate automation_rate)
 {
     return realm.create<AudioParam>(realm, default_value, min_value, max_value, automation_rate);
 }
@@ -78,16 +78,16 @@ float AudioParam::max_value() const
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-setvalueattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::set_value_at_time(float value, double start_time)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::set_value_at_time(float value, double start_time)
 {
     (void)value;
     (void)start_time;
     dbgln("FIXME: Implement AudioParam::set_value_at_time");
-    return JS::NonnullGCPtr<AudioParam> { *this };
+    return GC::Ref<AudioParam> { *this };
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-linearramptovalueattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::linear_ramp_to_value_at_time(float value, double end_time)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::linear_ramp_to_value_at_time(float value, double end_time)
 {
     (void)value;
     (void)end_time;
@@ -95,7 +95,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::linear_ramp_to_val
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-exponentialramptovalueattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::exponential_ramp_to_value_at_time(float value, double end_time)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::exponential_ramp_to_value_at_time(float value, double end_time)
 {
     (void)value;
     (void)end_time;
@@ -103,7 +103,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::exponential_ramp_t
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-settargetattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::set_target_at_time(float target, double start_time, float time_constant)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::set_target_at_time(float target, double start_time, float time_constant)
 {
     (void)target;
     (void)start_time;
@@ -112,7 +112,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::set_target_at_time
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-setvaluecurveattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::set_value_curve_at_time(Span<float> values, double start_time, double duration)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::set_value_curve_at_time(Span<float> values, double start_time, double duration)
 {
     (void)values;
     (void)start_time;
@@ -121,14 +121,14 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::set_value_curve_at
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-cancelscheduledvalues
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::cancel_scheduled_values(double cancel_time)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::cancel_scheduled_values(double cancel_time)
 {
     (void)cancel_time;
     return WebIDL::NotSupportedError::create(realm(), "FIXME: Implement AudioParam::cancel_scheduled_values"_string);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioparam-cancelandholdattime
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> AudioParam::cancel_and_hold_at_time(double cancel_time)
+WebIDL::ExceptionOr<GC::Ref<AudioParam>> AudioParam::cancel_and_hold_at_time(double cancel_time)
 {
     (void)cancel_time;
     return WebIDL::NotSupportedError::create(realm(), "FIXME: Implement AudioParam::cancel_and_hold_at_time"_string);
diff --git a/Libraries/LibWeb/WebAudio/AudioParam.h b/Libraries/LibWeb/WebAudio/AudioParam.h
index 7d5e10f74da..6d8a66a0efe 100644
--- a/Libraries/LibWeb/WebAudio/AudioParam.h
+++ b/Libraries/LibWeb/WebAudio/AudioParam.h
@@ -15,10 +15,10 @@ namespace Web::WebAudio {
 // https://webaudio.github.io/web-audio-api/#AudioParam
 class AudioParam final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(AudioParam, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(AudioParam);
+    GC_DECLARE_ALLOCATOR(AudioParam);
 
 public:
-    static JS::NonnullGCPtr<AudioParam> create(JS::Realm&, float default_value, float min_value, float max_value, Bindings::AutomationRate);
+    static GC::Ref<AudioParam> create(JS::Realm&, float default_value, float min_value, float max_value, Bindings::AutomationRate);
 
     virtual ~AudioParam() override;
 
@@ -32,13 +32,13 @@ public:
     float min_value() const;
     float max_value() const;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> set_value_at_time(float value, double start_time);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> linear_ramp_to_value_at_time(float value, double end_time);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> exponential_ramp_to_value_at_time(float value, double end_time);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> set_target_at_time(float target, double start_time, float time_constant);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> set_value_curve_at_time(Span<float> values, double start_time, double duration);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> cancel_scheduled_values(double cancel_time);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioParam>> cancel_and_hold_at_time(double cancel_time);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> set_value_at_time(float value, double start_time);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> linear_ramp_to_value_at_time(float value, double end_time);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> exponential_ramp_to_value_at_time(float value, double end_time);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> set_target_at_time(float target, double start_time, float time_constant);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> set_value_curve_at_time(Span<float> values, double start_time, double duration);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> cancel_scheduled_values(double cancel_time);
+    WebIDL::ExceptionOr<GC::Ref<AudioParam>> cancel_and_hold_at_time(double cancel_time);
 
 private:
     AudioParam(JS::Realm&, float default_value, float min_value, float max_value, Bindings::AutomationRate);
diff --git a/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.cpp b/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.cpp
index 23fcdfe660c..9d7653dd439 100644
--- a/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.cpp
+++ b/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.cpp
@@ -11,9 +11,9 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(AudioScheduledSourceNode);
+GC_DEFINE_ALLOCATOR(AudioScheduledSourceNode);
 
-AudioScheduledSourceNode::AudioScheduledSourceNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context)
+AudioScheduledSourceNode::AudioScheduledSourceNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context)
     : AudioNode(realm, context)
 {
 }
@@ -21,13 +21,13 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(JS::Realm& realm, JS::Nonnull
 AudioScheduledSourceNode::~AudioScheduledSourceNode() = default;
 
 // https://webaudio.github.io/web-audio-api/#dom-audioscheduledsourcenode-onended
-JS::GCPtr<WebIDL::CallbackType> AudioScheduledSourceNode::onended()
+GC::Ptr<WebIDL::CallbackType> AudioScheduledSourceNode::onended()
 {
     return event_handler_attribute(HTML::EventNames::ended);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-audioscheduledsourcenode-onended
-void AudioScheduledSourceNode::set_onended(JS::GCPtr<WebIDL::CallbackType> value)
+void AudioScheduledSourceNode::set_onended(GC::Ptr<WebIDL::CallbackType> value)
 {
     set_event_handler_attribute(HTML::EventNames::ended, value);
 }
diff --git a/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.h b/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.h
index 545398a3dde..66c10da9a7d 100644
--- a/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.h
+++ b/Libraries/LibWeb/WebAudio/AudioScheduledSourceNode.h
@@ -13,19 +13,19 @@ namespace Web::WebAudio {
 // https://webaudio.github.io/web-audio-api/#AudioScheduledSourceNode
 class AudioScheduledSourceNode : public AudioNode {
     WEB_PLATFORM_OBJECT(AudioScheduledSourceNode, AudioNode);
-    JS_DECLARE_ALLOCATOR(AudioScheduledSourceNode);
+    GC_DECLARE_ALLOCATOR(AudioScheduledSourceNode);
 
 public:
     virtual ~AudioScheduledSourceNode() override;
 
-    JS::GCPtr<WebIDL::CallbackType> onended();
-    void set_onended(JS::GCPtr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> onended();
+    void set_onended(GC::Ptr<WebIDL::CallbackType>);
 
     WebIDL::ExceptionOr<void> start(double when = 0);
     WebIDL::ExceptionOr<void> stop(double when = 0);
 
 protected:
-    AudioScheduledSourceNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>);
+    AudioScheduledSourceNode(JS::Realm&, GC::Ref<BaseAudioContext>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
diff --git a/Libraries/LibWeb/WebAudio/BaseAudioContext.cpp b/Libraries/LibWeb/WebAudio/BaseAudioContext.cpp
index 9eda7e8ddcf..44cf2d86c8f 100644
--- a/Libraries/LibWeb/WebAudio/BaseAudioContext.cpp
+++ b/Libraries/LibWeb/WebAudio/BaseAudioContext.cpp
@@ -59,14 +59,14 @@ WebIDL::CallbackType* BaseAudioContext::onstatechange()
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createbiquadfilter
-WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> BaseAudioContext::create_biquad_filter()
+WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> BaseAudioContext::create_biquad_filter()
 {
     // Factory method for a BiquadFilterNode representing a second order filter which can be configured as one of several common filter types.
     return BiquadFilterNode::create(realm(), *this);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createbuffer
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> BaseAudioContext::create_buffer(WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate)
+WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> BaseAudioContext::create_buffer(WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate)
 {
     // Creates an AudioBuffer of the given size. The audio data in the buffer will be zero-initialized (silent).
     // A NotSupportedError exception MUST be thrown if any of the arguments is negative, zero, or outside its nominal range.
@@ -74,28 +74,28 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> BaseAudioContext::create_buff
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createbuffersource
-WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> BaseAudioContext::create_buffer_source()
+WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> BaseAudioContext::create_buffer_source()
 {
     // Factory method for a AudioBufferSourceNode.
     return AudioBufferSourceNode::create(realm(), *this);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createoscillator
-WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> BaseAudioContext::create_oscillator()
+WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> BaseAudioContext::create_oscillator()
 {
     // Factory method for an OscillatorNode.
     return OscillatorNode::create(realm(), *this);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createdynamicscompressor
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> BaseAudioContext::create_dynamics_compressor()
+WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> BaseAudioContext::create_dynamics_compressor()
 {
     // Factory method for a DynamicsCompressorNode.
     return DynamicsCompressorNode::create(realm(), *this);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-creategain
-WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> BaseAudioContext::create_gain()
+WebIDL::ExceptionOr<GC::Ref<GainNode>> BaseAudioContext::create_gain()
 {
     // Factory method for GainNode.
     return GainNode::create(realm(), *this);
@@ -121,14 +121,14 @@ WebIDL::ExceptionOr<void> BaseAudioContext::verify_audio_options_inside_nominal_
     return {};
 }
 
-void BaseAudioContext::queue_a_media_element_task(JS::NonnullGCPtr<JS::HeapFunction<void()>> steps)
+void BaseAudioContext::queue_a_media_element_task(GC::Ref<GC::Function<void()>> steps)
 {
     auto task = HTML::Task::create(vm(), m_media_element_event_task_source.source, HTML::current_principal_settings_object().responsible_document(), steps);
     HTML::main_thread_event_loop().task_queue().add(task);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-decodeaudiodata
-JS::NonnullGCPtr<WebIDL::Promise> BaseAudioContext::decode_audio_data(JS::Handle<WebIDL::BufferSource> audio_data, JS::GCPtr<WebIDL::CallbackType> success_callback, JS::GCPtr<WebIDL::CallbackType> error_callback)
+GC::Ref<WebIDL::Promise> BaseAudioContext::decode_audio_data(GC::Root<WebIDL::BufferSource> audio_data, GC::Ptr<WebIDL::CallbackType> success_callback, GC::Ptr<WebIDL::CallbackType> error_callback)
 {
     auto& realm = this->realm();
 
@@ -169,7 +169,7 @@ JS::NonnullGCPtr<WebIDL::Promise> BaseAudioContext::decode_audio_data(JS::Handle
 
         // 4.3. Queue a media element task to invoke errorCallback with error.
         if (error_callback) {
-            queue_a_media_element_task(JS::create_heap_function(heap(), [&realm, error_callback, error] {
+            queue_a_media_element_task(GC::create_function(heap(), [&realm, error_callback, error] {
                 auto completion = WebIDL::invoke_callback(*error_callback, {}, error);
                 if (completion.is_abrupt())
                     HTML::report_exception(completion, realm);
@@ -182,7 +182,7 @@ JS::NonnullGCPtr<WebIDL::Promise> BaseAudioContext::decode_audio_data(JS::Handle
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-decodeaudiodata
-void BaseAudioContext::queue_a_decoding_operation(JS::NonnullGCPtr<JS::PromiseCapability> promise, [[maybe_unused]] JS::Handle<WebIDL::BufferSource> audio_data, JS::GCPtr<WebIDL::CallbackType> success_callback, JS::GCPtr<WebIDL::CallbackType> error_callback)
+void BaseAudioContext::queue_a_decoding_operation(GC::Ref<JS::PromiseCapability> promise, [[maybe_unused]] GC::Root<WebIDL::BufferSource> audio_data, GC::Ptr<WebIDL::CallbackType> success_callback, GC::Ptr<WebIDL::CallbackType> error_callback)
 {
     auto& realm = this->realm();
 
@@ -208,7 +208,7 @@ void BaseAudioContext::queue_a_decoding_operation(JS::NonnullGCPtr<JS::PromiseCa
     // 4. If can decode is false,
     if (!can_decode) {
         // queue a media element task to execute the following steps:
-        queue_a_media_element_task(JS::create_heap_function(heap(), [this, &realm, promise, error_callback] {
+        queue_a_media_element_task(GC::create_function(heap(), [this, &realm, promise, error_callback] {
             // 4.1. Let error be a DOMException whose name is EncodingError.
             auto error = WebIDL::EncodingError::create(realm, "Unable to decode."_string);
 
diff --git a/Libraries/LibWeb/WebAudio/BaseAudioContext.h b/Libraries/LibWeb/WebAudio/BaseAudioContext.h
index 4b8b14862db..207122f2846 100644
--- a/Libraries/LibWeb/WebAudio/BaseAudioContext.h
+++ b/Libraries/LibWeb/WebAudio/BaseAudioContext.h
@@ -36,10 +36,10 @@ public:
     static constexpr float MIN_SAMPLE_RATE { 8000 };
     static constexpr float MAX_SAMPLE_RATE { 192000 };
 
-    JS::NonnullGCPtr<AudioDestinationNode> destination() const { return m_destination; }
+    GC::Ref<AudioDestinationNode> destination() const { return m_destination; }
     float sample_rate() const { return m_sample_rate; }
     double current_time() const { return m_current_time; }
-    JS::NonnullGCPtr<AudioListener> listener() const { return m_listener; }
+    GC::Ref<AudioListener> listener() const { return m_listener; }
     Bindings::AudioContextState state() const { return m_control_thread_state; }
 
     // https://webaudio.github.io/web-audio-api/#--nyquist-frequency
@@ -54,33 +54,33 @@ public:
 
     static WebIDL::ExceptionOr<void> verify_audio_options_inside_nominal_range(JS::Realm&, WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> create_biquad_filter();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBuffer>> create_buffer(WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<AudioBufferSourceNode>> create_buffer_source();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> create_oscillator();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> create_dynamics_compressor();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> create_gain();
+    WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> create_biquad_filter();
+    WebIDL::ExceptionOr<GC::Ref<AudioBuffer>> create_buffer(WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
+    WebIDL::ExceptionOr<GC::Ref<AudioBufferSourceNode>> create_buffer_source();
+    WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> create_oscillator();
+    WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> create_dynamics_compressor();
+    WebIDL::ExceptionOr<GC::Ref<GainNode>> create_gain();
 
-    JS::NonnullGCPtr<WebIDL::Promise> decode_audio_data(JS::Handle<WebIDL::BufferSource>, JS::GCPtr<WebIDL::CallbackType>, JS::GCPtr<WebIDL::CallbackType>);
+    GC::Ref<WebIDL::Promise> decode_audio_data(GC::Root<WebIDL::BufferSource>, GC::Ptr<WebIDL::CallbackType>, GC::Ptr<WebIDL::CallbackType>);
 
 protected:
     explicit BaseAudioContext(JS::Realm&, float m_sample_rate = 0);
 
-    void queue_a_media_element_task(JS::NonnullGCPtr<JS::HeapFunction<void()>>);
+    void queue_a_media_element_task(GC::Ref<GC::Function<void()>>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<AudioDestinationNode> m_destination;
-    Vector<JS::NonnullGCPtr<WebIDL::Promise>> m_pending_promises;
+    GC::Ref<AudioDestinationNode> m_destination;
+    Vector<GC::Ref<WebIDL::Promise>> m_pending_promises;
 
 private:
-    void queue_a_decoding_operation(JS::NonnullGCPtr<JS::PromiseCapability>, JS::Handle<WebIDL::BufferSource>, JS::GCPtr<WebIDL::CallbackType>, JS::GCPtr<WebIDL::CallbackType>);
+    void queue_a_decoding_operation(GC::Ref<JS::PromiseCapability>, GC::Root<WebIDL::BufferSource>, GC::Ptr<WebIDL::CallbackType>, GC::Ptr<WebIDL::CallbackType>);
 
     float m_sample_rate { 0 };
     double m_current_time { 0 };
 
-    JS::NonnullGCPtr<AudioListener> m_listener;
+    GC::Ref<AudioListener> m_listener;
 
     Bindings::AudioContextState m_control_thread_state = Bindings::AudioContextState::Suspended;
     Bindings::AudioContextState m_rendering_thread_state = Bindings::AudioContextState::Suspended;
diff --git a/Libraries/LibWeb/WebAudio/BiquadFilterNode.cpp b/Libraries/LibWeb/WebAudio/BiquadFilterNode.cpp
index 1d4ba31c3f4..61cbded0068 100644
--- a/Libraries/LibWeb/WebAudio/BiquadFilterNode.cpp
+++ b/Libraries/LibWeb/WebAudio/BiquadFilterNode.cpp
@@ -13,9 +13,9 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(BiquadFilterNode);
+GC_DEFINE_ALLOCATOR(BiquadFilterNode);
 
-BiquadFilterNode::BiquadFilterNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, BiquadFilterOptions const& options)
+BiquadFilterNode::BiquadFilterNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context, BiquadFilterOptions const& options)
     : AudioNode(realm, context)
     , m_type(options.type)
     , m_frequency(AudioParam::create(realm, options.frequency, NumericLimits<float>::lowest(), NumericLimits<float>::max(), Bindings::AutomationRate::ARate))
@@ -40,31 +40,31 @@ Bindings::BiquadFilterType BiquadFilterNode::type() const
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-frequency
-JS::NonnullGCPtr<AudioParam> BiquadFilterNode::frequency() const
+GC::Ref<AudioParam> BiquadFilterNode::frequency() const
 {
     return m_frequency;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-detune
-JS::NonnullGCPtr<AudioParam> BiquadFilterNode::detune() const
+GC::Ref<AudioParam> BiquadFilterNode::detune() const
 {
     return m_detune;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-q
-JS::NonnullGCPtr<AudioParam> BiquadFilterNode::q() const
+GC::Ref<AudioParam> BiquadFilterNode::q() const
 {
     return m_q;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-gain
-JS::NonnullGCPtr<AudioParam> BiquadFilterNode::gain() const
+GC::Ref<AudioParam> BiquadFilterNode::gain() const
 {
     return m_gain;
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-getfrequencyresponse
-WebIDL::ExceptionOr<void> BiquadFilterNode::get_frequency_response(JS::Handle<WebIDL::BufferSource> const& frequency_hz, JS::Handle<WebIDL::BufferSource> const& mag_response, JS::Handle<WebIDL::BufferSource> const& phase_response)
+WebIDL::ExceptionOr<void> BiquadFilterNode::get_frequency_response(GC::Root<WebIDL::BufferSource> const& frequency_hz, GC::Root<WebIDL::BufferSource> const& mag_response, GC::Root<WebIDL::BufferSource> const& phase_response)
 {
     (void)frequency_hz;
     (void)mag_response;
@@ -73,13 +73,13 @@ WebIDL::ExceptionOr<void> BiquadFilterNode::get_frequency_response(JS::Handle<We
     return {};
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> BiquadFilterNode::create(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, BiquadFilterOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> BiquadFilterNode::create(JS::Realm& realm, GC::Ref<BaseAudioContext> context, BiquadFilterOptions const& options)
 {
     return construct_impl(realm, context, options);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-biquadfilternode-biquadfilternode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> BiquadFilterNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, BiquadFilterOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> BiquadFilterNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context, BiquadFilterOptions const& options)
 {
     // When the constructor is called with a BaseAudioContext c and an option object option, the user agent
     // MUST initialize the AudioNode this, with context and options as arguments.
diff --git a/Libraries/LibWeb/WebAudio/BiquadFilterNode.h b/Libraries/LibWeb/WebAudio/BiquadFilterNode.h
index f632713aaec..dfad7be8d9d 100644
--- a/Libraries/LibWeb/WebAudio/BiquadFilterNode.h
+++ b/Libraries/LibWeb/WebAudio/BiquadFilterNode.h
@@ -24,7 +24,7 @@ struct BiquadFilterOptions : AudioNodeOptions {
 // https://webaudio.github.io/web-audio-api/#BiquadFilterNode
 class BiquadFilterNode : public AudioNode {
     WEB_PLATFORM_OBJECT(BiquadFilterNode, AudioNode);
-    JS_DECLARE_ALLOCATOR(BiquadFilterNode);
+    GC_DECLARE_ALLOCATOR(BiquadFilterNode);
 
 public:
     virtual ~BiquadFilterNode() override;
@@ -34,27 +34,27 @@ public:
 
     void set_type(Bindings::BiquadFilterType);
     Bindings::BiquadFilterType type() const;
-    JS::NonnullGCPtr<AudioParam> frequency() const;
-    JS::NonnullGCPtr<AudioParam> detune() const;
-    JS::NonnullGCPtr<AudioParam> q() const;
-    JS::NonnullGCPtr<AudioParam> gain() const;
-    WebIDL::ExceptionOr<void> get_frequency_response(JS::Handle<WebIDL::BufferSource> const&, JS::Handle<WebIDL::BufferSource> const&, JS::Handle<WebIDL::BufferSource> const&);
+    GC::Ref<AudioParam> frequency() const;
+    GC::Ref<AudioParam> detune() const;
+    GC::Ref<AudioParam> q() const;
+    GC::Ref<AudioParam> gain() const;
+    WebIDL::ExceptionOr<void> get_frequency_response(GC::Root<WebIDL::BufferSource> const&, GC::Root<WebIDL::BufferSource> const&, GC::Root<WebIDL::BufferSource> const&);
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> create(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, BiquadFilterOptions const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<BiquadFilterNode>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, BiquadFilterOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> create(JS::Realm&, GC::Ref<BaseAudioContext>, BiquadFilterOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<BiquadFilterNode>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, BiquadFilterOptions const& = {});
 
 protected:
-    BiquadFilterNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, BiquadFilterOptions const& = {});
+    BiquadFilterNode(JS::Realm&, GC::Ref<BaseAudioContext>, BiquadFilterOptions const& = {});
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
     Bindings::BiquadFilterType m_type { Bindings::BiquadFilterType::Lowpass };
-    JS::NonnullGCPtr<AudioParam> m_frequency;
-    JS::NonnullGCPtr<AudioParam> m_detune;
-    JS::NonnullGCPtr<AudioParam> m_q;
-    JS::NonnullGCPtr<AudioParam> m_gain;
+    GC::Ref<AudioParam> m_frequency;
+    GC::Ref<AudioParam> m_detune;
+    GC::Ref<AudioParam> m_q;
+    GC::Ref<AudioParam> m_gain;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.cpp b/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.cpp
index bdc725bc337..9584c7c749c 100644
--- a/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.cpp
+++ b/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.cpp
@@ -11,17 +11,17 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(DynamicsCompressorNode);
+GC_DEFINE_ALLOCATOR(DynamicsCompressorNode);
 
 DynamicsCompressorNode::~DynamicsCompressorNode() = default;
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> DynamicsCompressorNode::create(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, DynamicsCompressorOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> DynamicsCompressorNode::create(JS::Realm& realm, GC::Ref<BaseAudioContext> context, DynamicsCompressorOptions const& options)
 {
     return construct_impl(realm, context, options);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-dynamicscompressornode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> DynamicsCompressorNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, DynamicsCompressorOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> DynamicsCompressorNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context, DynamicsCompressorOptions const& options)
 {
     // Create the node and allocate memory
     auto node = realm.create<DynamicsCompressorNode>(realm, context, options);
@@ -39,7 +39,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> DynamicsCompressor
     return node;
 }
 
-DynamicsCompressorNode::DynamicsCompressorNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, DynamicsCompressorOptions const& options)
+DynamicsCompressorNode::DynamicsCompressorNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context, DynamicsCompressorOptions const& options)
     : AudioNode(realm, context)
     , m_threshold(AudioParam::create(realm, options.threshold, -100, 0, Bindings::AutomationRate::KRate))
     , m_knee(AudioParam::create(realm, options.knee, 0, 40, Bindings::AutomationRate::KRate))
diff --git a/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.h b/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.h
index 30fad47a799..45eaa10f31b 100644
--- a/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.h
+++ b/Libraries/LibWeb/WebAudio/DynamicsCompressorNode.h
@@ -22,48 +22,48 @@ struct DynamicsCompressorOptions : AudioNodeOptions {
 // https://webaudio.github.io/web-audio-api/#DynamicsCompressorNode
 class DynamicsCompressorNode : public AudioNode {
     WEB_PLATFORM_OBJECT(DynamicsCompressorNode, AudioNode);
-    JS_DECLARE_ALLOCATOR(DynamicsCompressorNode);
+    GC_DECLARE_ALLOCATOR(DynamicsCompressorNode);
 
 public:
     virtual ~DynamicsCompressorNode() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> create(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, DynamicsCompressorOptions const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<DynamicsCompressorNode>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, DynamicsCompressorOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> create(JS::Realm&, GC::Ref<BaseAudioContext>, DynamicsCompressorOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<DynamicsCompressorNode>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, DynamicsCompressorOptions const& = {});
 
     WebIDL::UnsignedLong number_of_inputs() override { return 1; }
     WebIDL::UnsignedLong number_of_outputs() override { return 1; }
 
-    JS::NonnullGCPtr<AudioParam const> threshold() const { return m_threshold; }
-    JS::NonnullGCPtr<AudioParam const> knee() const { return m_knee; }
-    JS::NonnullGCPtr<AudioParam const> ratio() const { return m_ratio; }
-    JS::NonnullGCPtr<AudioParam const> attack() const { return m_attack; }
-    JS::NonnullGCPtr<AudioParam const> release() const { return m_release; }
+    GC::Ref<AudioParam const> threshold() const { return m_threshold; }
+    GC::Ref<AudioParam const> knee() const { return m_knee; }
+    GC::Ref<AudioParam const> ratio() const { return m_ratio; }
+    GC::Ref<AudioParam const> attack() const { return m_attack; }
+    GC::Ref<AudioParam const> release() const { return m_release; }
     float reduction() const { return m_reduction; }
 
     WebIDL::ExceptionOr<void> set_channel_count_mode(Bindings::ChannelCountMode) override;
     WebIDL::ExceptionOr<void> set_channel_count(WebIDL::UnsignedLong) override;
 
 protected:
-    DynamicsCompressorNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, DynamicsCompressorOptions const& = {});
+    DynamicsCompressorNode(JS::Realm&, GC::Ref<BaseAudioContext>, DynamicsCompressorOptions const& = {});
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-threshold
-    JS::NonnullGCPtr<AudioParam> m_threshold;
+    GC::Ref<AudioParam> m_threshold;
 
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-knee
-    JS::NonnullGCPtr<AudioParam> m_knee;
+    GC::Ref<AudioParam> m_knee;
 
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-ratio
-    JS::NonnullGCPtr<AudioParam> m_ratio;
+    GC::Ref<AudioParam> m_ratio;
 
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-attack
-    JS::NonnullGCPtr<AudioParam> m_attack;
+    GC::Ref<AudioParam> m_attack;
 
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-release
-    JS::NonnullGCPtr<AudioParam> m_release;
+    GC::Ref<AudioParam> m_release;
 
     // https://webaudio.github.io/web-audio-api/#dom-dynamicscompressornode-internal-reduction-slot
     float m_reduction { 0 }; // [[internal reduction]]
diff --git a/Libraries/LibWeb/WebAudio/GainNode.cpp b/Libraries/LibWeb/WebAudio/GainNode.cpp
index 6e4b6eb95db..69f2a6b935f 100644
--- a/Libraries/LibWeb/WebAudio/GainNode.cpp
+++ b/Libraries/LibWeb/WebAudio/GainNode.cpp
@@ -12,17 +12,17 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(GainNode);
+GC_DEFINE_ALLOCATOR(GainNode);
 
 GainNode::~GainNode() = default;
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> GainNode::create(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, GainOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<GainNode>> GainNode::create(JS::Realm& realm, GC::Ref<BaseAudioContext> context, GainOptions const& options)
 {
     return construct_impl(realm, context, options);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-gainnode-gainnode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> GainNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, GainOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<GainNode>> GainNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context, GainOptions const& options)
 {
     // Create the node and allocate memory
     auto node = realm.create<GainNode>(realm, context, options);
@@ -39,7 +39,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> GainNode::construct_impl(JS::Rea
     return node;
 }
 
-GainNode::GainNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, GainOptions const& options)
+GainNode::GainNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context, GainOptions const& options)
     : AudioNode(realm, context)
     , m_gain(AudioParam::create(realm, options.gain, NumericLimits<float>::lowest(), NumericLimits<float>::max(), Bindings::AutomationRate::ARate))
 {
diff --git a/Libraries/LibWeb/WebAudio/GainNode.h b/Libraries/LibWeb/WebAudio/GainNode.h
index 1e1020a435d..1bdd0b09abe 100644
--- a/Libraries/LibWeb/WebAudio/GainNode.h
+++ b/Libraries/LibWeb/WebAudio/GainNode.h
@@ -19,28 +19,28 @@ struct GainOptions : AudioNodeOptions {
 // https://webaudio.github.io/web-audio-api/#GainNode
 class GainNode : public AudioNode {
     WEB_PLATFORM_OBJECT(GainNode, AudioNode);
-    JS_DECLARE_ALLOCATOR(GainNode);
+    GC_DECLARE_ALLOCATOR(GainNode);
 
 public:
     virtual ~GainNode() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> create(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, GainOptions const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<GainNode>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, GainOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<GainNode>> create(JS::Realm&, GC::Ref<BaseAudioContext>, GainOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<GainNode>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, GainOptions const& = {});
 
     WebIDL::UnsignedLong number_of_inputs() override { return 1; }
     WebIDL::UnsignedLong number_of_outputs() override { return 1; }
 
-    JS::NonnullGCPtr<AudioParam const> gain() const { return m_gain; }
+    GC::Ref<AudioParam const> gain() const { return m_gain; }
 
 protected:
-    GainNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, GainOptions const& = {});
+    GainNode(JS::Realm&, GC::Ref<BaseAudioContext>, GainOptions const& = {});
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
 private:
     // https://webaudio.github.io/web-audio-api/#dom-gainnode-gain
-    JS::NonnullGCPtr<AudioParam> m_gain;
+    GC::Ref<AudioParam> m_gain;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAudio/OfflineAudioContext.cpp b/Libraries/LibWeb/WebAudio/OfflineAudioContext.cpp
index 0ac148601b1..5393eca4e9c 100644
--- a/Libraries/LibWeb/WebAudio/OfflineAudioContext.cpp
+++ b/Libraries/LibWeb/WebAudio/OfflineAudioContext.cpp
@@ -11,15 +11,15 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(OfflineAudioContext);
+GC_DEFINE_ALLOCATOR(OfflineAudioContext);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<OfflineAudioContext>> OfflineAudioContext::construct_impl(JS::Realm& realm, OfflineAudioContextOptions const& context_options)
+WebIDL::ExceptionOr<GC::Ref<OfflineAudioContext>> OfflineAudioContext::construct_impl(JS::Realm& realm, OfflineAudioContextOptions const& context_options)
 {
     return construct_impl(realm, context_options.number_of_channels, context_options.length, context_options.sample_rate);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocontext-offlineaudiocontext-numberofchannels-length-samplerate
-WebIDL::ExceptionOr<JS::NonnullGCPtr<OfflineAudioContext>> OfflineAudioContext::construct_impl(JS::Realm& realm,
+WebIDL::ExceptionOr<GC::Ref<OfflineAudioContext>> OfflineAudioContext::construct_impl(JS::Realm& realm,
     WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate)
 {
     // The OfflineAudioContext can be constructed with the same arguments as AudioContext.createBuffer.
@@ -32,17 +32,17 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<OfflineAudioContext>> OfflineAudioContext::
 OfflineAudioContext::~OfflineAudioContext() = default;
 
 // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocontext-startrendering
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> OfflineAudioContext::start_rendering()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> OfflineAudioContext::start_rendering()
 {
     return WebIDL::NotSupportedError::create(realm(), "FIXME: Implement OfflineAudioContext::start_rendering"_string);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> OfflineAudioContext::resume()
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> OfflineAudioContext::resume()
 {
     return WebIDL::NotSupportedError::create(realm(), "FIXME: Implement OfflineAudioContext::resume"_string);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> OfflineAudioContext::suspend(double suspend_time)
+WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> OfflineAudioContext::suspend(double suspend_time)
 {
     (void)suspend_time;
     return WebIDL::NotSupportedError::create(realm(), "FIXME: Implement OfflineAudioContext::suspend"_string);
@@ -56,13 +56,13 @@ WebIDL::UnsignedLong OfflineAudioContext::length() const
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocontext-oncomplete
-JS::GCPtr<WebIDL::CallbackType> OfflineAudioContext::oncomplete()
+GC::Ptr<WebIDL::CallbackType> OfflineAudioContext::oncomplete()
 {
     return event_handler_attribute(HTML::EventNames::complete);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocontext-oncomplete
-void OfflineAudioContext::set_oncomplete(JS::GCPtr<WebIDL::CallbackType> value)
+void OfflineAudioContext::set_oncomplete(GC::Ptr<WebIDL::CallbackType> value)
 {
     set_event_handler_attribute(HTML::EventNames::complete, value);
 }
diff --git a/Libraries/LibWeb/WebAudio/OfflineAudioContext.h b/Libraries/LibWeb/WebAudio/OfflineAudioContext.h
index 00e4c3842fa..63c6b8e0cc0 100644
--- a/Libraries/LibWeb/WebAudio/OfflineAudioContext.h
+++ b/Libraries/LibWeb/WebAudio/OfflineAudioContext.h
@@ -23,23 +23,23 @@ struct OfflineAudioContextOptions {
 // https://webaudio.github.io/web-audio-api/#OfflineAudioContext
 class OfflineAudioContext final : public BaseAudioContext {
     WEB_PLATFORM_OBJECT(OfflineAudioContext, BaseAudioContext);
-    JS_DECLARE_ALLOCATOR(OfflineAudioContext);
+    GC_DECLARE_ALLOCATOR(OfflineAudioContext);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<OfflineAudioContext>> construct_impl(JS::Realm&, OfflineAudioContextOptions const&);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<OfflineAudioContext>> construct_impl(JS::Realm&,
+    static WebIDL::ExceptionOr<GC::Ref<OfflineAudioContext>> construct_impl(JS::Realm&, OfflineAudioContextOptions const&);
+    static WebIDL::ExceptionOr<GC::Ref<OfflineAudioContext>> construct_impl(JS::Realm&,
         WebIDL::UnsignedLong number_of_channels, WebIDL::UnsignedLong length, float sample_rate);
 
     virtual ~OfflineAudioContext() override;
 
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> start_rendering();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> resume();
-    WebIDL::ExceptionOr<JS::NonnullGCPtr<WebIDL::Promise>> suspend(double suspend_time);
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> start_rendering();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> resume();
+    WebIDL::ExceptionOr<GC::Ref<WebIDL::Promise>> suspend(double suspend_time);
 
     WebIDL::UnsignedLong length() const;
 
-    JS::GCPtr<WebIDL::CallbackType> oncomplete();
-    void set_oncomplete(JS::GCPtr<WebIDL::CallbackType>);
+    GC::Ptr<WebIDL::CallbackType> oncomplete();
+    void set_oncomplete(GC::Ptr<WebIDL::CallbackType>);
 
 private:
     OfflineAudioContext(JS::Realm&, OfflineAudioContextOptions const&);
diff --git a/Libraries/LibWeb/WebAudio/OscillatorNode.cpp b/Libraries/LibWeb/WebAudio/OscillatorNode.cpp
index 272d220356c..78390794f85 100644
--- a/Libraries/LibWeb/WebAudio/OscillatorNode.cpp
+++ b/Libraries/LibWeb/WebAudio/OscillatorNode.cpp
@@ -12,17 +12,17 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(OscillatorNode);
+GC_DEFINE_ALLOCATOR(OscillatorNode);
 
 OscillatorNode::~OscillatorNode() = default;
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> OscillatorNode::create(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, OscillatorOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> OscillatorNode::create(JS::Realm& realm, GC::Ref<BaseAudioContext> context, OscillatorOptions const& options)
 {
     return construct_impl(realm, context, options);
 }
 
 // https://webaudio.github.io/web-audio-api/#dom-oscillatornode-oscillatornode
-WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> OscillatorNode::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, OscillatorOptions const& options)
+WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> OscillatorNode::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext> context, OscillatorOptions const& options)
 {
     // FIXME: Invoke "Initialize the AudioNode" steps.
     TRY(verify_valid_type(realm, options.type));
@@ -30,7 +30,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> OscillatorNode::construct_
     return node;
 }
 
-OscillatorNode::OscillatorNode(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext> context, OscillatorOptions const& options)
+OscillatorNode::OscillatorNode(JS::Realm& realm, GC::Ref<BaseAudioContext> context, OscillatorOptions const& options)
     : AudioScheduledSourceNode(realm, context)
     , m_frequency(AudioParam::create(realm, options.frequency, -context->nyquist_frequency(), context->nyquist_frequency(), Bindings::AutomationRate::ARate))
 {
diff --git a/Libraries/LibWeb/WebAudio/OscillatorNode.h b/Libraries/LibWeb/WebAudio/OscillatorNode.h
index 6bd32cac0f4..29f8feeb23c 100644
--- a/Libraries/LibWeb/WebAudio/OscillatorNode.h
+++ b/Libraries/LibWeb/WebAudio/OscillatorNode.h
@@ -16,29 +16,29 @@ struct OscillatorOptions : AudioNodeOptions {
     Bindings::OscillatorType type { Bindings::OscillatorType::Sine };
     float frequency { 440 };
     float detune { 0 };
-    JS::GCPtr<PeriodicWave> periodic_wave;
+    GC::Ptr<PeriodicWave> periodic_wave;
 };
 
 // https://webaudio.github.io/web-audio-api/#OscillatorNode
 class OscillatorNode : public AudioScheduledSourceNode {
     WEB_PLATFORM_OBJECT(OscillatorNode, AudioScheduledSourceNode);
-    JS_DECLARE_ALLOCATOR(OscillatorNode);
+    GC_DECLARE_ALLOCATOR(OscillatorNode);
 
 public:
     virtual ~OscillatorNode() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> create(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, OscillatorOptions const& = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<OscillatorNode>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, OscillatorOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> create(JS::Realm&, GC::Ref<BaseAudioContext>, OscillatorOptions const& = {});
+    static WebIDL::ExceptionOr<GC::Ref<OscillatorNode>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, OscillatorOptions const& = {});
 
     Bindings::OscillatorType type() const;
     WebIDL::ExceptionOr<void> set_type(Bindings::OscillatorType);
 
-    JS::NonnullGCPtr<AudioParam const> frequency() const { return m_frequency; }
+    GC::Ref<AudioParam const> frequency() const { return m_frequency; }
     WebIDL::UnsignedLong number_of_inputs() override { return 0; }
     WebIDL::UnsignedLong number_of_outputs() override { return 1; }
 
 protected:
-    OscillatorNode(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, OscillatorOptions const& = {});
+    OscillatorNode(JS::Realm&, GC::Ref<BaseAudioContext>, OscillatorOptions const& = {});
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
@@ -50,7 +50,7 @@ private:
     Bindings::OscillatorType m_type { Bindings::OscillatorType::Sine };
 
     // https://webaudio.github.io/web-audio-api/#dom-oscillatornode-frequency
-    JS::NonnullGCPtr<AudioParam> m_frequency;
+    GC::Ref<AudioParam> m_frequency;
 };
 
 }
diff --git a/Libraries/LibWeb/WebAudio/PeriodicWave.cpp b/Libraries/LibWeb/WebAudio/PeriodicWave.cpp
index 977db576333..354f050c6a3 100644
--- a/Libraries/LibWeb/WebAudio/PeriodicWave.cpp
+++ b/Libraries/LibWeb/WebAudio/PeriodicWave.cpp
@@ -11,10 +11,10 @@
 
 namespace Web::WebAudio {
 
-JS_DEFINE_ALLOCATOR(PeriodicWave);
+GC_DEFINE_ALLOCATOR(PeriodicWave);
 
 // https://webaudio.github.io/web-audio-api/#dom-periodicwave-periodicwave
-WebIDL::ExceptionOr<JS::NonnullGCPtr<PeriodicWave>> PeriodicWave::construct_impl(JS::Realm& realm, JS::NonnullGCPtr<BaseAudioContext>, PeriodicWaveOptions const&)
+WebIDL::ExceptionOr<GC::Ref<PeriodicWave>> PeriodicWave::construct_impl(JS::Realm& realm, GC::Ref<BaseAudioContext>, PeriodicWaveOptions const&)
 {
     return WebIDL::NotSupportedError::create(realm, "FIXME: Implement PeriodicWave::construct_impl"_string);
 }
diff --git a/Libraries/LibWeb/WebAudio/PeriodicWave.h b/Libraries/LibWeb/WebAudio/PeriodicWave.h
index 100e66ab0c8..2eb32f77a62 100644
--- a/Libraries/LibWeb/WebAudio/PeriodicWave.h
+++ b/Libraries/LibWeb/WebAudio/PeriodicWave.h
@@ -26,10 +26,10 @@ struct PeriodicWaveOptions : PeriodicWaveConstraints {
 // https://webaudio.github.io/web-audio-api/#PeriodicWave
 class PeriodicWave : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(PeriodicWave, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(PeriodicWave);
+    GC_DECLARE_ALLOCATOR(PeriodicWave);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<PeriodicWave>> construct_impl(JS::Realm&, JS::NonnullGCPtr<BaseAudioContext>, PeriodicWaveOptions const&);
+    static WebIDL::ExceptionOr<GC::Ref<PeriodicWave>> construct_impl(JS::Realm&, GC::Ref<BaseAudioContext>, PeriodicWaveOptions const&);
 
     virtual ~PeriodicWave() override;
 
diff --git a/Libraries/LibWeb/WebDriver/Actions.cpp b/Libraries/LibWeb/WebDriver/Actions.cpp
index 75d652b486e..e99ab6b822c 100644
--- a/Libraries/LibWeb/WebDriver/Actions.cpp
+++ b/Libraries/LibWeb/WebDriver/Actions.cpp
@@ -1271,8 +1271,8 @@ static ErrorOr<void, WebDriver::Error> dispatch_pointer_move_action(ActionObject
 
 // https://w3c.github.io/webdriver/#dfn-dispatch-actions-inner
 class ActionExecutor final : public JS::Cell {
-    JS_CELL(ActionExecutor, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ActionExecutor);
+    GC_CELL(ActionExecutor, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ActionExecutor);
 
 public:
     ActionExecutor(InputState& input_state, Vector<Vector<ActionObject>> actions_by_tick, HTML::BrowsingContext& browsing_context, ActionsOptions actions_options, OnActionsComplete on_complete)
@@ -1316,7 +1316,7 @@ public:
         m_timer = Core::Timer::create_single_shot(static_cast<int>(tick_duration.to_milliseconds()), [this]() {
             m_timer = nullptr;
 
-            HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(heap(), [this]() {
+            HTML::queue_a_task(HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(heap(), [this]() {
                 process_next_tick();
             }));
         });
@@ -1331,7 +1331,7 @@ private:
         visitor.visit(m_on_complete);
     }
 
-    JS::NonnullGCPtr<HTML::BrowsingContext> m_browsing_context;
+    GC::Ref<HTML::BrowsingContext> m_browsing_context;
 
     InputState& m_input_state;
     ActionsOptions m_actions_options;
@@ -1344,10 +1344,10 @@ private:
     RefPtr<Core::Timer> m_timer;
 };
 
-JS_DEFINE_ALLOCATOR(ActionExecutor);
+GC_DEFINE_ALLOCATOR(ActionExecutor);
 
 // https://w3c.github.io/webdriver/#dfn-dispatch-actions
-JS::NonnullGCPtr<JS::Cell> dispatch_actions(InputState& input_state, Vector<Vector<ActionObject>> actions_by_tick, HTML::BrowsingContext& browsing_context, ActionsOptions actions_options, OnActionsComplete on_complete)
+GC::Ref<JS::Cell> dispatch_actions(InputState& input_state, Vector<Vector<ActionObject>> actions_by_tick, HTML::BrowsingContext& browsing_context, ActionsOptions actions_options, OnActionsComplete on_complete)
 {
     // 1. Let token be a new unique identifier.
     auto token = MUST(Crypto::generate_random_uuid());
@@ -1466,7 +1466,7 @@ ErrorOr<void, WebDriver::Error> dispatch_tick_actions(InputState& input_state, R
 }
 
 // https://w3c.github.io/webdriver/#dfn-dispatch-a-list-of-actions
-JS::NonnullGCPtr<JS::Cell> dispatch_list_of_actions(InputState& input_state, Vector<ActionObject> actions, HTML::BrowsingContext& browsing_context, ActionsOptions actions_options, OnActionsComplete on_complete)
+GC::Ref<JS::Cell> dispatch_list_of_actions(InputState& input_state, Vector<ActionObject> actions, HTML::BrowsingContext& browsing_context, ActionsOptions actions_options, OnActionsComplete on_complete)
 {
     // 1. Let tick actions be the list «actions»
     // 2. Let actions by tick be the list «tick actions».
@@ -1478,7 +1478,7 @@ JS::NonnullGCPtr<JS::Cell> dispatch_list_of_actions(InputState& input_state, Vec
 }
 
 // https://w3c.github.io/webdriver/#dfn-dispatch-the-events-for-a-typeable-string
-static JS::NonnullGCPtr<JS::Cell> dispatch_the_events_for_a_typeable_string(Web::WebDriver::InputState& input_state, String const& input_id, Web::WebDriver::InputSource& source, StringView text, Web::HTML::BrowsingContext& browsing_context, Web::WebDriver::OnActionsComplete on_complete)
+static GC::Ref<JS::Cell> dispatch_the_events_for_a_typeable_string(Web::WebDriver::InputState& input_state, String const& input_id, Web::WebDriver::InputSource& source, StringView text, Web::HTML::BrowsingContext& browsing_context, Web::WebDriver::OnActionsComplete on_complete)
 {
     auto& input_source = source.get<Web::WebDriver::KeyInputSource>();
 
@@ -1551,7 +1551,7 @@ static JS::NonnullGCPtr<JS::Cell> dispatch_the_events_for_a_typeable_string(Web:
 }
 
 // https://w3c.github.io/webdriver/#dfn-dispatch-actions-for-a-string
-JS::NonnullGCPtr<JS::Cell> dispatch_actions_for_a_string(Web::WebDriver::InputState& input_state, String const& input_id, Web::WebDriver::InputSource& source, StringView text, Web::HTML::BrowsingContext& browsing_context, Web::WebDriver::OnActionsComplete on_complete)
+GC::Ref<JS::Cell> dispatch_actions_for_a_string(Web::WebDriver::InputState& input_state, String const& input_id, Web::WebDriver::InputSource& source, StringView text, Web::HTML::BrowsingContext& browsing_context, Web::WebDriver::OnActionsComplete on_complete)
 {
     // FIXME: 1. Let clusters be an array created by breaking text into extended grapheme clusters.
     // FIXME: 2. Let undo actions be an empty map.
@@ -1596,7 +1596,7 @@ JS::NonnullGCPtr<JS::Cell> dispatch_actions_for_a_string(Web::WebDriver::InputSt
 
     // 5. Dispatch the events for a typeable string with input state, input id and source, current typeable text, and
     //    browsing context.
-    return dispatch_the_events_for_a_typeable_string(input_state, input_id, source, text, browsing_context, JS::create_heap_function(browsing_context.heap(), [on_complete](Web::WebDriver::Response result) {
+    return dispatch_the_events_for_a_typeable_string(input_state, input_id, source, text, browsing_context, GC::create_function(browsing_context.heap(), [on_complete](Web::WebDriver::Response result) {
         // FIXME: 6. Try to clear the modifier key state with input state, input id, source, undo actions, and browsing context.
 
         on_complete->function()(move(result));
diff --git a/Libraries/LibWeb/WebDriver/Actions.h b/Libraries/LibWeb/WebDriver/Actions.h
index 3e93ff2ab76..7f144d2e929 100644
--- a/Libraries/LibWeb/WebDriver/Actions.h
+++ b/Libraries/LibWeb/WebDriver/Actions.h
@@ -11,8 +11,8 @@
 #include <AK/Time.h>
 #include <AK/Variant.h>
 #include <AK/Vector.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/PixelUnits.h>
 #include <LibWeb/UIEvents/MouseButton.h>
@@ -118,19 +118,19 @@ struct ActionObject {
 // https://w3c.github.io/webdriver/#dfn-actions-options
 struct ActionsOptions {
     using IsElementOrigin = bool (*)(JsonValue const&);
-    using GetElementOrigin = ErrorOr<JS::NonnullGCPtr<DOM::Element>, WebDriver::Error> (*)(HTML::BrowsingContext const&, StringView);
+    using GetElementOrigin = ErrorOr<GC::Ref<DOM::Element>, WebDriver::Error> (*)(HTML::BrowsingContext const&, StringView);
 
     IsElementOrigin is_element_origin { nullptr };
     GetElementOrigin get_element_origin { nullptr };
 };
 
-using OnActionsComplete = JS::NonnullGCPtr<JS::HeapFunction<void(Web::WebDriver::Response)>>;
+using OnActionsComplete = GC::Ref<GC::Function<void(Web::WebDriver::Response)>>;
 
 ErrorOr<Vector<Vector<ActionObject>>, WebDriver::Error> extract_an_action_sequence(InputState&, JsonValue const&, ActionsOptions const&);
 
-JS::NonnullGCPtr<JS::Cell> dispatch_actions(InputState&, Vector<Vector<ActionObject>>, HTML::BrowsingContext&, ActionsOptions, OnActionsComplete);
+GC::Ref<JS::Cell> dispatch_actions(InputState&, Vector<Vector<ActionObject>>, HTML::BrowsingContext&, ActionsOptions, OnActionsComplete);
 ErrorOr<void, WebDriver::Error> dispatch_tick_actions(InputState&, ReadonlySpan<ActionObject>, AK::Duration, HTML::BrowsingContext&, ActionsOptions const&);
-JS::NonnullGCPtr<JS::Cell> dispatch_list_of_actions(InputState&, Vector<ActionObject>, HTML::BrowsingContext&, ActionsOptions, OnActionsComplete);
-JS::NonnullGCPtr<JS::Cell> dispatch_actions_for_a_string(Web::WebDriver::InputState&, String const& input_id, Web::WebDriver::InputSource&, StringView text, Web::HTML::BrowsingContext&, Web::WebDriver::OnActionsComplete);
+GC::Ref<JS::Cell> dispatch_list_of_actions(InputState&, Vector<ActionObject>, HTML::BrowsingContext&, ActionsOptions, OnActionsComplete);
+GC::Ref<JS::Cell> dispatch_actions_for_a_string(Web::WebDriver::InputState&, String const& input_id, Web::WebDriver::InputSource&, StringView text, Web::HTML::BrowsingContext&, Web::WebDriver::OnActionsComplete);
 
 }
diff --git a/Libraries/LibWeb/WebDriver/Contexts.cpp b/Libraries/LibWeb/WebDriver/Contexts.cpp
index c0d6dcc34e2..14c907e19a3 100644
--- a/Libraries/LibWeb/WebDriver/Contexts.cpp
+++ b/Libraries/LibWeb/WebDriver/Contexts.cpp
@@ -44,7 +44,7 @@ JsonObject window_proxy_reference_object(HTML::WindowProxy const& window)
     return object;
 }
 
-static JS::GCPtr<HTML::Navigable> find_navigable_with_handle(StringView handle, bool should_be_top_level)
+static GC::Ptr<HTML::Navigable> find_navigable_with_handle(StringView handle, bool should_be_top_level)
 {
     for (auto* navigable : Web::HTML::all_navigables()) {
         if (navigable->is_top_level_traversable() != should_be_top_level)
@@ -69,7 +69,7 @@ bool represents_a_web_frame(JS::Value value)
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-web-frame
-ErrorOr<JS::NonnullGCPtr<HTML::WindowProxy>, WebDriver::Error> deserialize_web_frame(JS::Object const& object)
+ErrorOr<GC::Ref<HTML::WindowProxy>, WebDriver::Error> deserialize_web_frame(JS::Object const& object)
 {
     // 1. If object has no own property web frame identifier, return error with error code invalid argument.
     auto property = object.get(WEB_FRAME_IDENTIFIER);
@@ -104,7 +104,7 @@ bool represents_a_web_window(JS::Value value)
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-web-frame
-ErrorOr<JS::NonnullGCPtr<HTML::WindowProxy>, WebDriver::Error> deserialize_web_window(JS::Object const& object)
+ErrorOr<GC::Ref<HTML::WindowProxy>, WebDriver::Error> deserialize_web_window(JS::Object const& object)
 {
     // 1. If object has no own property web window identifier, return error with error code invalid argument.
     auto property = object.get(WEB_WINDOW_IDENTIFIER);
diff --git a/Libraries/LibWeb/WebDriver/Contexts.h b/Libraries/LibWeb/WebDriver/Contexts.h
index ab47caff8d3..0a35f966256 100644
--- a/Libraries/LibWeb/WebDriver/Contexts.h
+++ b/Libraries/LibWeb/WebDriver/Contexts.h
@@ -17,9 +17,9 @@ namespace Web::WebDriver {
 JsonObject window_proxy_reference_object(HTML::WindowProxy const&);
 
 bool represents_a_web_frame(JS::Value);
-ErrorOr<JS::NonnullGCPtr<HTML::WindowProxy>, WebDriver::Error> deserialize_web_frame(JS::Object const&);
+ErrorOr<GC::Ref<HTML::WindowProxy>, WebDriver::Error> deserialize_web_frame(JS::Object const&);
 
 bool represents_a_web_window(JS::Value);
-ErrorOr<JS::NonnullGCPtr<HTML::WindowProxy>, WebDriver::Error> deserialize_web_window(JS::Object const&);
+ErrorOr<GC::Ref<HTML::WindowProxy>, WebDriver::Error> deserialize_web_window(JS::Object const&);
 
 }
diff --git a/Libraries/LibWeb/WebDriver/ElementLocationStrategies.cpp b/Libraries/LibWeb/WebDriver/ElementLocationStrategies.cpp
index 30d5ca21a46..b36db86f602 100644
--- a/Libraries/LibWeb/WebDriver/ElementLocationStrategies.cpp
+++ b/Libraries/LibWeb/WebDriver/ElementLocationStrategies.cpp
@@ -15,7 +15,7 @@
 namespace Web::WebDriver {
 
 // https://w3c.github.io/webdriver/#css-selectors
-static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_css_selector(DOM::ParentNode& start_node, StringView selector)
+static ErrorOr<GC::Ref<DOM::NodeList>, Error> locate_element_by_css_selector(DOM::ParentNode& start_node, StringView selector)
 {
     // 1. Let elements be the result of calling querySelectorAll() with start node as this and selector as the argument.
     //    If this causes an exception to be thrown, return error with error code invalid selector.
@@ -28,7 +28,7 @@ static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_css_sel
 }
 
 // https://w3c.github.io/webdriver/#link-text
-static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_link_text(DOM::ParentNode& start_node, StringView selector)
+static ErrorOr<GC::Ref<DOM::NodeList>, Error> locate_element_by_link_text(DOM::ParentNode& start_node, StringView selector)
 {
     auto& realm = start_node.realm();
 
@@ -39,7 +39,7 @@ static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_link_te
         return Error::from_code(ErrorCode::UnknownError, "querySelectorAll() failed"sv);
 
     // 2. Let result be an empty NodeList.
-    Vector<JS::Handle<DOM::Node>> result;
+    Vector<GC::Root<DOM::Node>> result;
 
     // 3. For each element in elements:
     for (size_t i = 0; i < elements.value()->length(); ++i) {
@@ -61,7 +61,7 @@ static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_link_te
 }
 
 // https://w3c.github.io/webdriver/#partial-link-text
-static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_partial_link_text(DOM::ParentNode& start_node, StringView selector)
+static ErrorOr<GC::Ref<DOM::NodeList>, Error> locate_element_by_partial_link_text(DOM::ParentNode& start_node, StringView selector)
 {
     auto& realm = start_node.realm();
 
@@ -72,7 +72,7 @@ static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_partial
         return Error::from_code(ErrorCode::UnknownError, "querySelectorAll() failed"sv);
 
     // 2. Let result be an empty NodeList.
-    Vector<JS::Handle<DOM::Node>> result;
+    Vector<GC::Root<DOM::Node>> result;
 
     // 3. For each element in elements:
     for (size_t i = 0; i < elements.value()->length(); ++i) {
@@ -91,7 +91,7 @@ static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_partial
 }
 
 // https://w3c.github.io/webdriver/#tag-name
-static JS::NonnullGCPtr<DOM::NodeList> locate_element_by_tag_name(DOM::ParentNode& start_node, StringView selector)
+static GC::Ref<DOM::NodeList> locate_element_by_tag_name(DOM::ParentNode& start_node, StringView selector)
 {
     auto& realm = start_node.realm();
 
@@ -100,7 +100,7 @@ static JS::NonnullGCPtr<DOM::NodeList> locate_element_by_tag_name(DOM::ParentNod
     auto elements = start_node.get_elements_by_tag_name(MUST(FlyString::from_utf8(selector)));
 
     // FIXME: Having to convert this to a NodeList is a bit awkward.
-    Vector<JS::Handle<DOM::Node>> result;
+    Vector<GC::Root<DOM::Node>> result;
 
     for (size_t i = 0; i < elements->length(); ++i) {
         auto* element = elements->item(i);
@@ -111,7 +111,7 @@ static JS::NonnullGCPtr<DOM::NodeList> locate_element_by_tag_name(DOM::ParentNod
 }
 
 // https://w3c.github.io/webdriver/#xpath
-static ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> locate_element_by_x_path(DOM::ParentNode&, StringView)
+static ErrorOr<GC::Ref<DOM::NodeList>, Error> locate_element_by_x_path(DOM::ParentNode&, StringView)
 {
     return Error::from_code(ErrorCode::UnsupportedOperation, "Not implemented: locate element by XPath"sv);
 }
@@ -131,7 +131,7 @@ Optional<LocationStrategy> location_strategy_from_string(StringView type)
     return {};
 }
 
-ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> invoke_location_strategy(LocationStrategy type, DOM::ParentNode& start_node, StringView selector)
+ErrorOr<GC::Ref<DOM::NodeList>, Error> invoke_location_strategy(LocationStrategy type, DOM::ParentNode& start_node, StringView selector)
 {
     switch (type) {
     case LocationStrategy::CssSelector:
diff --git a/Libraries/LibWeb/WebDriver/ElementLocationStrategies.h b/Libraries/LibWeb/WebDriver/ElementLocationStrategies.h
index eac1416f87e..8b086724b35 100644
--- a/Libraries/LibWeb/WebDriver/ElementLocationStrategies.h
+++ b/Libraries/LibWeb/WebDriver/ElementLocationStrategies.h
@@ -7,7 +7,7 @@
 
 #pragma once
 
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/DOM/NodeList.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/WebDriver/Error.h>
@@ -24,6 +24,6 @@ enum class LocationStrategy {
 };
 
 Optional<LocationStrategy> location_strategy_from_string(StringView type);
-ErrorOr<JS::NonnullGCPtr<DOM::NodeList>, Error> invoke_location_strategy(LocationStrategy type, DOM::ParentNode& start_node, StringView selector);
+ErrorOr<GC::Ref<DOM::NodeList>, Error> invoke_location_strategy(LocationStrategy type, DOM::ParentNode& start_node, StringView selector);
 
 }
diff --git a/Libraries/LibWeb/WebDriver/ElementReference.cpp b/Libraries/LibWeb/WebDriver/ElementReference.cpp
index bd3ae366cca..e77518a5dee 100644
--- a/Libraries/LibWeb/WebDriver/ElementReference.cpp
+++ b/Libraries/LibWeb/WebDriver/ElementReference.cpp
@@ -31,13 +31,13 @@ static ByteString const web_element_identifier = "element-6066-11e4-a52e-4f73546
 static ByteString const shadow_root_identifier = "shadow-6066-11e4-a52e-4f735466cecf"sv;
 
 // https://w3c.github.io/webdriver/#dfn-browsing-context-group-node-map
-static HashMap<JS::RawGCPtr<HTML::BrowsingContextGroup const>, HashTable<ByteString>> browsing_context_group_node_map;
+static HashMap<GC::RawPtr<HTML::BrowsingContextGroup const>, HashTable<ByteString>> browsing_context_group_node_map;
 
 // https://w3c.github.io/webdriver/#dfn-navigable-seen-nodes-map
-static HashMap<JS::RawGCPtr<HTML::Navigable>, HashTable<ByteString>> navigable_seen_nodes_map;
+static HashMap<GC::RawPtr<HTML::Navigable>, HashTable<ByteString>> navigable_seen_nodes_map;
 
 // https://w3c.github.io/webdriver/#dfn-get-a-node
-JS::GCPtr<Web::DOM::Node> get_node(HTML::BrowsingContext const& browsing_context, StringView reference)
+GC::Ptr<Web::DOM::Node> get_node(HTML::BrowsingContext const& browsing_context, StringView reference)
 {
     // 1. Let browsing context group node map be session's browsing context group node map.
     // 2. Let browsing context group be browsing context's browsing context group.
@@ -50,7 +50,7 @@ JS::GCPtr<Web::DOM::Node> get_node(HTML::BrowsingContext const& browsing_context
         return nullptr;
 
     // 5. Let node be the entry in node id map whose value is reference, if such an entry exists, or null otherwise.
-    JS::GCPtr<Web::DOM::Node> node;
+    GC::Ptr<Web::DOM::Node> node;
 
     if (node_id_map->contains(reference)) {
         auto node_id = reference.to_number<i64>().value();
@@ -158,7 +158,7 @@ bool represents_a_web_element(JS::Value value)
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-web-element
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const& browsing_context, JsonObject const& object)
+ErrorOr<GC::Ref<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const& browsing_context, JsonObject const& object)
 {
     // 1. If object has no own property web element identifier, return error with error code invalid argument.
     if (!object.has_string(web_element_identifier))
@@ -175,7 +175,7 @@ ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, WebDriver::Error> deserialize_web_e
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-web-element
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const& browsing_context, JS::Object const& object)
+ErrorOr<GC::Ref<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const& browsing_context, JS::Object const& object)
 {
     // 1. If object has no own property web element identifier, return error with error code invalid argument.
     auto property = object.get(web_element_identifier);
@@ -198,7 +198,7 @@ ByteString extract_web_element_reference(JsonObject const& object)
 }
 
 // https://w3c.github.io/webdriver/#dfn-get-a-webelement-origin
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, Web::WebDriver::Error> get_web_element_origin(Web::HTML::BrowsingContext const& browsing_context, StringView origin)
+ErrorOr<GC::Ref<Web::DOM::Element>, Web::WebDriver::Error> get_web_element_origin(Web::HTML::BrowsingContext const& browsing_context, StringView origin)
 {
     // 1. Assert: browsing context is the current browsing context.
 
@@ -210,7 +210,7 @@ ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, Web::WebDriver::Error> get_web_elem
 }
 
 // https://w3c.github.io/webdriver/#dfn-get-a-known-element
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, Web::WebDriver::Error> get_known_element(Web::HTML::BrowsingContext const& browsing_context, StringView reference)
+ErrorOr<GC::Ref<Web::DOM::Element>, Web::WebDriver::Error> get_known_element(Web::HTML::BrowsingContext const& browsing_context, StringView reference)
 {
     // 1. If not node reference is known with session, session's current browsing context, and reference return error
     //    with error code no such element.
@@ -366,18 +366,18 @@ bool is_element_non_typeable_form_control(Web::DOM::Element const& element)
 }
 
 // https://w3c.github.io/webdriver/#dfn-in-view
-bool is_element_in_view(ReadonlySpan<JS::NonnullGCPtr<Web::DOM::Element>> paint_tree, Web::DOM::Element& element)
+bool is_element_in_view(ReadonlySpan<GC::Ref<Web::DOM::Element>> paint_tree, Web::DOM::Element& element)
 {
     // An element is in view if it is a member of its own pointer-interactable paint tree, given the pretense that its
     // pointer events are not disabled.
     if (!element.paintable() || !element.paintable()->is_visible() || !element.paintable()->visible_for_hit_testing())
         return false;
 
-    return paint_tree.contains_slow(JS::NonnullGCPtr { element });
+    return paint_tree.contains_slow(GC::Ref { element });
 }
 
 // https://w3c.github.io/webdriver/#dfn-in-view
-bool is_element_obscured(ReadonlySpan<JS::NonnullGCPtr<Web::DOM::Element>> paint_tree, Web::DOM::Element& element)
+bool is_element_obscured(ReadonlySpan<GC::Ref<Web::DOM::Element>> paint_tree, Web::DOM::Element& element)
 {
     // An element is obscured if the pointer-interactable paint tree at its center point is empty, or the first element
     // in this tree is not an inclusive descendant of itself.
@@ -385,18 +385,18 @@ bool is_element_obscured(ReadonlySpan<JS::NonnullGCPtr<Web::DOM::Element>> paint
 }
 
 // https://w3c.github.io/webdriver/#dfn-pointer-interactable-paint-tree
-JS::MarkedVector<JS::NonnullGCPtr<Web::DOM::Element>> pointer_interactable_tree(Web::HTML::BrowsingContext& browsing_context, Web::DOM::Element& element)
+GC::MarkedVector<GC::Ref<Web::DOM::Element>> pointer_interactable_tree(Web::HTML::BrowsingContext& browsing_context, Web::DOM::Element& element)
 {
     // 1. If element is not in the same tree as session's current browsing context's active document, return an empty sequence.
     if (!browsing_context.active_document()->contains(element))
-        return JS::MarkedVector<JS::NonnullGCPtr<Web::DOM::Element>>(browsing_context.heap());
+        return GC::MarkedVector<GC::Ref<Web::DOM::Element>>(browsing_context.heap());
 
     // 2. Let rectangles be the DOMRect sequence returned by calling getClientRects().
     auto rectangles = element.get_client_rects();
 
     // 3. If rectangles has the length of 0, return an empty sequence.
     if (rectangles->length() == 0)
-        return JS::MarkedVector<JS::NonnullGCPtr<Web::DOM::Element>>(browsing_context.heap());
+        return GC::MarkedVector<GC::Ref<Web::DOM::Element>>(browsing_context.heap());
 
     // 4. Let center point be the in-view center point of the first indexed element in rectangles.
     auto viewport = browsing_context.page().top_level_traversable()->viewport_rect();
@@ -452,7 +452,7 @@ bool represents_a_shadow_root(JS::Value value)
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-shadow-root
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const& browsing_context, JsonObject const& object)
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const& browsing_context, JsonObject const& object)
 {
     // 1. If object has no own property shadow root identifier, return error with error code invalid argument.
     if (!object.has_string(shadow_root_identifier))
@@ -469,7 +469,7 @@ ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_sh
 }
 
 // https://w3c.github.io/webdriver/#dfn-deserialize-a-shadow-root
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const& browsing_context, JS::Object const& object)
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const& browsing_context, JS::Object const& object)
 {
     // 1. If object has no own property shadow root identifier, return error with error code invalid argument.
     auto property = object.get(shadow_root_identifier);
@@ -487,7 +487,7 @@ ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_sh
 }
 
 // https://w3c.github.io/webdriver/#dfn-get-a-known-shadow-root
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, Web::WebDriver::Error> get_known_shadow_root(HTML::BrowsingContext const& browsing_context, StringView reference)
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, Web::WebDriver::Error> get_known_shadow_root(HTML::BrowsingContext const& browsing_context, StringView reference)
 {
     // 1. If not node reference is known with session, session's current browsing context, and reference return error with error code no such shadow root.
     if (!node_reference_is_known(browsing_context, reference))
diff --git a/Libraries/LibWeb/WebDriver/ElementReference.h b/Libraries/LibWeb/WebDriver/ElementReference.h
index aeca6515b7a..fd6038d8714 100644
--- a/Libraries/LibWeb/WebDriver/ElementReference.h
+++ b/Libraries/LibWeb/WebDriver/ElementReference.h
@@ -9,8 +9,8 @@
 #include <AK/ByteString.h>
 #include <AK/Error.h>
 #include <AK/JsonObject.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/PixelUnits.h>
@@ -18,7 +18,7 @@
 
 namespace Web::WebDriver {
 
-JS::GCPtr<Web::DOM::Node> get_node(HTML::BrowsingContext const&, StringView reference);
+GC::Ptr<Web::DOM::Node> get_node(HTML::BrowsingContext const&, StringView reference);
 ByteString get_or_create_a_node_reference(HTML::BrowsingContext const&, Web::DOM::Node const&);
 bool node_reference_is_known(HTML::BrowsingContext const&, StringView reference);
 
@@ -26,11 +26,11 @@ ByteString get_or_create_a_web_element_reference(HTML::BrowsingContext const&, W
 JsonObject web_element_reference_object(HTML::BrowsingContext const&, Web::DOM::Node const& element);
 bool represents_a_web_element(JsonValue const&);
 bool represents_a_web_element(JS::Value);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const&, JsonObject const&);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const&, JS::Object const&);
+ErrorOr<GC::Ref<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const&, JsonObject const&);
+ErrorOr<GC::Ref<Web::DOM::Element>, WebDriver::Error> deserialize_web_element(Web::HTML::BrowsingContext const&, JS::Object const&);
 ByteString extract_web_element_reference(JsonObject const&);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, Web::WebDriver::Error> get_web_element_origin(Web::HTML::BrowsingContext const&, StringView origin);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::Element>, Web::WebDriver::Error> get_known_element(Web::HTML::BrowsingContext const&, StringView reference);
+ErrorOr<GC::Ref<Web::DOM::Element>, Web::WebDriver::Error> get_web_element_origin(Web::HTML::BrowsingContext const&, StringView origin);
+ErrorOr<GC::Ref<Web::DOM::Element>, Web::WebDriver::Error> get_known_element(Web::HTML::BrowsingContext const&, StringView reference);
 
 bool is_element_stale(Web::DOM::Node const& element);
 bool is_element_interactable(Web::HTML::BrowsingContext const&, Web::DOM::Element const&);
@@ -42,17 +42,17 @@ bool is_element_mutable(Web::DOM::Element const&);
 bool is_element_mutable_form_control(Web::DOM::Element const&);
 bool is_element_non_typeable_form_control(Web::DOM::Element const&);
 
-bool is_element_in_view(ReadonlySpan<JS::NonnullGCPtr<Web::DOM::Element>> paint_tree, Web::DOM::Element&);
-bool is_element_obscured(ReadonlySpan<JS::NonnullGCPtr<Web::DOM::Element>> paint_tree, Web::DOM::Element&);
-JS::MarkedVector<JS::NonnullGCPtr<Web::DOM::Element>> pointer_interactable_tree(Web::HTML::BrowsingContext&, Web::DOM::Element&);
+bool is_element_in_view(ReadonlySpan<GC::Ref<Web::DOM::Element>> paint_tree, Web::DOM::Element&);
+bool is_element_obscured(ReadonlySpan<GC::Ref<Web::DOM::Element>> paint_tree, Web::DOM::Element&);
+GC::MarkedVector<GC::Ref<Web::DOM::Element>> pointer_interactable_tree(Web::HTML::BrowsingContext&, Web::DOM::Element&);
 
 ByteString get_or_create_a_shadow_root_reference(HTML::BrowsingContext const&, Web::DOM::ShadowRoot const&);
 JsonObject shadow_root_reference_object(HTML::BrowsingContext const&, Web::DOM::ShadowRoot const&);
 bool represents_a_shadow_root(JsonValue const&);
 bool represents_a_shadow_root(JS::Value);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const&, JsonObject const&);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const&, JS::Object const&);
-ErrorOr<JS::NonnullGCPtr<Web::DOM::ShadowRoot>, Web::WebDriver::Error> get_known_shadow_root(HTML::BrowsingContext const&, StringView reference);
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const&, JsonObject const&);
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, WebDriver::Error> deserialize_shadow_root(Web::HTML::BrowsingContext const&, JS::Object const&);
+ErrorOr<GC::Ref<Web::DOM::ShadowRoot>, Web::WebDriver::Error> get_known_shadow_root(HTML::BrowsingContext const&, StringView reference);
 bool is_shadow_root_detached(Web::DOM::ShadowRoot const&);
 
 String element_rendered_text(DOM::Node&);
diff --git a/Libraries/LibWeb/WebDriver/ExecuteScript.cpp b/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
index 56ecb99352d..f7220171544 100644
--- a/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
+++ b/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
@@ -84,7 +84,7 @@ static JS::ThrowCompletionOr<JS::Value> execute_a_function_body(HTML::BrowsingCo
     return completion;
 }
 
-void execute_script(HTML::BrowsingContext const& browsing_context, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete)
+void execute_script(HTML::BrowsingContext const& browsing_context, ByteString body, GC::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, GC::Ref<OnScriptComplete> on_complete)
 {
     auto const* document = browsing_context.active_document();
     auto& realm = document->realm();
@@ -96,7 +96,7 @@ void execute_script(HTML::BrowsingContext const& browsing_context, ByteString bo
     // 6. If timeout is not null:
     if (timeout_ms.has_value()) {
         // 1. Start the timer with timer and timeout.
-        timer->start(timeout_ms.value(), JS::create_heap_function(vm.heap(), [on_complete]() {
+        timer->start(timeout_ms.value(), GC::create_function(vm.heap(), [on_complete]() {
             on_complete->function()({ .state = JS::Promise::State::Pending });
         }));
     }
@@ -108,7 +108,7 @@ void execute_script(HTML::BrowsingContext const& browsing_context, ByteString bo
     auto promise = WebIDL::create_promise(realm);
 
     // 8. Run the following substeps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&realm, &browsing_context, promise, body = move(body), arguments = move(arguments)]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&realm, &browsing_context, promise, body = move(body), arguments = move(arguments)]() mutable {
         HTML::TemporaryExecutionContext execution_context { realm };
 
         // 1. Let scriptPromise be the result of promise-calling execute a function body, with arguments body and arguments.
@@ -127,12 +127,12 @@ void execute_script(HTML::BrowsingContext const& browsing_context, ByteString bo
     }));
 
     // 9. Wait until promise is resolved, or timer's timeout fired flag is set, whichever occurs first.
-    auto reaction_steps = JS::create_heap_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    auto reaction_steps = GC::create_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         if (timer->is_timed_out())
             return JS::js_undefined();
         timer->stop();
 
-        auto promise_promise = JS::NonnullGCPtr { verify_cast<JS::Promise>(*promise->promise()) };
+        auto promise_promise = GC::Ref { verify_cast<JS::Promise>(*promise->promise()) };
         on_complete->function()({ promise_promise->state(), promise_promise->result() });
 
         return JS::js_undefined();
@@ -141,7 +141,7 @@ void execute_script(HTML::BrowsingContext const& browsing_context, ByteString bo
     WebIDL::react_to_promise(promise, reaction_steps, reaction_steps);
 }
 
-void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete)
+void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteString body, GC::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, GC::Ref<OnScriptComplete> on_complete)
 {
     auto const* document = browsing_context.active_document();
     auto& realm = document->realm();
@@ -153,7 +153,7 @@ void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteStr
     // 6. If timeout is not null:
     if (timeout_ms.has_value()) {
         // 1. Start the timer with timer and timeout.
-        timer->start(timeout_ms.value(), JS::create_heap_function(vm.heap(), [on_complete]() {
+        timer->start(timeout_ms.value(), GC::create_function(vm.heap(), [on_complete]() {
             on_complete->function()({ .state = JS::Promise::State::Pending });
         }));
     }
@@ -163,10 +163,10 @@ void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteStr
 
     // 7. Let promise be a new Promise.
     auto promise_capability = WebIDL::create_promise(realm);
-    JS::NonnullGCPtr promise { verify_cast<JS::Promise>(*promise_capability->promise()) };
+    GC::Ref promise { verify_cast<JS::Promise>(*promise_capability->promise()) };
 
     // 8. Run the following substeps in parallel:
-    Platform::EventLoopPlugin::the().deferred_invoke(JS::create_heap_function(realm.heap(), [&vm, &realm, &browsing_context, timer, promise_capability, promise, body = move(body), arguments = move(arguments)]() mutable {
+    Platform::EventLoopPlugin::the().deferred_invoke(GC::create_function(realm.heap(), [&vm, &realm, &browsing_context, timer, promise_capability, promise, body = move(body), arguments = move(arguments)]() mutable {
         HTML::TemporaryExecutionContext execution_context { realm };
 
         // 1. Let resolvingFunctions be CreateResolvingFunctions(promise).
@@ -211,7 +211,7 @@ void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteStr
             return;
         auto& script_promise = static_cast<JS::Promise&>(*script_promise_or_error.value());
 
-        vm.custom_data()->spin_event_loop_until(JS::create_heap_function(vm.heap(), [timer, &script_promise]() {
+        vm.custom_data()->spin_event_loop_until(GC::create_function(vm.heap(), [timer, &script_promise]() {
             return timer->is_timed_out() || script_promise.state() != JS::Promise::State::Pending;
         }));
 
@@ -225,7 +225,7 @@ void execute_async_script(HTML::BrowsingContext const& browsing_context, ByteStr
     }));
 
     // 9. Wait until promise is resolved, or timer's timeout fired flag is set, whichever occurs first.
-    auto reaction_steps = JS::create_heap_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
+    auto reaction_steps = GC::create_function(vm.heap(), [promise, timer, on_complete](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
         if (timer->is_timed_out())
             return JS::js_undefined();
         timer->stop();
diff --git a/Libraries/LibWeb/WebDriver/ExecuteScript.h b/Libraries/LibWeb/WebDriver/ExecuteScript.h
index 058be4c580f..7ffc1bcc96b 100644
--- a/Libraries/LibWeb/WebDriver/ExecuteScript.h
+++ b/Libraries/LibWeb/WebDriver/ExecuteScript.h
@@ -8,8 +8,8 @@
 #pragma once
 
 #include <AK/Forward.h>
+#include <LibGC/Function.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/HeapFunction.h>
 #include <LibJS/Runtime/Promise.h>
 #include <LibJS/Runtime/Value.h>
 #include <LibWeb/Forward.h>
@@ -21,9 +21,9 @@ struct ExecutionResult {
     JS::Value value {};
 };
 
-using OnScriptComplete = JS::HeapFunction<void(ExecutionResult)>;
+using OnScriptComplete = GC::Function<void(ExecutionResult)>;
 
-void execute_script(HTML::BrowsingContext const&, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete);
-void execute_async_script(HTML::BrowsingContext const&, ByteString body, JS::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, JS::NonnullGCPtr<OnScriptComplete> on_complete);
+void execute_script(HTML::BrowsingContext const&, ByteString body, GC::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, GC::Ref<OnScriptComplete> on_complete);
+void execute_async_script(HTML::BrowsingContext const&, ByteString body, GC::MarkedVector<JS::Value> arguments, Optional<u64> const& timeout_ms, GC::Ref<OnScriptComplete> on_complete);
 
 }
diff --git a/Libraries/LibWeb/WebDriver/HeapTimer.cpp b/Libraries/LibWeb/WebDriver/HeapTimer.cpp
index 25ba7b85155..534fc7de274 100644
--- a/Libraries/LibWeb/WebDriver/HeapTimer.cpp
+++ b/Libraries/LibWeb/WebDriver/HeapTimer.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebDriver {
 
-JS_DEFINE_ALLOCATOR(HeapTimer);
+GC_DEFINE_ALLOCATOR(HeapTimer);
 
 HeapTimer::HeapTimer()
     : m_timer(Core::Timer::create())
@@ -24,7 +24,7 @@ void HeapTimer::visit_edges(JS::Cell::Visitor& visitor)
     visitor.visit(m_on_timeout);
 }
 
-void HeapTimer::start(u64 timeout_ms, JS::NonnullGCPtr<JS::HeapFunction<void()>> on_timeout)
+void HeapTimer::start(u64 timeout_ms, GC::Ref<GC::Function<void()>> on_timeout)
 {
     m_on_timeout = on_timeout;
 
diff --git a/Libraries/LibWeb/WebDriver/HeapTimer.h b/Libraries/LibWeb/WebDriver/HeapTimer.h
index a7ca3e6c78f..30838b41901 100644
--- a/Libraries/LibWeb/WebDriver/HeapTimer.h
+++ b/Libraries/LibWeb/WebDriver/HeapTimer.h
@@ -7,21 +7,21 @@
 #pragma once
 
 #include <LibCore/Forward.h>
+#include <LibGC/Function.h>
+#include <LibGC/Ptr.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/HeapFunction.h>
 
 namespace Web::WebDriver {
 
 class HeapTimer : public JS::Cell {
-    JS_CELL(HeapTimer, JS::Cell);
-    JS_DECLARE_ALLOCATOR(HeapTimer);
+    GC_CELL(HeapTimer, JS::Cell);
+    GC_DECLARE_ALLOCATOR(HeapTimer);
 
 public:
     explicit HeapTimer();
     virtual ~HeapTimer() override;
 
-    void start(u64 timeout_ms, JS::NonnullGCPtr<JS::HeapFunction<void()>> on_timeout);
+    void start(u64 timeout_ms, GC::Ref<GC::Function<void()>> on_timeout);
     void stop_and_fire_timeout_handler();
     void stop();
 
@@ -31,7 +31,7 @@ private:
     virtual void visit_edges(JS::Cell::Visitor& visitor) override;
 
     NonnullRefPtr<Core::Timer> m_timer;
-    JS::GCPtr<JS::HeapFunction<void()>> m_on_timeout;
+    GC::Ptr<GC::Function<void()>> m_on_timeout;
     bool m_timed_out { false };
 };
 
diff --git a/Libraries/LibWeb/WebDriver/InputState.cpp b/Libraries/LibWeb/WebDriver/InputState.cpp
index 8316ee0490d..a149a58f6d4 100644
--- a/Libraries/LibWeb/WebDriver/InputState.cpp
+++ b/Libraries/LibWeb/WebDriver/InputState.cpp
@@ -11,7 +11,7 @@
 namespace Web::WebDriver {
 
 // https://w3c.github.io/webdriver/#dfn-browsing-context-input-state-map
-static HashMap<JS::RawGCPtr<HTML::BrowsingContext>, InputState> s_browsing_context_input_state_map;
+static HashMap<GC::RawPtr<HTML::BrowsingContext>, InputState> s_browsing_context_input_state_map;
 
 InputState::InputState() = default;
 InputState::~InputState() = default;
diff --git a/Libraries/LibWeb/WebDriver/JSON.cpp b/Libraries/LibWeb/WebDriver/JSON.cpp
index c10d3624a08..c8da822014c 100644
--- a/Libraries/LibWeb/WebDriver/JSON.cpp
+++ b/Libraries/LibWeb/WebDriver/JSON.cpp
@@ -40,7 +40,7 @@ namespace Web::WebDriver {
         _temporary_result.release_value();                                                              \
     })
 
-using SeenMap = HashTable<JS::RawGCPtr<JS::Object const>>;
+using SeenMap = HashTable<GC::RawPtr<JS::Object const>>;
 
 // https://w3c.github.io/webdriver/#dfn-collection
 static bool is_collection(JS::Object const& value)
@@ -253,7 +253,7 @@ static Response internal_json_clone(HTML::BrowsingContext const& browsing_contex
     // -> has an own property named "toJSON" that is a Function
     if (auto to_json = object.get_without_side_effects(vm.names.toJSON); to_json.is_function()) {
         // Return success with the value returned by Function.[[Call]](toJSON) with value as the this value.
-        auto to_json_result = TRY_OR_JS_ERROR(to_json.as_function().internal_call(value, JS::MarkedVector<JS::Value> { vm.heap() }));
+        auto to_json_result = TRY_OR_JS_ERROR(to_json.as_function().internal_call(value, GC::MarkedVector<JS::Value> { vm.heap() }));
         if (!to_json_result.is_string())
             return WebDriver::Error::from_code(ErrorCode::JavascriptError, "toJSON did not return a String"sv);
 
@@ -322,7 +322,7 @@ static ErrorOr<JS::Value, WebDriver::Error> internal_json_deserialize(HTML::Brow
     if (value.is_object()) {
         // Return clone an object algorithm with session, value and seen, and the JSON deserialize algorithm as the
         // clone algorithm.
-        return clone_an_object<JS::NonnullGCPtr<JS::Object>>(browsing_context, value.as_object(), seen, internal_json_deserialize);
+        return clone_an_object<GC::Ref<JS::Object>>(browsing_context, value.as_object(), seen, internal_json_deserialize);
     }
 
     return WebDriver::Error::from_code(ErrorCode::JavascriptError, "Unrecognized value type"sv);
diff --git a/Libraries/LibWeb/WebDriver/Screenshot.cpp b/Libraries/LibWeb/WebDriver/Screenshot.cpp
index a0c205c46e0..6a69aed4b62 100644
--- a/Libraries/LibWeb/WebDriver/Screenshot.cpp
+++ b/Libraries/LibWeb/WebDriver/Screenshot.cpp
@@ -18,7 +18,7 @@
 namespace Web::WebDriver {
 
 // https://w3c.github.io/webdriver/#dfn-draw-a-bounding-box-from-the-framebuffer
-ErrorOr<JS::NonnullGCPtr<HTML::HTMLCanvasElement>, WebDriver::Error> draw_bounding_box_from_the_framebuffer(HTML::BrowsingContext& browsing_context, DOM::Element& element, Gfx::IntRect rect)
+ErrorOr<GC::Ref<HTML::HTMLCanvasElement>, WebDriver::Error> draw_bounding_box_from_the_framebuffer(HTML::BrowsingContext& browsing_context, DOM::Element& element, Gfx::IntRect rect)
 {
     // 1. If either the initial viewport's width or height is 0 CSS pixels, return error with error code unable to capture screen.
     auto viewport_rect = browsing_context.top_level_traversable()->viewport_rect();
diff --git a/Libraries/LibWeb/WebDriver/Screenshot.h b/Libraries/LibWeb/WebDriver/Screenshot.h
index 1296f770236..7c164ffa296 100644
--- a/Libraries/LibWeb/WebDriver/Screenshot.h
+++ b/Libraries/LibWeb/WebDriver/Screenshot.h
@@ -6,14 +6,14 @@
 
 #pragma once
 
+#include <LibGC/Ptr.h>
 #include <LibGfx/Rect.h>
-#include <LibJS/Heap/GCPtr.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/WebDriver/Response.h>
 
 namespace Web::WebDriver {
 
-ErrorOr<JS::NonnullGCPtr<HTML::HTMLCanvasElement>, WebDriver::Error> draw_bounding_box_from_the_framebuffer(HTML::BrowsingContext&, DOM::Element&, Gfx::IntRect);
+ErrorOr<GC::Ref<HTML::HTMLCanvasElement>, WebDriver::Error> draw_bounding_box_from_the_framebuffer(HTML::BrowsingContext&, DOM::Element&, Gfx::IntRect);
 Response encode_canvas_element(HTML::HTMLCanvasElement&);
 
 }
diff --git a/Libraries/LibWeb/WebGL/WebGLActiveInfo.cpp b/Libraries/LibWeb/WebGL/WebGLActiveInfo.cpp
index 03492e8f223..6c0ff9bf62c 100644
--- a/Libraries/LibWeb/WebGL/WebGLActiveInfo.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLActiveInfo.cpp
@@ -8,7 +8,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLActiveInfo);
+GC_DEFINE_ALLOCATOR(WebGLActiveInfo);
 
 WebGLActiveInfo::WebGLActiveInfo(JS::Realm& realm)
     : Bindings::PlatformObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLActiveInfo.h b/Libraries/LibWeb/WebGL/WebGLActiveInfo.h
index 3e27070ddec..33d300e2815 100644
--- a/Libraries/LibWeb/WebGL/WebGLActiveInfo.h
+++ b/Libraries/LibWeb/WebGL/WebGLActiveInfo.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLActiveInfo : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(WebGLActiveInfo, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(WebGLActiveInfo);
+    GC_DECLARE_ALLOCATOR(WebGLActiveInfo);
 
 public:
     virtual ~WebGLActiveInfo();
diff --git a/Libraries/LibWeb/WebGL/WebGLBuffer.cpp b/Libraries/LibWeb/WebGL/WebGLBuffer.cpp
index 736b48f37b6..472b402e67d 100644
--- a/Libraries/LibWeb/WebGL/WebGLBuffer.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLBuffer.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLBuffer);
+GC_DEFINE_ALLOCATOR(WebGLBuffer);
 
 WebGLBuffer::WebGLBuffer(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLBuffer.h b/Libraries/LibWeb/WebGL/WebGLBuffer.h
index 35eb12bfc47..0c6cc5e2b2d 100644
--- a/Libraries/LibWeb/WebGL/WebGLBuffer.h
+++ b/Libraries/LibWeb/WebGL/WebGLBuffer.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLBuffer final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLBuffer, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLBuffer);
+    GC_DECLARE_ALLOCATOR(WebGLBuffer);
 
 public:
     virtual ~WebGLBuffer();
diff --git a/Libraries/LibWeb/WebGL/WebGLContextEvent.cpp b/Libraries/LibWeb/WebGL/WebGLContextEvent.cpp
index ccd0a7c0898..8ef8bffa020 100644
--- a/Libraries/LibWeb/WebGL/WebGLContextEvent.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLContextEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLContextEvent);
+GC_DEFINE_ALLOCATOR(WebGLContextEvent);
 
-JS::NonnullGCPtr<WebGLContextEvent> WebGLContextEvent::create(JS::Realm& realm, FlyString const& event_name, WebGLContextEventInit const& event_init)
+GC::Ref<WebGLContextEvent> WebGLContextEvent::create(JS::Realm& realm, FlyString const& event_name, WebGLContextEventInit const& event_init)
 {
     return realm.create<WebGLContextEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebGLContextEvent>> WebGLContextEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, WebGLContextEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<WebGLContextEvent>> WebGLContextEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, WebGLContextEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/WebGL/WebGLContextEvent.h b/Libraries/LibWeb/WebGL/WebGLContextEvent.h
index c36cb1ba385..f96b37a9257 100644
--- a/Libraries/LibWeb/WebGL/WebGLContextEvent.h
+++ b/Libraries/LibWeb/WebGL/WebGLContextEvent.h
@@ -18,11 +18,11 @@ struct WebGLContextEventInit final : public DOM::EventInit {
 
 class WebGLContextEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(WebGLContextEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(WebGLContextEvent);
+    GC_DECLARE_ALLOCATOR(WebGLContextEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<WebGLContextEvent> create(JS::Realm&, FlyString const& type, WebGLContextEventInit const&);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<WebGLContextEvent>> construct_impl(JS::Realm&, FlyString const& type, WebGLContextEventInit const&);
+    [[nodiscard]] static GC::Ref<WebGLContextEvent> create(JS::Realm&, FlyString const& type, WebGLContextEventInit const&);
+    static WebIDL::ExceptionOr<GC::Ref<WebGLContextEvent>> construct_impl(JS::Realm&, FlyString const& type, WebGLContextEventInit const&);
 
     virtual ~WebGLContextEvent() override;
 
diff --git a/Libraries/LibWeb/WebGL/WebGLFramebuffer.cpp b/Libraries/LibWeb/WebGL/WebGLFramebuffer.cpp
index 735e608e4d1..2fb5c681da0 100644
--- a/Libraries/LibWeb/WebGL/WebGLFramebuffer.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLFramebuffer.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLFramebuffer);
+GC_DEFINE_ALLOCATOR(WebGLFramebuffer);
 
 WebGLFramebuffer::WebGLFramebuffer(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLFramebuffer.h b/Libraries/LibWeb/WebGL/WebGLFramebuffer.h
index 725edd2af9e..84d3ad8e154 100644
--- a/Libraries/LibWeb/WebGL/WebGLFramebuffer.h
+++ b/Libraries/LibWeb/WebGL/WebGLFramebuffer.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLFramebuffer final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLFramebuffer, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLFramebuffer);
+    GC_DECLARE_ALLOCATOR(WebGLFramebuffer);
 
 public:
     virtual ~WebGLFramebuffer();
diff --git a/Libraries/LibWeb/WebGL/WebGLProgram.cpp b/Libraries/LibWeb/WebGL/WebGLProgram.cpp
index 629dc22d7f1..cf784403daf 100644
--- a/Libraries/LibWeb/WebGL/WebGLProgram.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLProgram.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLProgram);
+GC_DEFINE_ALLOCATOR(WebGLProgram);
 
 WebGLProgram::WebGLProgram(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLProgram.h b/Libraries/LibWeb/WebGL/WebGLProgram.h
index fde138bac81..7e1de769c9f 100644
--- a/Libraries/LibWeb/WebGL/WebGLProgram.h
+++ b/Libraries/LibWeb/WebGL/WebGLProgram.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLProgram final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLProgram, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLProgram);
+    GC_DECLARE_ALLOCATOR(WebGLProgram);
 
 public:
     virtual ~WebGLProgram();
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderbuffer.cpp b/Libraries/LibWeb/WebGL/WebGLRenderbuffer.cpp
index e268f9b3549..cfc0480fb18 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderbuffer.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLRenderbuffer.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLRenderbuffer);
+GC_DEFINE_ALLOCATOR(WebGLRenderbuffer);
 
 WebGLRenderbuffer::WebGLRenderbuffer(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderbuffer.h b/Libraries/LibWeb/WebGL/WebGLRenderbuffer.h
index 1a4887643bf..0fa456cb20a 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderbuffer.h
+++ b/Libraries/LibWeb/WebGL/WebGLRenderbuffer.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLRenderbuffer final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLRenderbuffer, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLRenderbuffer);
+    GC_DECLARE_ALLOCATOR(WebGLRenderbuffer);
 
 public:
     virtual ~WebGLRenderbuffer();
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderingContext.cpp b/Libraries/LibWeb/WebGL/WebGLRenderingContext.cpp
index d6d4a09b43b..f53732fd34f 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderingContext.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLRenderingContext.cpp
@@ -14,7 +14,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLRenderingContext);
+GC_DEFINE_ALLOCATOR(WebGLRenderingContext);
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#fire-a-webgl-context-event
 static void fire_webgl_context_event(HTML::HTMLCanvasElement& canvas_element, FlyString const& type)
@@ -34,7 +34,7 @@ static void fire_webgl_context_creation_error(HTML::HTMLCanvasElement& canvas_el
     fire_webgl_context_event(canvas_element, EventNames::webglcontextcreationerror);
 }
 
-JS::ThrowCompletionOr<JS::GCPtr<WebGLRenderingContext>> WebGLRenderingContext::create(JS::Realm& realm, HTML::HTMLCanvasElement& canvas_element, JS::Value options)
+JS::ThrowCompletionOr<GC::Ptr<WebGLRenderingContext>> WebGLRenderingContext::create(JS::Realm& realm, HTML::HTMLCanvasElement& canvas_element, JS::Value options)
 {
     // We should be coming here from getContext being called on a wrapped <canvas> element.
     auto context_attributes = TRY(convert_value_to_context_attributes_dictionary(canvas_element.vm(), options));
@@ -42,7 +42,7 @@ JS::ThrowCompletionOr<JS::GCPtr<WebGLRenderingContext>> WebGLRenderingContext::c
     bool created_surface = canvas_element.allocate_painting_surface(/* minimum_width= */ 1, /* minimum_height= */ 1);
     if (!created_surface) {
         fire_webgl_context_creation_error(canvas_element);
-        return JS::GCPtr<WebGLRenderingContext> { nullptr };
+        return GC::Ptr<WebGLRenderingContext> { nullptr };
     }
 
     VERIFY(canvas_element.surface());
@@ -50,7 +50,7 @@ JS::ThrowCompletionOr<JS::GCPtr<WebGLRenderingContext>> WebGLRenderingContext::c
 
     if (!context) {
         fire_webgl_context_creation_error(canvas_element);
-        return JS::GCPtr<WebGLRenderingContext> { nullptr };
+        return GC::Ptr<WebGLRenderingContext> { nullptr };
     }
 
     return realm.create<WebGLRenderingContext>(realm, canvas_element, context.release_nonnull(), context_attributes, context_attributes);
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderingContext.h b/Libraries/LibWeb/WebGL/WebGLRenderingContext.h
index d504382ada2..f2d3f613118 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderingContext.h
+++ b/Libraries/LibWeb/WebGL/WebGLRenderingContext.h
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <AK/OwnPtr.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/WebGL/WebGLRenderingContextBase.h>
 
@@ -16,10 +16,10 @@ namespace Web::WebGL {
 
 class WebGLRenderingContext final : public WebGLRenderingContextBase {
     WEB_PLATFORM_OBJECT(WebGLRenderingContext, WebGLRenderingContextBase);
-    JS_DECLARE_ALLOCATOR(WebGLRenderingContext);
+    GC_DECLARE_ALLOCATOR(WebGLRenderingContext);
 
 public:
-    static JS::ThrowCompletionOr<JS::GCPtr<WebGLRenderingContext>> create(JS::Realm&, HTML::HTMLCanvasElement& canvas_element, JS::Value options);
+    static JS::ThrowCompletionOr<GC::Ptr<WebGLRenderingContext>> create(JS::Realm&, HTML::HTMLCanvasElement& canvas_element, JS::Value options);
 
     virtual ~WebGLRenderingContext() override;
 
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.cpp b/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.cpp
index 589b8a1f2f2..3848c3e0d18 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.cpp
@@ -73,7 +73,7 @@ HTML::HTMLCanvasElement const& WebGLRenderingContextBase::canvas_element() const
     return *m_canvas_element;
 }
 
-JS::NonnullGCPtr<HTML::HTMLCanvasElement> WebGLRenderingContextBase::canvas_for_binding() const
+GC::Ref<HTML::HTMLCanvasElement> WebGLRenderingContextBase::canvas_for_binding() const
 {
     return *m_canvas_element;
 }
diff --git a/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.h b/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.h
index 18164ee00a9..f87af49a11b 100644
--- a/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.h
+++ b/Libraries/LibWeb/WebGL/WebGLRenderingContextBase.h
@@ -9,7 +9,7 @@
 
 #include <AK/WeakPtr.h>
 #include <AK/Weakable.h>
-#include <LibJS/Heap/GCPtr.h>
+#include <LibGC/Ptr.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/WebGL/OpenGLContext.h>
@@ -27,7 +27,7 @@ public:
 
     void present();
 
-    JS::NonnullGCPtr<HTML::HTMLCanvasElement> canvas_for_binding() const;
+    GC::Ref<HTML::HTMLCanvasElement> canvas_for_binding() const;
 
     bool is_context_lost() const;
 
@@ -71,7 +71,7 @@ protected:
 private:
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<HTML::HTMLCanvasElement> m_canvas_element;
+    GC::Ref<HTML::HTMLCanvasElement> m_canvas_element;
 
     NonnullOwnPtr<OpenGLContext> m_context;
 
diff --git a/Libraries/LibWeb/WebGL/WebGLShader.cpp b/Libraries/LibWeb/WebGL/WebGLShader.cpp
index 75d265da9e3..9a6b121ae32 100644
--- a/Libraries/LibWeb/WebGL/WebGLShader.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLShader.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLShader);
+GC_DEFINE_ALLOCATOR(WebGLShader);
 
 WebGLShader::WebGLShader(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLShader.h b/Libraries/LibWeb/WebGL/WebGLShader.h
index 1ce8308ae3b..9207143427b 100644
--- a/Libraries/LibWeb/WebGL/WebGLShader.h
+++ b/Libraries/LibWeb/WebGL/WebGLShader.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLShader final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLShader, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLShader);
+    GC_DECLARE_ALLOCATOR(WebGLShader);
 
 public:
     virtual ~WebGLShader();
diff --git a/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.cpp b/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.cpp
index 8470c440acc..0a7caa88cec 100644
--- a/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLShaderPrecisionFormat);
+GC_DEFINE_ALLOCATOR(WebGLShaderPrecisionFormat);
 
 WebGLShaderPrecisionFormat::WebGLShaderPrecisionFormat(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.h b/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.h
index 980e7432480..74668602ebf 100644
--- a/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.h
+++ b/Libraries/LibWeb/WebGL/WebGLShaderPrecisionFormat.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLShaderPrecisionFormat final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLShaderPrecisionFormat, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLShaderPrecisionFormat);
+    GC_DECLARE_ALLOCATOR(WebGLShaderPrecisionFormat);
 
 public:
     virtual ~WebGLShaderPrecisionFormat();
diff --git a/Libraries/LibWeb/WebGL/WebGLTexture.cpp b/Libraries/LibWeb/WebGL/WebGLTexture.cpp
index 9969d39b730..be3b837f859 100644
--- a/Libraries/LibWeb/WebGL/WebGLTexture.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLTexture.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLTexture);
+GC_DEFINE_ALLOCATOR(WebGLTexture);
 
 WebGLTexture::WebGLTexture(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLTexture.h b/Libraries/LibWeb/WebGL/WebGLTexture.h
index cde502983d0..1b2cc675f59 100644
--- a/Libraries/LibWeb/WebGL/WebGLTexture.h
+++ b/Libraries/LibWeb/WebGL/WebGLTexture.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLTexture final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLTexture, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLTexture);
+    GC_DECLARE_ALLOCATOR(WebGLTexture);
 
 public:
     virtual ~WebGLTexture();
diff --git a/Libraries/LibWeb/WebGL/WebGLUniformLocation.cpp b/Libraries/LibWeb/WebGL/WebGLUniformLocation.cpp
index 3baa7ceb120..11e3e414a88 100644
--- a/Libraries/LibWeb/WebGL/WebGLUniformLocation.cpp
+++ b/Libraries/LibWeb/WebGL/WebGLUniformLocation.cpp
@@ -9,7 +9,7 @@
 
 namespace Web::WebGL {
 
-JS_DEFINE_ALLOCATOR(WebGLUniformLocation);
+GC_DEFINE_ALLOCATOR(WebGLUniformLocation);
 
 WebGLUniformLocation::WebGLUniformLocation(JS::Realm& realm)
     : WebGLObject(realm)
diff --git a/Libraries/LibWeb/WebGL/WebGLUniformLocation.h b/Libraries/LibWeb/WebGL/WebGLUniformLocation.h
index 4b69fb835ea..282cc646692 100644
--- a/Libraries/LibWeb/WebGL/WebGLUniformLocation.h
+++ b/Libraries/LibWeb/WebGL/WebGLUniformLocation.h
@@ -12,7 +12,7 @@ namespace Web::WebGL {
 
 class WebGLUniformLocation final : public WebGLObject {
     WEB_PLATFORM_OBJECT(WebGLUniformLocation, WebGLObject);
-    JS_DECLARE_ALLOCATOR(WebGLUniformLocation);
+    GC_DECLARE_ALLOCATOR(WebGLUniformLocation);
 
 public:
     virtual ~WebGLUniformLocation();
diff --git a/Libraries/LibWeb/WebIDL/AbstractOperations.cpp b/Libraries/LibWeb/WebIDL/AbstractOperations.cpp
index 08033df7fc7..405bc700f3c 100644
--- a/Libraries/LibWeb/WebIDL/AbstractOperations.cpp
+++ b/Libraries/LibWeb/WebIDL/AbstractOperations.cpp
@@ -131,7 +131,7 @@ inline JS::Completion clean_up_on_return(JS::Realm& stored_realm, JS::Realm& rel
 
 // https://webidl.spec.whatwg.org/#call-a-user-objects-operation
 // https://whatpr.org/webidl/1437.html#call-a-user-objects-operation
-JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String const& operation_name, Optional<JS::Value> this_argument, JS::MarkedVector<JS::Value> args)
+JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String const& operation_name, Optional<JS::Value> this_argument, GC::MarkedVector<JS::Value> args)
 {
     // 1. Let completion be an uninitialized variable.
     JS::Completion completion;
@@ -207,7 +207,7 @@ JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String
 
 // https://webidl.spec.whatwg.org/#invoke-a-callback-function
 // https://whatpr.org/webidl/1437.html#invoke-a-callback-function
-JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Value> this_argument, JS::MarkedVector<JS::Value> args)
+JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Value> this_argument, GC::MarkedVector<JS::Value> args)
 {
     // 1. Let completion be an uninitialized variable.
     JS::Completion completion;
@@ -261,7 +261,7 @@ JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Valu
     return clean_up_on_return(stored_realm, relevant_realm, completion, callback.operation_returns_promise);
 }
 
-JS::Completion construct(WebIDL::CallbackType& callback, JS::MarkedVector<JS::Value> args)
+JS::Completion construct(WebIDL::CallbackType& callback, GC::MarkedVector<JS::Value> args)
 {
     // 1. Let completion be an uninitialized variable.
     JS::Completion completion;
diff --git a/Libraries/LibWeb/WebIDL/AbstractOperations.h b/Libraries/LibWeb/WebIDL/AbstractOperations.h
index 2f3ad156a7a..46fb1acb5fb 100644
--- a/Libraries/LibWeb/WebIDL/AbstractOperations.h
+++ b/Libraries/LibWeb/WebIDL/AbstractOperations.h
@@ -19,7 +19,7 @@ namespace Web::WebIDL {
 
 ErrorOr<ByteBuffer> get_buffer_source_copy(JS::Object const& buffer_source);
 
-JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String const& operation_name, Optional<JS::Value> this_argument, JS::MarkedVector<JS::Value> args);
+JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String const& operation_name, Optional<JS::Value> this_argument, GC::MarkedVector<JS::Value> args);
 
 // https://webidl.spec.whatwg.org/#call-a-user-objects-operation
 template<typename... Args>
@@ -27,13 +27,13 @@ JS::Completion call_user_object_operation(WebIDL::CallbackType& callback, String
 {
     auto& function_object = callback.callback;
 
-    JS::MarkedVector<JS::Value> arguments_list { function_object->heap() };
+    GC::MarkedVector<JS::Value> arguments_list { function_object->heap() };
     (arguments_list.append(forward<Args>(args)), ...);
 
     return call_user_object_operation(callback, operation_name, move(this_argument), move(arguments_list));
 }
 
-JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Value> this_argument, JS::MarkedVector<JS::Value> args);
+JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Value> this_argument, GC::MarkedVector<JS::Value> args);
 
 // https://webidl.spec.whatwg.org/#invoke-a-callback-function
 template<typename... Args>
@@ -41,13 +41,13 @@ JS::Completion invoke_callback(WebIDL::CallbackType& callback, Optional<JS::Valu
 {
     auto& function_object = callback.callback;
 
-    JS::MarkedVector<JS::Value> arguments_list { function_object->heap() };
+    GC::MarkedVector<JS::Value> arguments_list { function_object->heap() };
     (arguments_list.append(forward<Args>(args)), ...);
 
     return invoke_callback(callback, move(this_argument), move(arguments_list));
 }
 
-JS::Completion construct(WebIDL::CallbackType& callback, JS::MarkedVector<JS::Value> args);
+JS::Completion construct(WebIDL::CallbackType& callback, GC::MarkedVector<JS::Value> args);
 
 // https://webidl.spec.whatwg.org/#construct-a-callback-function
 template<typename... Args>
@@ -55,7 +55,7 @@ JS::Completion construct(WebIDL::CallbackType& callback, Args&&... args)
 {
     auto& function_object = callback.callback;
 
-    JS::MarkedVector<JS::Value> arguments_list { function_object->heap() };
+    GC::MarkedVector<JS::Value> arguments_list { function_object->heap() };
     (arguments_list.append(forward<Args>(args)), ...);
 
     return construct(callback, move(arguments_list));
diff --git a/Libraries/LibWeb/WebIDL/Buffers.cpp b/Libraries/LibWeb/WebIDL/Buffers.cpp
index fc164847fb5..8529496a0a0 100644
--- a/Libraries/LibWeb/WebIDL/Buffers.cpp
+++ b/Libraries/LibWeb/WebIDL/Buffers.cpp
@@ -11,68 +11,68 @@
 
 namespace Web::WebIDL {
 
-JS_DEFINE_ALLOCATOR(BufferableObjectBase);
-JS_DEFINE_ALLOCATOR(ArrayBufferView);
-JS_DEFINE_ALLOCATOR(BufferSource);
+GC_DEFINE_ALLOCATOR(BufferableObjectBase);
+GC_DEFINE_ALLOCATOR(ArrayBufferView);
+GC_DEFINE_ALLOCATOR(BufferSource);
 
 u32 BufferableObjectBase::byte_length() const
 {
     return m_bufferable_object.visit(
-        [](JS::NonnullGCPtr<JS::TypedArrayBase> typed_array) {
+        [](GC::Ref<JS::TypedArrayBase> typed_array) {
             auto typed_array_record = JS::make_typed_array_with_buffer_witness_record(typed_array, JS::ArrayBuffer::Order::SeqCst);
             return JS::typed_array_byte_length(typed_array_record);
         },
-        [](JS::NonnullGCPtr<JS::DataView> data_view) {
+        [](GC::Ref<JS::DataView> data_view) {
             auto view_record = JS::make_data_view_with_buffer_witness_record(data_view, JS::ArrayBuffer::Order::SeqCst);
             return JS::get_view_byte_length(view_record);
         },
-        [](JS::NonnullGCPtr<JS::ArrayBuffer> array_buffer) { return static_cast<u32>(array_buffer->byte_length()); });
+        [](GC::Ref<JS::ArrayBuffer> array_buffer) { return static_cast<u32>(array_buffer->byte_length()); });
 }
 
-JS::NonnullGCPtr<JS::Object> BufferableObjectBase::raw_object()
+GC::Ref<JS::Object> BufferableObjectBase::raw_object()
 {
-    return m_bufferable_object.visit([](auto const& obj) -> JS::NonnullGCPtr<JS::Object> { return obj; });
+    return m_bufferable_object.visit([](auto const& obj) -> GC::Ref<JS::Object> { return obj; });
 }
 
-JS::GCPtr<JS::ArrayBuffer> BufferableObjectBase::viewed_array_buffer()
+GC::Ptr<JS::ArrayBuffer> BufferableObjectBase::viewed_array_buffer()
 {
     return m_bufferable_object.visit(
-        [](JS::NonnullGCPtr<JS::ArrayBuffer> array_buffer) -> JS::GCPtr<JS::ArrayBuffer> { return array_buffer; },
-        [](auto const& view) -> JS::GCPtr<JS::ArrayBuffer> { return view->viewed_array_buffer(); });
+        [](GC::Ref<JS::ArrayBuffer> array_buffer) -> GC::Ptr<JS::ArrayBuffer> { return array_buffer; },
+        [](auto const& view) -> GC::Ptr<JS::ArrayBuffer> { return view->viewed_array_buffer(); });
 }
 
-BufferableObject BufferableObjectBase::bufferable_object_from_raw_object(JS::NonnullGCPtr<JS::Object> object)
+BufferableObject BufferableObjectBase::bufferable_object_from_raw_object(GC::Ref<JS::Object> object)
 {
     if (is<JS::TypedArrayBase>(*object))
-        return JS::NonnullGCPtr { static_cast<JS::TypedArrayBase&>(*object) };
+        return GC::Ref { static_cast<JS::TypedArrayBase&>(*object) };
 
     if (is<JS::DataView>(*object))
-        return JS::NonnullGCPtr { static_cast<JS::DataView&>(*object) };
+        return GC::Ref { static_cast<JS::DataView&>(*object) };
 
     if (is<JS::ArrayBuffer>(*object))
-        return JS::NonnullGCPtr { static_cast<JS::ArrayBuffer&>(*object) };
+        return GC::Ref { static_cast<JS::ArrayBuffer&>(*object) };
 
     VERIFY_NOT_REACHED();
 }
 
-BufferableObjectBase::BufferableObjectBase(JS::NonnullGCPtr<JS::Object> object)
+BufferableObjectBase::BufferableObjectBase(GC::Ref<JS::Object> object)
     : m_bufferable_object(bufferable_object_from_raw_object(object))
 {
 }
 
 bool BufferableObjectBase::is_typed_array_base() const
 {
-    return m_bufferable_object.has<JS::NonnullGCPtr<JS::TypedArrayBase>>();
+    return m_bufferable_object.has<GC::Ref<JS::TypedArrayBase>>();
 }
 
 bool BufferableObjectBase::is_data_view() const
 {
-    return m_bufferable_object.has<JS::NonnullGCPtr<JS::DataView>>();
+    return m_bufferable_object.has<GC::Ref<JS::DataView>>();
 }
 
 bool BufferableObjectBase::is_array_buffer() const
 {
-    return m_bufferable_object.has<JS::NonnullGCPtr<JS::ArrayBuffer>>();
+    return m_bufferable_object.has<GC::Ref<JS::ArrayBuffer>>();
 }
 
 void BufferableObjectBase::visit_edges(Visitor& visitor)
@@ -86,7 +86,7 @@ ArrayBufferView::~ArrayBufferView() = default;
 u32 ArrayBufferView::byte_offset() const
 {
     return m_bufferable_object.visit(
-        [](JS::NonnullGCPtr<JS::ArrayBuffer>) -> u32 { VERIFY_NOT_REACHED(); },
+        [](GC::Ref<JS::ArrayBuffer>) -> u32 { VERIFY_NOT_REACHED(); },
         [](auto& view) -> u32 { return static_cast<u32>(view->byte_offset()); });
 }
 
diff --git a/Libraries/LibWeb/WebIDL/Buffers.h b/Libraries/LibWeb/WebIDL/Buffers.h
index 2b4ef4fa836..2381e286205 100644
--- a/Libraries/LibWeb/WebIDL/Buffers.h
+++ b/Libraries/LibWeb/WebIDL/Buffers.h
@@ -8,36 +8,36 @@
 #pragma once
 
 #include <AK/Variant.h>
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Forward.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 
 namespace Web::WebIDL {
 
 using BufferableObject = Variant<
-    JS::NonnullGCPtr<JS::TypedArrayBase>,
-    JS::NonnullGCPtr<JS::DataView>,
-    JS::NonnullGCPtr<JS::ArrayBuffer>>;
+    GC::Ref<JS::TypedArrayBase>,
+    GC::Ref<JS::DataView>,
+    GC::Ref<JS::ArrayBuffer>>;
 
 class BufferableObjectBase : public JS::Cell {
-    JS_CELL(BufferableObjectBase, JS::Cell);
-    JS_DECLARE_ALLOCATOR(BufferableObjectBase);
+    GC_CELL(BufferableObjectBase, JS::Cell);
+    GC_DECLARE_ALLOCATOR(BufferableObjectBase);
 
 public:
     virtual ~BufferableObjectBase() override = default;
 
     u32 byte_length() const;
 
-    JS::NonnullGCPtr<JS::Object> raw_object();
-    JS::NonnullGCPtr<JS::Object const> raw_object() const { return const_cast<BufferableObjectBase&>(*this).raw_object(); }
+    GC::Ref<JS::Object> raw_object();
+    GC::Ref<JS::Object const> raw_object() const { return const_cast<BufferableObjectBase&>(*this).raw_object(); }
 
-    JS::GCPtr<JS::ArrayBuffer> viewed_array_buffer();
+    GC::Ptr<JS::ArrayBuffer> viewed_array_buffer();
 
     BufferableObject const& bufferable_object() const { return m_bufferable_object; }
     BufferableObject& bufferable_object() { return m_bufferable_object; }
 
 protected:
-    BufferableObjectBase(JS::NonnullGCPtr<JS::Object>);
+    BufferableObjectBase(GC::Ref<JS::Object>);
 
     virtual void visit_edges(Visitor&) override;
 
@@ -45,7 +45,7 @@ protected:
     bool is_typed_array_base() const;
     bool is_array_buffer() const;
 
-    static BufferableObject bufferable_object_from_raw_object(JS::NonnullGCPtr<JS::Object>);
+    static BufferableObject bufferable_object_from_raw_object(GC::Ref<JS::Object>);
 
     BufferableObject m_bufferable_object;
 };
@@ -57,8 +57,8 @@ protected:
 //          BigInt64Array or BigUint64Array or
 //          Float32Array or Float64Array or DataView) ArrayBufferView;
 class ArrayBufferView : public BufferableObjectBase {
-    JS_CELL(ArrayBufferView, BufferableObjectBase);
-    JS_DECLARE_ALLOCATOR(ArrayBufferView);
+    GC_CELL(ArrayBufferView, BufferableObjectBase);
+    GC_DECLARE_ALLOCATOR(ArrayBufferView);
 
 public:
     using BufferableObjectBase::BufferableObjectBase;
@@ -75,8 +75,8 @@ public:
 //
 // typedef (ArrayBufferView or ArrayBuffer) BufferSource;
 class BufferSource : public BufferableObjectBase {
-    JS_CELL(BufferSource, BufferableObjectBase);
-    JS_DECLARE_ALLOCATOR(BufferSource);
+    GC_CELL(BufferSource, BufferableObjectBase);
+    GC_DECLARE_ALLOCATOR(BufferSource);
 
 public:
     using BufferableObjectBase::BufferableObjectBase;
diff --git a/Libraries/LibWeb/WebIDL/CallbackType.cpp b/Libraries/LibWeb/WebIDL/CallbackType.cpp
index 810569dfe57..ace140af086 100644
--- a/Libraries/LibWeb/WebIDL/CallbackType.cpp
+++ b/Libraries/LibWeb/WebIDL/CallbackType.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::WebIDL {
 
-JS_DEFINE_ALLOCATOR(CallbackType);
+GC_DEFINE_ALLOCATOR(CallbackType);
 
 CallbackType::CallbackType(JS::Object& callback, HTML::EnvironmentSettingsObject& callback_context, OperationReturnsPromise operation_returns_promise)
     : callback(callback)
diff --git a/Libraries/LibWeb/WebIDL/CallbackType.h b/Libraries/LibWeb/WebIDL/CallbackType.h
index 2a6dafab50b..5768975893c 100644
--- a/Libraries/LibWeb/WebIDL/CallbackType.h
+++ b/Libraries/LibWeb/WebIDL/CallbackType.h
@@ -7,8 +7,8 @@
 
 #pragma once
 
+#include <LibGC/CellAllocator.h>
 #include <LibJS/Heap/Cell.h>
-#include <LibJS/Heap/CellAllocator.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::WebIDL {
@@ -20,16 +20,16 @@ enum class OperationReturnsPromise {
 
 // https://webidl.spec.whatwg.org/#idl-callback-interface
 class CallbackType final : public JS::Cell {
-    JS_CELL(CallbackType, JS::Cell);
-    JS_DECLARE_ALLOCATOR(CallbackType);
+    GC_CELL(CallbackType, JS::Cell);
+    GC_DECLARE_ALLOCATOR(CallbackType);
 
 public:
     CallbackType(JS::Object& callback, HTML::EnvironmentSettingsObject& callback_context, OperationReturnsPromise = OperationReturnsPromise::No);
 
-    JS::NonnullGCPtr<JS::Object> callback;
+    GC::Ref<JS::Object> callback;
 
     // https://webidl.spec.whatwg.org/#dfn-callback-context
-    JS::NonnullGCPtr<HTML::EnvironmentSettingsObject> callback_context;
+    GC::Ref<HTML::EnvironmentSettingsObject> callback_context;
 
     // Non-standard property used to distinguish Promise-returning callbacks in callback-related AOs
     OperationReturnsPromise operation_returns_promise;
diff --git a/Libraries/LibWeb/WebIDL/DOMException.cpp b/Libraries/LibWeb/WebIDL/DOMException.cpp
index 3166b41fb8d..acb4d29db9d 100644
--- a/Libraries/LibWeb/WebIDL/DOMException.cpp
+++ b/Libraries/LibWeb/WebIDL/DOMException.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::WebIDL {
 
-JS_DEFINE_ALLOCATOR(DOMException);
+GC_DEFINE_ALLOCATOR(DOMException);
 
-JS::NonnullGCPtr<DOMException> DOMException::create(JS::Realm& realm, FlyString name, String message)
+GC::Ref<DOMException> DOMException::create(JS::Realm& realm, FlyString name, String message)
 {
     return realm.create<DOMException>(realm, move(name), move(message));
 }
 
-JS::NonnullGCPtr<DOMException> DOMException::construct_impl(JS::Realm& realm, String message, FlyString name)
+GC::Ref<DOMException> DOMException::construct_impl(JS::Realm& realm, String message, FlyString name)
 {
     return realm.create<DOMException>(realm, move(name), move(message));
 }
diff --git a/Libraries/LibWeb/WebIDL/DOMException.h b/Libraries/LibWeb/WebIDL/DOMException.h
index 666d099dec1..c004d6789e5 100644
--- a/Libraries/LibWeb/WebIDL/DOMException.h
+++ b/Libraries/LibWeb/WebIDL/DOMException.h
@@ -91,14 +91,14 @@ static u16 get_legacy_code_for_name(FlyString const& name)
 // https://webidl.spec.whatwg.org/#idl-DOMException
 class DOMException final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(DOMException, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(DOMException);
+    GC_DECLARE_ALLOCATOR(DOMException);
 
 public:
-    static JS::NonnullGCPtr<DOMException> create(JS::Realm& realm, FlyString name, String message);
+    static GC::Ref<DOMException> create(JS::Realm& realm, FlyString name, String message);
 
     // JS constructor has message first, name second
     // FIXME: This is a completely pointless footgun, let's use the same order for both factories.
-    static JS::NonnullGCPtr<DOMException> construct_impl(JS::Realm& realm, String message, FlyString name);
+    static GC::Ref<DOMException> construct_impl(JS::Realm& realm, String message, FlyString name);
 
     virtual ~DOMException() override;
 
@@ -116,13 +116,13 @@ private:
     FlyString m_message;
 };
 
-#define __ENUMERATE(ErrorName)                                                                \
-    class ErrorName final {                                                                   \
-    public:                                                                                   \
-        static JS::NonnullGCPtr<DOMException> create(JS::Realm& realm, String const& message) \
-        {                                                                                     \
-            return DOMException::create(realm, #ErrorName##_fly_string, message);             \
-        }                                                                                     \
+#define __ENUMERATE(ErrorName)                                                       \
+    class ErrorName final {                                                          \
+    public:                                                                          \
+        static GC::Ref<DOMException> create(JS::Realm& realm, String const& message) \
+        {                                                                            \
+            return DOMException::create(realm, #ErrorName##_fly_string, message);    \
+        }                                                                            \
     };
 ENUMERATE_DOM_EXCEPTION_ERROR_NAMES
 #undef __ENUMERATE
@@ -131,7 +131,7 @@ ENUMERATE_DOM_EXCEPTION_ERROR_NAMES
 
 namespace Web {
 
-inline JS::Completion throw_completion(JS::NonnullGCPtr<WebIDL::DOMException> exception)
+inline JS::Completion throw_completion(GC::Ref<WebIDL::DOMException> exception)
 {
     return JS::throw_completion(JS::Value(exception));
 }
diff --git a/Libraries/LibWeb/WebIDL/ExceptionOr.h b/Libraries/LibWeb/WebIDL/ExceptionOr.h
index 566222fa581..57de48ca4ee 100644
--- a/Libraries/LibWeb/WebIDL/ExceptionOr.h
+++ b/Libraries/LibWeb/WebIDL/ExceptionOr.h
@@ -32,7 +32,7 @@ struct SimpleException {
     Variant<String, StringView> message;
 };
 
-using Exception = Variant<SimpleException, JS::NonnullGCPtr<DOMException>, JS::Completion>;
+using Exception = Variant<SimpleException, GC::Ref<DOMException>, JS::Completion>;
 
 template<typename ValueType>
 class [[nodiscard]] ExceptionOr {
@@ -63,7 +63,7 @@ public:
     {
     }
 
-    ExceptionOr(JS::NonnullGCPtr<DOMException> exception)
+    ExceptionOr(GC::Ref<DOMException> exception)
         : m_result_or_exception(exception)
     {
     }
@@ -104,7 +104,7 @@ public:
 
     Exception exception() const
     {
-        return m_result_or_exception.template downcast<SimpleException, JS::NonnullGCPtr<DOMException>, JS::Completion>();
+        return m_result_or_exception.template downcast<SimpleException, GC::Ref<DOMException>, JS::Completion>();
     }
 
     bool is_exception() const
@@ -124,7 +124,7 @@ public:
 
 private:
     // https://webidl.spec.whatwg.org/#idl-exceptions
-    Variant<ValueType, SimpleException, JS::NonnullGCPtr<DOMException>, JS::Completion> m_result_or_exception;
+    Variant<ValueType, SimpleException, GC::Ref<DOMException>, JS::Completion> m_result_or_exception;
 };
 
 template<>
diff --git a/Libraries/LibWeb/WebIDL/ObservableArray.cpp b/Libraries/LibWeb/WebIDL/ObservableArray.cpp
index fe074e5240f..0f999f01d68 100644
--- a/Libraries/LibWeb/WebIDL/ObservableArray.cpp
+++ b/Libraries/LibWeb/WebIDL/ObservableArray.cpp
@@ -9,9 +9,9 @@
 
 namespace Web::WebIDL {
 
-JS_DEFINE_ALLOCATOR(ObservableArray);
+GC_DEFINE_ALLOCATOR(ObservableArray);
 
-JS::NonnullGCPtr<ObservableArray> ObservableArray::create(JS::Realm& realm)
+GC::Ref<ObservableArray> ObservableArray::create(JS::Realm& realm)
 {
     auto prototype = realm.intrinsics().array_prototype();
     return realm.create<ObservableArray>(prototype);
@@ -31,12 +31,12 @@ void ObservableArray::visit_edges(JS::Cell::Visitor& visitor)
 
 void ObservableArray::set_on_set_an_indexed_value_callback(SetAnIndexedValueCallbackFunction&& callback)
 {
-    m_on_set_an_indexed_value = create_heap_function(heap(), move(callback));
+    m_on_set_an_indexed_value = GC::create_function(heap(), move(callback));
 }
 
 void ObservableArray::set_on_delete_an_indexed_value_callback(DeleteAnIndexedValueCallbackFunction&& callback)
 {
-    m_on_delete_an_indexed_value = create_heap_function(heap(), move(callback));
+    m_on_delete_an_indexed_value = GC::create_function(heap(), move(callback));
 }
 
 JS::ThrowCompletionOr<bool> ObservableArray::internal_set(JS::PropertyKey const& property_key, JS::Value value, JS::Value receiver, JS::CacheablePropertyMetadata* metadata)
diff --git a/Libraries/LibWeb/WebIDL/ObservableArray.h b/Libraries/LibWeb/WebIDL/ObservableArray.h
index 5131ddefb31..e3dd4e30a26 100644
--- a/Libraries/LibWeb/WebIDL/ObservableArray.h
+++ b/Libraries/LibWeb/WebIDL/ObservableArray.h
@@ -14,10 +14,10 @@ namespace Web::WebIDL {
 // https://webidl.spec.whatwg.org/#idl-observable-array
 class ObservableArray final : public JS::Array {
     JS_OBJECT(ObservableArray, JS::Array);
-    JS_DECLARE_ALLOCATOR(ObservableArray);
+    GC_DECLARE_ALLOCATOR(ObservableArray);
 
 public:
-    static JS::NonnullGCPtr<ObservableArray> create(JS::Realm& realm);
+    static GC::Ref<ObservableArray> create(JS::Realm& realm);
 
     virtual JS::ThrowCompletionOr<bool> internal_set(JS::PropertyKey const& property_key, JS::Value value, JS::Value receiver, JS::CacheablePropertyMetadata* metadata = nullptr) override;
     virtual JS::ThrowCompletionOr<bool> internal_delete(JS::PropertyKey const& property_key) override;
@@ -48,11 +48,11 @@ public:
     virtual void visit_edges(JS::Cell::Visitor&) override;
 
 private:
-    using SetAnIndexedValueCallbackHeapFunction = JS::HeapFunction<SetAnIndexedValueCallbackFunction::FunctionType>;
-    using DeleteAnIndexedValueCallbackHeapFunction = JS::HeapFunction<DeleteAnIndexedValueCallbackFunction::FunctionType>;
+    using SetAnIndexedValueCallbackHeapFunction = GC::Function<SetAnIndexedValueCallbackFunction::FunctionType>;
+    using DeleteAnIndexedValueCallbackHeapFunction = GC::Function<DeleteAnIndexedValueCallbackFunction::FunctionType>;
 
-    JS::GCPtr<SetAnIndexedValueCallbackHeapFunction> m_on_set_an_indexed_value;
-    JS::GCPtr<DeleteAnIndexedValueCallbackHeapFunction> m_on_delete_an_indexed_value;
+    GC::Ptr<SetAnIndexedValueCallbackHeapFunction> m_on_set_an_indexed_value;
+    GC::Ptr<DeleteAnIndexedValueCallbackHeapFunction> m_on_delete_an_indexed_value;
 };
 
 }
diff --git a/Libraries/LibWeb/WebIDL/Promise.cpp b/Libraries/LibWeb/WebIDL/Promise.cpp
index 29f679f8af0..cb2de074f69 100644
--- a/Libraries/LibWeb/WebIDL/Promise.cpp
+++ b/Libraries/LibWeb/WebIDL/Promise.cpp
@@ -6,7 +6,7 @@
 
 #include <AK/Function.h>
 #include <AK/TypeCasts.h>
-#include <LibJS/Heap/HeapFunction.h>
+#include <LibGC/Function.h>
 #include <LibJS/Runtime/PromiseCapability.h>
 #include <LibJS/Runtime/PromiseConstructor.h>
 #include <LibJS/Runtime/Realm.h>
@@ -17,7 +17,7 @@
 namespace Web::WebIDL {
 
 // https://webidl.spec.whatwg.org/#a-new-promise
-JS::NonnullGCPtr<Promise> create_promise(JS::Realm& realm)
+GC::Ref<Promise> create_promise(JS::Realm& realm)
 {
     auto& vm = realm.vm();
 
@@ -30,7 +30,7 @@ JS::NonnullGCPtr<Promise> create_promise(JS::Realm& realm)
 }
 
 // https://webidl.spec.whatwg.org/#a-promise-resolved-with
-JS::NonnullGCPtr<Promise> create_resolved_promise(JS::Realm& realm, JS::Value value)
+GC::Ref<Promise> create_resolved_promise(JS::Realm& realm, JS::Value value)
 {
     auto& vm = realm.vm();
 
@@ -51,7 +51,7 @@ JS::NonnullGCPtr<Promise> create_resolved_promise(JS::Realm& realm, JS::Value va
 }
 
 // https://webidl.spec.whatwg.org/#a-promise-rejected-with
-JS::NonnullGCPtr<Promise> create_rejected_promise(JS::Realm& realm, JS::Value reason)
+GC::Ref<Promise> create_rejected_promise(JS::Realm& realm, JS::Value reason)
 {
     auto& vm = realm.vm();
 
@@ -92,7 +92,7 @@ void reject_promise(JS::Realm& realm, Promise const& promise, JS::Value reason)
 }
 
 // https://webidl.spec.whatwg.org/#dfn-perform-steps-once-promise-is-settled
-JS::NonnullGCPtr<Promise> react_to_promise(Promise const& promise, JS::GCPtr<ReactionSteps> on_fulfilled_callback, JS::GCPtr<ReactionSteps> on_rejected_callback)
+GC::Ref<Promise> react_to_promise(Promise const& promise, GC::Ptr<ReactionSteps> on_fulfilled_callback, GC::Ptr<ReactionSteps> on_rejected_callback)
 {
     auto& realm = promise.promise()->shape().realm();
     auto& vm = realm.vm();
@@ -149,7 +149,7 @@ JS::NonnullGCPtr<Promise> react_to_promise(Promise const& promise, JS::GCPtr<Rea
 }
 
 // https://webidl.spec.whatwg.org/#upon-fulfillment
-JS::NonnullGCPtr<Promise> upon_fulfillment(Promise const& promise, JS::NonnullGCPtr<ReactionSteps> steps)
+GC::Ref<Promise> upon_fulfillment(Promise const& promise, GC::Ref<ReactionSteps> steps)
 {
     // 1. Return the result of reacting to promise:
     return react_to_promise(promise,
@@ -160,7 +160,7 @@ JS::NonnullGCPtr<Promise> upon_fulfillment(Promise const& promise, JS::NonnullGC
 }
 
 // https://webidl.spec.whatwg.org/#upon-rejection
-JS::NonnullGCPtr<Promise> upon_rejection(Promise const& promise, JS::NonnullGCPtr<ReactionSteps> steps)
+GC::Ref<Promise> upon_rejection(Promise const& promise, GC::Ref<ReactionSteps> steps)
 {
     // 1. Return the result of reacting to promise:
     return react_to_promise(promise, {},
@@ -178,10 +178,10 @@ void mark_promise_as_handled(Promise const& promise)
 }
 
 struct WaitForAllResults : JS::Cell {
-    JS_CELL(WaitForAllResults, JS::Cell);
-    JS_DECLARE_ALLOCATOR(WaitForAllResults);
+    GC_CELL(WaitForAllResults, JS::Cell);
+    GC_DECLARE_ALLOCATOR(WaitForAllResults);
 
-    WaitForAllResults(JS::NonnullGCPtr<JS::HeapFunction<void(Vector<JS::Value> const&)>> s, size_t t)
+    WaitForAllResults(GC::Ref<GC::Function<void(Vector<JS::Value> const&)>> s, size_t t)
         : success_steps(s)
         , total(t)
     {
@@ -198,16 +198,16 @@ struct WaitForAllResults : JS::Cell {
         visitor.visit(result);
     }
 
-    JS::NonnullGCPtr<JS::HeapFunction<void(Vector<JS::Value> const&)>> success_steps;
+    GC::Ref<GC::Function<void(Vector<JS::Value> const&)>> success_steps;
     Vector<JS::Value> result;
     size_t total = 0;
     size_t fulfilled_count = 0;
 };
 
-JS_DEFINE_ALLOCATOR(WaitForAllResults);
+GC_DEFINE_ALLOCATOR(WaitForAllResults);
 
 // https://webidl.spec.whatwg.org/#wait-for-all
-void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& promises, Function<void(Vector<JS::Value> const&)> success_steps, Function<void(JS::Value)> failure_steps)
+void wait_for_all(JS::Realm& realm, Vector<GC::Ref<Promise>> const& promises, Function<void(Vector<JS::Value> const&)> success_steps, Function<void(JS::Value)> failure_steps)
 {
     // FIXME: Fix spec typo, fullfilled --> fulfilled
     // 1. Let fullfilledCount be 0.
@@ -217,7 +217,7 @@ void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& pro
     auto rejected = false;
 
     // 3. Let rejectionHandlerSteps be the following steps given arg:
-    auto rejection_handler_steps = [rejected, failure_steps = JS::create_heap_function(realm.heap(), move(failure_steps))](JS::VM& vm) mutable -> JS::ThrowCompletionOr<JS::Value> {
+    auto rejection_handler_steps = [rejected, failure_steps = GC::create_function(realm.heap(), move(failure_steps))](JS::VM& vm) mutable -> JS::ThrowCompletionOr<JS::Value> {
         // 1. If rejected is true, abort these steps.
         if (rejected)
             return JS::js_undefined();
@@ -240,7 +240,7 @@ void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& pro
     // 6. If total is 0, then:
     if (total == 0) {
         // 1. Queue a microtask to perform successSteps given « ».
-        HTML::queue_a_microtask(nullptr, JS::create_heap_function(realm.heap(), [success_steps = JS::create_heap_function(realm.heap(), move(success_steps))] {
+        HTML::queue_a_microtask(nullptr, GC::create_function(realm.heap(), [success_steps = GC::create_function(realm.heap(), move(success_steps))] {
             success_steps->function()({});
         }));
 
@@ -254,7 +254,7 @@ void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& pro
     // 8. Let result be a list containing total null values.
     // Handled in WaitForAllResults
 
-    auto results = realm.create<WaitForAllResults>(JS::create_heap_function(realm.heap(), move(success_steps)), total);
+    auto results = realm.create<WaitForAllResults>(GC::create_function(realm.heap(), move(success_steps)), total);
 
     // 9. For each promise of promises:
     for (auto const& promise : promises) {
@@ -290,7 +290,7 @@ void wait_for_all(JS::Realm& realm, Vector<JS::NonnullGCPtr<Promise>> const& pro
     }
 }
 
-JS::NonnullGCPtr<Promise> create_rejected_promise_from_exception(JS::Realm& realm, Exception exception)
+GC::Ref<Promise> create_rejected_promise_from_exception(JS::Realm& realm, Exception exception)
 {
     auto throw_completion = Bindings::dom_exception_to_throw_completion(realm.vm(), move(exception));
     return WebIDL::create_rejected_promise(realm, *throw_completion.value());
diff --git a/Libraries/LibWeb/WebIDL/Promise.h b/Libraries/LibWeb/WebIDL/Promise.h
index f025b74d46d..555c6f31c3b 100644
--- a/Libraries/LibWeb/WebIDL/Promise.h
+++ b/Libraries/LibWeb/WebIDL/Promise.h
@@ -15,23 +15,23 @@
 
 namespace Web::WebIDL {
 
-using ReactionSteps = JS::HeapFunction<WebIDL::ExceptionOr<JS::Value>(JS::Value)>;
+using ReactionSteps = GC::Function<WebIDL::ExceptionOr<JS::Value>(JS::Value)>;
 
 // https://webidl.spec.whatwg.org/#es-promise
 using Promise = JS::PromiseCapability;
 
-JS::NonnullGCPtr<Promise> create_promise(JS::Realm&);
-JS::NonnullGCPtr<Promise> create_resolved_promise(JS::Realm&, JS::Value);
-JS::NonnullGCPtr<Promise> create_rejected_promise(JS::Realm&, JS::Value);
+GC::Ref<Promise> create_promise(JS::Realm&);
+GC::Ref<Promise> create_resolved_promise(JS::Realm&, JS::Value);
+GC::Ref<Promise> create_rejected_promise(JS::Realm&, JS::Value);
 void resolve_promise(JS::Realm&, Promise const&, JS::Value = JS::js_undefined());
 void reject_promise(JS::Realm&, Promise const&, JS::Value);
-JS::NonnullGCPtr<Promise> react_to_promise(Promise const&, JS::GCPtr<ReactionSteps> on_fulfilled_callback, JS::GCPtr<ReactionSteps> on_rejected_callback);
-JS::NonnullGCPtr<Promise> upon_fulfillment(Promise const&, JS::NonnullGCPtr<ReactionSteps>);
-JS::NonnullGCPtr<Promise> upon_rejection(Promise const&, JS::NonnullGCPtr<ReactionSteps>);
+GC::Ref<Promise> react_to_promise(Promise const&, GC::Ptr<ReactionSteps> on_fulfilled_callback, GC::Ptr<ReactionSteps> on_rejected_callback);
+GC::Ref<Promise> upon_fulfillment(Promise const&, GC::Ref<ReactionSteps>);
+GC::Ref<Promise> upon_rejection(Promise const&, GC::Ref<ReactionSteps>);
 void mark_promise_as_handled(Promise const&);
-void wait_for_all(JS::Realm&, Vector<JS::NonnullGCPtr<Promise>> const& promises, Function<void(Vector<JS::Value> const&)> success_steps, Function<void(JS::Value)> failure_steps);
+void wait_for_all(JS::Realm&, Vector<GC::Ref<Promise>> const& promises, Function<void(Vector<JS::Value> const&)> success_steps, Function<void(JS::Value)> failure_steps);
 
 // Non-spec, convenience method.
-JS::NonnullGCPtr<Promise> create_rejected_promise_from_exception(JS::Realm&, Exception);
+GC::Ref<Promise> create_rejected_promise_from_exception(JS::Realm&, Exception);
 
 }
diff --git a/Libraries/LibWeb/WebSockets/WebSocket.cpp b/Libraries/LibWeb/WebSockets/WebSocket.cpp
index e3795725bcc..930176c8c7a 100644
--- a/Libraries/LibWeb/WebSockets/WebSocket.cpp
+++ b/Libraries/LibWeb/WebSockets/WebSocket.cpp
@@ -31,10 +31,10 @@
 
 namespace Web::WebSockets {
 
-JS_DEFINE_ALLOCATOR(WebSocket);
+GC_DEFINE_ALLOCATOR(WebSocket);
 
 // https://websockets.spec.whatwg.org/#dom-websocket-websocket
-WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> WebSocket::construct_impl(JS::Realm& realm, String const& url, Optional<Variant<String, Vector<String>>> const& protocols)
+WebIDL::ExceptionOr<GC::Ref<WebSocket>> WebSocket::construct_impl(JS::Realm& realm, String const& url, Optional<Variant<String, Vector<String>>> const& protocols)
 {
     auto& vm = realm.vm();
 
@@ -214,7 +214,7 @@ WebIDL::ExceptionOr<void> WebSocket::close(Optional<u16> code, Optional<String>
 }
 
 // https://websockets.spec.whatwg.org/#dom-websocket-send
-WebIDL::ExceptionOr<void> WebSocket::send(Variant<JS::Handle<WebIDL::BufferSource>, JS::Handle<FileAPI::Blob>, String> const& data)
+WebIDL::ExceptionOr<void> WebSocket::send(Variant<GC::Root<WebIDL::BufferSource>, GC::Root<FileAPI::Blob>, String> const& data)
 {
     auto state = ready_state();
     if (state == Requests::WebSocket::ReadyState::Connecting)
@@ -226,14 +226,14 @@ WebIDL::ExceptionOr<void> WebSocket::send(Variant<JS::Handle<WebIDL::BufferSourc
                     m_websocket->send(string);
                     return {};
                 },
-                [this](JS::Handle<WebIDL::BufferSource> const& buffer_source) -> ErrorOr<void> {
+                [this](GC::Root<WebIDL::BufferSource> const& buffer_source) -> ErrorOr<void> {
                     // FIXME: While the spec doesn't say to do this, it's not observable except from potentially throwing OOM.
                     //        Can we avoid this copy?
                     auto data_buffer = TRY(WebIDL::get_buffer_source_copy(*buffer_source->raw_object()));
                     m_websocket->send(data_buffer, false);
                     return {};
                 },
-                [this](JS::Handle<FileAPI::Blob> const& blob) -> ErrorOr<void> {
+                [this](GC::Root<FileAPI::Blob> const& blob) -> ErrorOr<void> {
                     auto byte_buffer = TRY(ByteBuffer::copy(blob->raw_bytes()));
                     m_websocket->send(byte_buffer, false);
                     return {};
diff --git a/Libraries/LibWeb/WebSockets/WebSocket.h b/Libraries/LibWeb/WebSockets/WebSocket.h
index 392a8a01a5b..7626ae452cf 100644
--- a/Libraries/LibWeb/WebSockets/WebSocket.h
+++ b/Libraries/LibWeb/WebSockets/WebSocket.h
@@ -28,10 +28,10 @@ namespace Web::WebSockets {
 
 class WebSocket final : public DOM::EventTarget {
     WEB_PLATFORM_OBJECT(WebSocket, DOM::EventTarget);
-    JS_DECLARE_ALLOCATOR(WebSocket);
+    GC_DECLARE_ALLOCATOR(WebSocket);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<WebSocket>> construct_impl(JS::Realm&, String const& url, Optional<Variant<String, Vector<String>>> const& protocols);
+    static WebIDL::ExceptionOr<GC::Ref<WebSocket>> construct_impl(JS::Realm&, String const& url, Optional<Variant<String, Vector<String>>> const& protocols);
 
     virtual ~WebSocket() override;
 
@@ -53,7 +53,7 @@ public:
     void set_binary_type(String const& type) { m_binary_type = type; }
 
     WebIDL::ExceptionOr<void> close(Optional<u16> code, Optional<String> reason);
-    WebIDL::ExceptionOr<void> send(Variant<JS::Handle<WebIDL::BufferSource>, JS::Handle<FileAPI::Blob>, String> const& data);
+    WebIDL::ExceptionOr<void> send(Variant<GC::Root<WebIDL::BufferSource>, GC::Root<FileAPI::Blob>, String> const& data);
 
 private:
     void on_open();
diff --git a/Libraries/LibWeb/WebVTT/VTTCue.cpp b/Libraries/LibWeb/WebVTT/VTTCue.cpp
index b1fbdc7c758..d7c874648f8 100644
--- a/Libraries/LibWeb/WebVTT/VTTCue.cpp
+++ b/Libraries/LibWeb/WebVTT/VTTCue.cpp
@@ -10,10 +10,10 @@
 
 namespace Web::WebVTT {
 
-JS_DEFINE_ALLOCATOR(VTTCue);
+GC_DEFINE_ALLOCATOR(VTTCue);
 
 // https://w3c.github.io/webvtt/#dom-vttcue-vttcue
-WebIDL::ExceptionOr<JS::NonnullGCPtr<VTTCue>> VTTCue::construct_impl(JS::Realm& realm, double start_time, double end_time, String const& text)
+WebIDL::ExceptionOr<GC::Ref<VTTCue>> VTTCue::construct_impl(JS::Realm& realm, double start_time, double end_time, String const& text)
 {
     // 1. Create a new WebVTT cue. Let cue be that WebVTT cue.
     auto cue = realm.create<VTTCue>(realm, nullptr);
@@ -67,7 +67,7 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<VTTCue>> VTTCue::construct_impl(JS::Realm&
     return cue;
 }
 
-VTTCue::VTTCue(JS::Realm& realm, JS::GCPtr<HTML::TextTrack> track)
+VTTCue::VTTCue(JS::Realm& realm, GC::Ptr<HTML::TextTrack> track)
     : HTML::TextTrackCue(realm, track)
 {
 }
diff --git a/Libraries/LibWeb/WebVTT/VTTCue.h b/Libraries/LibWeb/WebVTT/VTTCue.h
index 71aeb50eb03..e5a0e2360ee 100644
--- a/Libraries/LibWeb/WebVTT/VTTCue.h
+++ b/Libraries/LibWeb/WebVTT/VTTCue.h
@@ -16,7 +16,7 @@ namespace Web::WebVTT {
 // https://w3c.github.io/webvtt/#vttcue
 class VTTCue final : public HTML::TextTrackCue {
     WEB_PLATFORM_OBJECT(VTTCue, HTML::TextTrackCue);
-    JS_DECLARE_ALLOCATOR(VTTCue);
+    GC_DECLARE_ALLOCATOR(VTTCue);
 
 public:
     enum class WritingDirection : u8 {
@@ -30,11 +30,11 @@ public:
         VerticalGrowingRight,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<VTTCue>> construct_impl(JS::Realm&, double start_time, double end_time, String const& text);
+    static WebIDL::ExceptionOr<GC::Ref<VTTCue>> construct_impl(JS::Realm&, double start_time, double end_time, String const& text);
     virtual ~VTTCue() override = default;
 
-    JS::GCPtr<VTTRegion> region() const { return m_region; }
-    void set_region(JS::GCPtr<VTTRegion> region) { m_region = region; }
+    GC::Ptr<VTTRegion> region() const { return m_region; }
+    void set_region(GC::Ptr<VTTRegion> region) { m_region = region; }
 
     Bindings::DirectionSetting vertical() const;
     void set_vertical(Bindings::DirectionSetting);
@@ -61,7 +61,7 @@ protected:
     Bindings::PositionAlignSetting computed_position_alignment();
 
 private:
-    VTTCue(JS::Realm&, JS::GCPtr<HTML::TextTrack>);
+    VTTCue(JS::Realm&, GC::Ptr<HTML::TextTrack>);
 
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Visitor&) override;
@@ -88,7 +88,7 @@ private:
     Bindings::AlignSetting m_text_alignment { Bindings::AlignSetting::Center };
 
     // https://w3c.github.io/webvtt/#webvtt-cue-region
-    JS::GCPtr<VTTRegion> m_region;
+    GC::Ptr<VTTRegion> m_region;
 };
 
 }
diff --git a/Libraries/LibWeb/WebVTT/VTTRegion.cpp b/Libraries/LibWeb/WebVTT/VTTRegion.cpp
index fb789da3958..9e8fd58684a 100644
--- a/Libraries/LibWeb/WebVTT/VTTRegion.cpp
+++ b/Libraries/LibWeb/WebVTT/VTTRegion.cpp
@@ -10,10 +10,10 @@
 
 namespace Web::WebVTT {
 
-JS_DEFINE_ALLOCATOR(VTTRegion);
+GC_DEFINE_ALLOCATOR(VTTRegion);
 
 // https://w3c.github.io/webvtt/#dom-vttregion-vttregion
-WebIDL::ExceptionOr<JS::NonnullGCPtr<VTTRegion>> VTTRegion::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<VTTRegion>> VTTRegion::construct_impl(JS::Realm& realm)
 {
     // 1. Create a new WebVTT region. Let region be that WebVTT region.
     auto region = realm.create<VTTRegion>(realm);
diff --git a/Libraries/LibWeb/WebVTT/VTTRegion.h b/Libraries/LibWeb/WebVTT/VTTRegion.h
index 52f8d232af3..5f8cff8fa65 100644
--- a/Libraries/LibWeb/WebVTT/VTTRegion.h
+++ b/Libraries/LibWeb/WebVTT/VTTRegion.h
@@ -15,10 +15,10 @@ namespace Web::WebVTT {
 // https://w3c.github.io/webvtt/#vttregion
 class VTTRegion final : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(VTTRegion, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(VTTRegion);
+    GC_DECLARE_ALLOCATOR(VTTRegion);
 
 public:
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<VTTRegion>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<VTTRegion>> construct_impl(JS::Realm&);
     virtual ~VTTRegion() override = default;
 
     String const& id() const { return m_identifier; }
diff --git a/Libraries/LibWeb/XHR/FormData.cpp b/Libraries/LibWeb/XHR/FormData.cpp
index 9573347c553..3c1421f75b1 100644
--- a/Libraries/LibWeb/XHR/FormData.cpp
+++ b/Libraries/LibWeb/XHR/FormData.cpp
@@ -15,10 +15,10 @@
 
 namespace Web::XHR {
 
-JS_DEFINE_ALLOCATOR(FormData);
+GC_DEFINE_ALLOCATOR(FormData);
 
 // https://xhr.spec.whatwg.org/#dom-formdata
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> FormData::construct_impl(JS::Realm& realm, JS::GCPtr<HTML::HTMLFormElement> form)
+WebIDL::ExceptionOr<GC::Ref<FormData>> FormData::construct_impl(JS::Realm& realm, GC::Ptr<HTML::HTMLFormElement> form)
 {
     Vector<FormDataEntry> list;
     // 1. If form is given, then:
@@ -35,12 +35,12 @@ WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> FormData::construct_impl(JS::Rea
     return construct_impl(realm, move(list));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> FormData::construct_impl(JS::Realm& realm, Vector<FormDataEntry> entry_list)
+WebIDL::ExceptionOr<GC::Ref<FormData>> FormData::construct_impl(JS::Realm& realm, Vector<FormDataEntry> entry_list)
 {
     return realm.create<FormData>(realm, move(entry_list));
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> FormData::create(JS::Realm& realm, Vector<DOMURL::QueryParam> entry_list)
+WebIDL::ExceptionOr<GC::Ref<FormData>> FormData::create(JS::Realm& realm, Vector<DOMURL::QueryParam> entry_list)
 {
     Vector<FormDataEntry> list;
     list.ensure_capacity(entry_list.size());
@@ -71,7 +71,7 @@ WebIDL::ExceptionOr<void> FormData::append(String const& name, String const& val
 }
 
 // https://xhr.spec.whatwg.org/#dom-formdata-append-blob
-WebIDL::ExceptionOr<void> FormData::append(String const& name, JS::NonnullGCPtr<FileAPI::Blob> const& blob_value, Optional<String> const& filename)
+WebIDL::ExceptionOr<void> FormData::append(String const& name, GC::Ref<FileAPI::Blob> const& blob_value, Optional<String> const& filename)
 {
     auto inner_filename = filename.has_value() ? filename.value() : Optional<String> {};
     return append_impl(name, blob_value, inner_filename);
@@ -79,7 +79,7 @@ WebIDL::ExceptionOr<void> FormData::append(String const& name, JS::NonnullGCPtr<
 
 // https://xhr.spec.whatwg.org/#dom-formdata-append
 // https://xhr.spec.whatwg.org/#dom-formdata-append-blob
-WebIDL::ExceptionOr<void> FormData::append_impl(String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
+WebIDL::ExceptionOr<void> FormData::append_impl(String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
@@ -103,7 +103,7 @@ void FormData::delete_(String const& name)
 }
 
 // https://xhr.spec.whatwg.org/#dom-formdata-get
-Variant<JS::Handle<FileAPI::File>, String, Empty> FormData::get(String const& name)
+Variant<GC::Root<FileAPI::File>, String, Empty> FormData::get(String const& name)
 {
     // 1. If there is no entry whose name is name in this’s entry list, then return null.
     auto entry_iterator = m_entry_list.find_if([&name](FormDataEntry const& entry) {
@@ -145,7 +145,7 @@ WebIDL::ExceptionOr<void> FormData::set(String const& name, String const& value)
 }
 
 // https://xhr.spec.whatwg.org/#dom-formdata-set-blob
-WebIDL::ExceptionOr<void> FormData::set(String const& name, JS::NonnullGCPtr<FileAPI::Blob> const& blob_value, Optional<String> const& filename)
+WebIDL::ExceptionOr<void> FormData::set(String const& name, GC::Ref<FileAPI::Blob> const& blob_value, Optional<String> const& filename)
 {
     auto inner_filename = filename.has_value() ? filename.value() : Optional<String> {};
     return set_impl(name, blob_value, inner_filename);
@@ -153,7 +153,7 @@ WebIDL::ExceptionOr<void> FormData::set(String const& name, JS::NonnullGCPtr<Fil
 
 // https://xhr.spec.whatwg.org/#dom-formdata-set
 // https://xhr.spec.whatwg.org/#dom-formdata-set-blob
-WebIDL::ExceptionOr<void> FormData::set_impl(String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
+WebIDL::ExceptionOr<void> FormData::set_impl(String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename)
 {
     auto& realm = this->realm();
     auto& vm = realm.vm();
diff --git a/Libraries/LibWeb/XHR/FormData.h b/Libraries/LibWeb/XHR/FormData.h
index 7ed5fe3517b..fc37565dd81 100644
--- a/Libraries/LibWeb/XHR/FormData.h
+++ b/Libraries/LibWeb/XHR/FormData.h
@@ -19,24 +19,24 @@ namespace Web::XHR {
 // https://xhr.spec.whatwg.org/#interface-formdata
 class FormData : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(FormData, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(FormData);
+    GC_DECLARE_ALLOCATOR(FormData);
 
 public:
     virtual ~FormData() override;
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> construct_impl(JS::Realm&, JS::GCPtr<HTML::HTMLFormElement> form = {});
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> construct_impl(JS::Realm&, Vector<FormDataEntry> entry_list);
+    static WebIDL::ExceptionOr<GC::Ref<FormData>> construct_impl(JS::Realm&, GC::Ptr<HTML::HTMLFormElement> form = {});
+    static WebIDL::ExceptionOr<GC::Ref<FormData>> construct_impl(JS::Realm&, Vector<FormDataEntry> entry_list);
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<FormData>> create(JS::Realm&, Vector<DOMURL::QueryParam> entry_list);
+    static WebIDL::ExceptionOr<GC::Ref<FormData>> create(JS::Realm&, Vector<DOMURL::QueryParam> entry_list);
 
     WebIDL::ExceptionOr<void> append(String const& name, String const& value);
-    WebIDL::ExceptionOr<void> append(String const& name, JS::NonnullGCPtr<FileAPI::Blob> const& blob_value, Optional<String> const& filename = {});
+    WebIDL::ExceptionOr<void> append(String const& name, GC::Ref<FileAPI::Blob> const& blob_value, Optional<String> const& filename = {});
     void delete_(String const& name);
-    Variant<JS::Handle<FileAPI::File>, String, Empty> get(String const& name);
+    Variant<GC::Root<FileAPI::File>, String, Empty> get(String const& name);
     WebIDL::ExceptionOr<Vector<FormDataEntryValue>> get_all(String const& name);
     bool has(String const& name);
     WebIDL::ExceptionOr<void> set(String const& name, String const& value);
-    WebIDL::ExceptionOr<void> set(String const& name, JS::NonnullGCPtr<FileAPI::Blob> const& blob_value, Optional<String> const& filename = {});
+    WebIDL::ExceptionOr<void> set(String const& name, GC::Ref<FileAPI::Blob> const& blob_value, Optional<String> const& filename = {});
 
     Vector<FormDataEntry> const& entry_list() const { return m_entry_list; }
 
@@ -50,8 +50,8 @@ private:
 
     virtual void initialize(JS::Realm&) override;
 
-    WebIDL::ExceptionOr<void> append_impl(String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
-    WebIDL::ExceptionOr<void> set_impl(String const& name, Variant<JS::NonnullGCPtr<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
+    WebIDL::ExceptionOr<void> append_impl(String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
+    WebIDL::ExceptionOr<void> set_impl(String const& name, Variant<GC::Ref<FileAPI::Blob>, String> const& value, Optional<String> const& filename = {});
 
     Vector<FormDataEntry> m_entry_list;
 };
diff --git a/Libraries/LibWeb/XHR/FormDataEntry.h b/Libraries/LibWeb/XHR/FormDataEntry.h
index bb9974b97aa..5f05b023b4b 100644
--- a/Libraries/LibWeb/XHR/FormDataEntry.h
+++ b/Libraries/LibWeb/XHR/FormDataEntry.h
@@ -8,13 +8,13 @@
 
 #include <AK/String.h>
 #include <AK/Variant.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <LibWeb/Forward.h>
 
 namespace Web::XHR {
 
 // https://xhr.spec.whatwg.org/#formdataentryvalue
-using FormDataEntryValue = Variant<JS::Handle<FileAPI::File>, String>;
+using FormDataEntryValue = Variant<GC::Root<FileAPI::File>, String>;
 
 struct FormDataEntry {
     String name;
diff --git a/Libraries/LibWeb/XHR/FormDataIterator.cpp b/Libraries/LibWeb/XHR/FormDataIterator.cpp
index b4a5295073a..8c6af1362b8 100644
--- a/Libraries/LibWeb/XHR/FormDataIterator.cpp
+++ b/Libraries/LibWeb/XHR/FormDataIterator.cpp
@@ -24,9 +24,9 @@ void Intrinsics::create_web_prototype_and_constructor<FormDataIteratorPrototype>
 
 namespace Web::XHR {
 
-JS_DEFINE_ALLOCATOR(FormDataIterator);
+GC_DEFINE_ALLOCATOR(FormDataIterator);
 
-JS::NonnullGCPtr<FormDataIterator> FormDataIterator::create(FormData const& form_data, JS::Object::PropertyKind iterator_kind)
+GC::Ref<FormDataIterator> FormDataIterator::create(FormData const& form_data, JS::Object::PropertyKind iterator_kind)
 {
     return form_data.realm().create<FormDataIterator>(form_data, iterator_kind);
 }
@@ -64,7 +64,7 @@ JS::Object* FormDataIterator::next()
         return create_iterator_result_object(vm, JS::PrimitiveString::create(vm, entry.name), false);
 
     auto entry_value = entry.value.visit(
-        [&](JS::Handle<FileAPI::File> const& file) -> JS::Value {
+        [&](GC::Root<FileAPI::File> const& file) -> JS::Value {
             return file.cell();
         },
         [&](String const& string) -> JS::Value {
diff --git a/Libraries/LibWeb/XHR/FormDataIterator.h b/Libraries/LibWeb/XHR/FormDataIterator.h
index 5b9a2f21e68..9381e11b0bc 100644
--- a/Libraries/LibWeb/XHR/FormDataIterator.h
+++ b/Libraries/LibWeb/XHR/FormDataIterator.h
@@ -13,10 +13,10 @@ namespace Web::XHR {
 
 class FormDataIterator : public Bindings::PlatformObject {
     WEB_PLATFORM_OBJECT(FormDataIterator, Bindings::PlatformObject);
-    JS_DECLARE_ALLOCATOR(FormDataIterator);
+    GC_DECLARE_ALLOCATOR(FormDataIterator);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<FormDataIterator> create(FormData const&, JS::Object::PropertyKind iterator_kind);
+    [[nodiscard]] static GC::Ref<FormDataIterator> create(FormData const&, JS::Object::PropertyKind iterator_kind);
 
     virtual ~FormDataIterator() override;
 
@@ -28,7 +28,7 @@ private:
     virtual void initialize(JS::Realm&) override;
     virtual void visit_edges(Cell::Visitor&) override;
 
-    JS::NonnullGCPtr<FormData const> m_form_data;
+    GC::Ref<FormData const> m_form_data;
     JS::Object::PropertyKind m_iterator_kind;
     size_t m_index { 0 };
 };
diff --git a/Libraries/LibWeb/XHR/ProgressEvent.cpp b/Libraries/LibWeb/XHR/ProgressEvent.cpp
index 2cf148334de..a865c47ab6a 100644
--- a/Libraries/LibWeb/XHR/ProgressEvent.cpp
+++ b/Libraries/LibWeb/XHR/ProgressEvent.cpp
@@ -10,14 +10,14 @@
 
 namespace Web::XHR {
 
-JS_DEFINE_ALLOCATOR(ProgressEvent);
+GC_DEFINE_ALLOCATOR(ProgressEvent);
 
-JS::NonnullGCPtr<ProgressEvent> ProgressEvent::create(JS::Realm& realm, FlyString const& event_name, ProgressEventInit const& event_init)
+GC::Ref<ProgressEvent> ProgressEvent::create(JS::Realm& realm, FlyString const& event_name, ProgressEventInit const& event_init)
 {
     return realm.create<ProgressEvent>(realm, event_name, event_init);
 }
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<ProgressEvent>> ProgressEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ProgressEventInit const& event_init)
+WebIDL::ExceptionOr<GC::Ref<ProgressEvent>> ProgressEvent::construct_impl(JS::Realm& realm, FlyString const& event_name, ProgressEventInit const& event_init)
 {
     return create(realm, event_name, event_init);
 }
diff --git a/Libraries/LibWeb/XHR/ProgressEvent.h b/Libraries/LibWeb/XHR/ProgressEvent.h
index b61a3276cab..d2856fe4a15 100644
--- a/Libraries/LibWeb/XHR/ProgressEvent.h
+++ b/Libraries/LibWeb/XHR/ProgressEvent.h
@@ -20,11 +20,11 @@ struct ProgressEventInit : public DOM::EventInit {
 
 class ProgressEvent final : public DOM::Event {
     WEB_PLATFORM_OBJECT(ProgressEvent, DOM::Event);
-    JS_DECLARE_ALLOCATOR(ProgressEvent);
+    GC_DECLARE_ALLOCATOR(ProgressEvent);
 
 public:
-    [[nodiscard]] static JS::NonnullGCPtr<ProgressEvent> create(JS::Realm&, FlyString const& event_name, ProgressEventInit const& event_init);
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<ProgressEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ProgressEventInit const& event_init);
+    [[nodiscard]] static GC::Ref<ProgressEvent> create(JS::Realm&, FlyString const& event_name, ProgressEventInit const& event_init);
+    static WebIDL::ExceptionOr<GC::Ref<ProgressEvent>> construct_impl(JS::Realm&, FlyString const& event_name, ProgressEventInit const& event_init);
 
     virtual ~ProgressEvent() override;
 
diff --git a/Libraries/LibWeb/XHR/XMLHttpRequest.cpp b/Libraries/LibWeb/XHR/XMLHttpRequest.cpp
index 39c5140e022..e0b3c127273 100644
--- a/Libraries/LibWeb/XHR/XMLHttpRequest.cpp
+++ b/Libraries/LibWeb/XHR/XMLHttpRequest.cpp
@@ -56,9 +56,9 @@
 
 namespace Web::XHR {
 
-JS_DEFINE_ALLOCATOR(XMLHttpRequest);
+GC_DEFINE_ALLOCATOR(XMLHttpRequest);
 
-WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLHttpRequest>> XMLHttpRequest::construct_impl(JS::Realm& realm)
+WebIDL::ExceptionOr<GC::Ref<XMLHttpRequest>> XMLHttpRequest::construct_impl(JS::Realm& realm)
 {
     auto upload_object = realm.create<XMLHttpRequestUpload>(realm);
     auto author_request_headers = Fetch::Infrastructure::HeaderList::create(realm.vm());
@@ -95,7 +95,7 @@ void XMLHttpRequest::visit_edges(Cell::Visitor& visitor)
     visitor.visit(m_response);
     visitor.visit(m_fetch_controller);
 
-    if (auto* value = m_response_object.get_pointer<JS::NonnullGCPtr<JS::Object>>())
+    if (auto* value = m_response_object.get_pointer<GC::Ref<JS::Object>>())
         visitor.visit(*value);
 }
 
@@ -129,7 +129,7 @@ WebIDL::ExceptionOr<String> XMLHttpRequest::response_text() const
 }
 
 // https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsexml
-WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> XMLHttpRequest::response_xml()
+WebIDL::ExceptionOr<GC::Ptr<DOM::Document>> XMLHttpRequest::response_xml()
 {
     // 1. If this’s response type is not the empty string or "document", then throw an "InvalidStateError" DOMException.
     if (m_response_type != Bindings::XMLHttpRequestResponseType::Empty && m_response_type != Bindings::XMLHttpRequestResponseType::Document)
@@ -144,7 +144,7 @@ WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> XMLHttpRequest::response_xml()
 
     // 4. If this’s response object is non-null, then return it.
     if (!m_response_object.has<Empty>())
-        return &verify_cast<DOM::Document>(*m_response_object.get<JS::NonnullGCPtr<JS::Object>>());
+        return &verify_cast<DOM::Document>(*m_response_object.get<GC::Ref<JS::Object>>());
 
     // 5. Set a document response for this.
     set_document_response();
@@ -152,7 +152,7 @@ WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> XMLHttpRequest::response_xml()
     // 6. Return this’s response object.
     if (m_response_object.has<Empty>())
         return nullptr;
-    return &verify_cast<DOM::Document>(*m_response_object.get<JS::NonnullGCPtr<JS::Object>>());
+    return &verify_cast<DOM::Document>(*m_response_object.get<GC::Ref<JS::Object>>());
 }
 
 // https://xhr.spec.whatwg.org/#dom-xmlhttprequest-responsetype
@@ -199,7 +199,7 @@ WebIDL::ExceptionOr<JS::Value> XMLHttpRequest::response()
 
     // 4. If this’s response object is non-null, then return it.
     if (!m_response_object.has<Empty>())
-        return m_response_object.get<JS::NonnullGCPtr<JS::Object>>();
+        return m_response_object.get<GC::Ref<JS::Object>>();
 
     // 5. If this’s response type is "arraybuffer",
     if (m_response_type == Bindings::XMLHttpRequestResponseType::Arraybuffer) {
@@ -212,14 +212,14 @@ WebIDL::ExceptionOr<JS::Value> XMLHttpRequest::response()
 
         auto buffer = buffer_result.release_value();
         buffer->buffer().overwrite(0, m_received_bytes.data(), m_received_bytes.size());
-        m_response_object = JS::NonnullGCPtr<JS::Object> { buffer };
+        m_response_object = GC::Ref<JS::Object> { buffer };
     }
     // 6. Otherwise, if this’s response type is "blob", set this’s response object to a new Blob object representing this’s received bytes with type set to the result of get a final MIME type for this.
     else if (m_response_type == Bindings::XMLHttpRequestResponseType::Blob) {
         auto mime_type_as_string = get_final_mime_type().serialized();
         auto blob_part = FileAPI::Blob::create(realm(), m_received_bytes, move(mime_type_as_string));
-        auto blob = FileAPI::Blob::create(realm(), Vector<FileAPI::BlobPart> { JS::make_handle(*blob_part) });
-        m_response_object = JS::NonnullGCPtr<JS::Object> { blob };
+        auto blob = FileAPI::Blob::create(realm(), Vector<FileAPI::BlobPart> { GC::make_root(*blob_part) });
+        m_response_object = GC::Ref<JS::Object> { blob };
     }
     // 7. Otherwise, if this’s response type is "document", set a document response for this.
     else if (m_response_type == Bindings::XMLHttpRequestResponseType::Document) {
@@ -241,14 +241,14 @@ WebIDL::ExceptionOr<JS::Value> XMLHttpRequest::response()
 
         // 4. Set this’s response object to jsonObject.
         if (json_object_result.value().is_object())
-            m_response_object = JS::NonnullGCPtr<JS::Object> { json_object_result.release_value().as_object() };
+            m_response_object = GC::Ref<JS::Object> { json_object_result.release_value().as_object() };
         else
             m_response_object = Empty {};
     }
 
     // 9. Return this’s response object.
     return m_response_object.visit(
-        [](JS::NonnullGCPtr<JS::Object> object) -> JS::Value { return object; },
+        [](GC::Ref<JS::Object> object) -> JS::Value { return object; },
         [](auto const&) -> JS::Value { return JS::js_null(); });
 }
 
@@ -300,7 +300,7 @@ void XMLHttpRequest::set_document_response()
 
     // 5. If finalMIME is an HTML MIME type, then:
     Optional<String> charset;
-    JS::GCPtr<DOM::Document> document;
+    GC::Ptr<DOM::Document> document;
     if (final_mime.is_html()) {
         // 5.1. Let charset be the result of get a final encoding for xhr.
         if (auto final_encoding = get_final_encoding(); final_encoding.has_value())
@@ -350,7 +350,7 @@ void XMLHttpRequest::set_document_response()
     document->set_origin(HTML::relevant_settings_object(*this).origin());
 
     // 12. Set xhr’s response object to document.
-    m_response_object = JS::NonnullGCPtr<JS::Object> { *document };
+    m_response_object = GC::Ref<JS::Object> { *document };
 }
 
 // https://xhr.spec.whatwg.org/#final-mime-type
@@ -572,8 +572,8 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         Optional<ByteBuffer> extracted_content_type;
 
         // 2. If body is a Document, then set this’s request body to body, serialized, converted, and UTF-8 encoded.
-        if (body->has<JS::Handle<DOM::Document>>()) {
-            auto string_serialized_document = TRY(body->get<JS::Handle<DOM::Document>>().cell()->serialize_fragment(DOMParsing::RequireWellFormed::No));
+        if (body->has<GC::Root<DOM::Document>>()) {
+            auto string_serialized_document = TRY(body->get<GC::Root<DOM::Document>>().cell()->serialize_fragment(DOMParsing::RequireWellFormed::No));
             m_request_body = TRY(Fetch::Infrastructure::byte_sequence_as_body(realm, string_serialized_document.bytes()));
         }
         // 3. Otherwise:
@@ -594,7 +594,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         // 5. If originalAuthorContentType is non-null, then:
         if (original_author_content_type.has_value()) {
             // 1. If body is a Document or a USVString, then:
-            if (body->has<JS::Handle<DOM::Document>>() || body->has<String>()) {
+            if (body->has<GC::Root<DOM::Document>>() || body->has<String>()) {
                 // 1. Let contentTypeRecord be the result of parsing originalAuthorContentType.
                 auto content_type_record = MimeSniff::MimeType::parse(original_author_content_type.value());
 
@@ -617,8 +617,8 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         }
         // 6. Otherwise:
         else {
-            if (body->has<JS::Handle<DOM::Document>>()) {
-                auto document = body->get<JS::Handle<DOM::Document>>();
+            if (body->has<GC::Root<DOM::Document>>()) {
+                auto document = body->get<GC::Root<DOM::Document>>();
 
                 // NOTE: A document can only be an HTML document or XML document.
                 // 1. If body is an HTML document, then set (`Content-Type`, `text/html;charset=UTF-8`) in this’s author request headers.
@@ -667,7 +667,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
     // body
     //    This’s request body.
     if (m_request_body)
-        request->set_body(JS::NonnullGCPtr { *m_request_body });
+        request->set_body(GC::Ref { *m_request_body });
 
     // client
     //    This’s relevant settings object.
@@ -738,7 +738,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
 
         // 7. Let processRequestBodyChunkLength, given a bytesLength, be these steps:
         // NOTE: request_body_length is captured by copy as to not UAF it when we leave `send()` and the callback gets called.
-        // NOTE: `this` is kept alive by FetchAlgorithms using JS::HeapFunction.
+        // NOTE: `this` is kept alive by FetchAlgorithms using GC::HeapFunction.
         auto process_request_body_chunk_length = [this, request_body_length](u64 bytes_length) {
             // 1. Increase requestBodyTransmitted by bytesLength.
             m_request_body_transmitted += bytes_length;
@@ -752,7 +752,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
 
         // 8. Let processRequestEndOfBody be these steps:
         // NOTE: request_body_length is captured by copy as to not UAF it when we leave `send()` and the callback gets called.
-        // NOTE: `this` is kept alive by FetchAlgorithms using JS::HeapFunction.
+        // NOTE: `this` is kept alive by FetchAlgorithms using GC::HeapFunction.
         auto process_request_end_of_body = [this, request_body_length]() {
             // 1. Set this’s upload complete flag.
             m_upload_complete = true;
@@ -772,8 +772,8 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         };
 
         // 9. Let processResponse, given a response, be these steps:
-        // NOTE: `this` is kept alive by FetchAlgorithms using JS::HeapFunction.
-        auto process_response = [this](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response) {
+        // NOTE: `this` is kept alive by FetchAlgorithms using GC::HeapFunction.
+        auto process_response = [this](GC::Ref<Fetch::Infrastructure::Response> response) {
             // 1. Set this’s response to response.
             m_response = response;
 
@@ -816,7 +816,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
             // FIXME: We can't implement these steps yet, as we don't fully implement the Streams standard.
 
             // 10. Let processBodyChunk given bytes be these steps:
-            auto process_body_chunks = JS::create_heap_function(heap(), [this, length](ByteBuffer byte_buffer) {
+            auto process_body_chunks = GC::create_function(heap(), [this, length](ByteBuffer byte_buffer) {
                 // 1. Append bytes to this’s received bytes.
                 m_received_bytes.append(byte_buffer);
 
@@ -835,14 +835,14 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
             });
 
             // 11. Let processEndOfBody be this step: run handle response end-of-body for this.
-            auto process_end_of_body = JS::create_heap_function(heap(), [this]() {
+            auto process_end_of_body = GC::create_function(heap(), [this]() {
                 // NOTE: This cannot throw, as `handle_response_end_of_body` only throws in a synchronous context.
                 // FIXME: However, we can receive allocation failures, but we can't propagate them anywhere currently.
                 handle_response_end_of_body().release_value_but_fixme_should_propagate_errors();
             });
 
             // 12. Let processBodyError be these steps:
-            auto process_body_error = JS::create_heap_function(heap(), [this](JS::Value) {
+            auto process_body_error = GC::create_function(heap(), [this](JS::Value) {
                 auto& vm = this->vm();
                 // 1. Set this’s response to a network error.
                 m_response = Fetch::Infrastructure::Response::network_error(vm, "A network error occurred processing body."sv);
@@ -853,7 +853,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
             });
 
             // 13. Incrementally read this’s response’s body, given processBodyChunk, processEndOfBody, processBodyError, and this’s relevant global object.
-            auto global_object = JS::NonnullGCPtr<JS::Object> { HTML::relevant_global_object(*this) };
+            auto global_object = GC::Ref<JS::Object> { HTML::relevant_global_object(*this) };
             response->body()->incrementally_read(process_body_chunks, process_end_of_body, process_body_error, global_object);
         };
 
@@ -880,7 +880,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
 
             // NOTE: `timer` is kept alive by capturing into the lambda for the GC to see
             // NOTE: `this` and `request` is kept alive by Platform::Timer using a Handle.
-            timer->on_timeout = JS::create_heap_function(heap(), [this, request, timer = JS::make_handle(timer)]() {
+            timer->on_timeout = GC::create_function(heap(), [this, request, timer = GC::make_root(timer)]() {
                 (void)timer;
                 if (!request->done()) {
                     m_timed_out = true;
@@ -895,7 +895,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         bool processed_response = false;
 
         // 2. Let processResponseConsumeBody, given a response and nullOrFailureOrBytes, be these steps:
-        auto process_response_consume_body = [this, &processed_response](JS::NonnullGCPtr<Fetch::Infrastructure::Response> response, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> null_or_failure_or_bytes) {
+        auto process_response_consume_body = [this, &processed_response](GC::Ref<Fetch::Infrastructure::Response> response, Variant<Empty, Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag, ByteBuffer> null_or_failure_or_bytes) {
             // 1. If nullOrFailureOrBytes is not failure, then set this’s response to response.
             if (!null_or_failure_or_bytes.has<Fetch::Infrastructure::FetchAlgorithms::ConsumeBodyFailureTag>())
                 m_response = response;
@@ -933,7 +933,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
             auto timer = Platform::Timer::create_single_shot(heap(), m_timeout, nullptr);
 
             // NOTE: `timer` is kept alive by capturing into the lambda for the GC to see
-            timer->on_timeout = JS::create_heap_function(heap(), [timer = JS::make_handle(timer), &did_time_out]() {
+            timer->on_timeout = GC::create_function(heap(), [timer = GC::make_root(timer), &did_time_out]() {
                 (void)timer;
                 did_time_out = true;
             });
@@ -942,7 +942,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::send(Optional<DocumentOrXMLHttpRequest
         }
 
         // FIXME: This is not exactly correct, as it allows the HTML event loop to continue executing tasks.
-        Platform::EventLoopPlugin::the().spin_until(JS::create_heap_function(heap(), [&]() {
+        Platform::EventLoopPlugin::the().spin_until(GC::create_function(heap(), [&]() {
             return processed_response || did_time_out;
         }));
 
@@ -1145,7 +1145,7 @@ void XMLHttpRequest::abort()
 }
 
 // https://xhr.spec.whatwg.org/#dom-xmlhttprequest-upload
-JS::NonnullGCPtr<XMLHttpRequestUpload> XMLHttpRequest::upload() const
+GC::Ref<XMLHttpRequestUpload> XMLHttpRequest::upload() const
 {
     // The upload getter steps are to return this’s upload object.
     return m_upload_object;
@@ -1236,7 +1236,7 @@ WebIDL::ExceptionOr<void> XMLHttpRequest::handle_errors()
     return {};
 }
 
-JS::ThrowCompletionOr<void> XMLHttpRequest::request_error_steps(FlyString const& event_name, JS::GCPtr<WebIDL::DOMException> exception)
+JS::ThrowCompletionOr<void> XMLHttpRequest::request_error_steps(FlyString const& event_name, GC::Ptr<WebIDL::DOMException> exception)
 {
     // 1. Set xhr’s state to done.
     m_state = State::Done;
diff --git a/Libraries/LibWeb/XHR/XMLHttpRequest.h b/Libraries/LibWeb/XHR/XMLHttpRequest.h
index 53031cf99cd..accd6b75968 100644
--- a/Libraries/LibWeb/XHR/XMLHttpRequest.h
+++ b/Libraries/LibWeb/XHR/XMLHttpRequest.h
@@ -26,11 +26,11 @@
 namespace Web::XHR {
 
 // https://fetch.spec.whatwg.org/#typedefdef-xmlhttprequestbodyinit
-using DocumentOrXMLHttpRequestBodyInit = Variant<JS::Handle<Web::DOM::Document>, JS::Handle<Web::FileAPI::Blob>, JS::Handle<WebIDL::BufferSource>, JS::Handle<XHR::FormData>, JS::Handle<Web::DOMURL::URLSearchParams>, AK::String>;
+using DocumentOrXMLHttpRequestBodyInit = Variant<GC::Root<Web::DOM::Document>, GC::Root<Web::FileAPI::Blob>, GC::Root<WebIDL::BufferSource>, GC::Root<XHR::FormData>, GC::Root<Web::DOMURL::URLSearchParams>, AK::String>;
 
 class XMLHttpRequest final : public XMLHttpRequestEventTarget {
     WEB_PLATFORM_OBJECT(XMLHttpRequest, XMLHttpRequestEventTarget);
-    JS_DECLARE_ALLOCATOR(XMLHttpRequest);
+    GC_DECLARE_ALLOCATOR(XMLHttpRequest);
 
 public:
     enum class State : u16 {
@@ -41,7 +41,7 @@ public:
         Done = 4,
     };
 
-    static WebIDL::ExceptionOr<JS::NonnullGCPtr<XMLHttpRequest>> construct_impl(JS::Realm&);
+    static WebIDL::ExceptionOr<GC::Ref<XMLHttpRequest>> construct_impl(JS::Realm&);
 
     virtual ~XMLHttpRequest() override;
 
@@ -49,7 +49,7 @@ public:
     Fetch::Infrastructure::Status status() const;
     WebIDL::ExceptionOr<String> status_text() const;
     WebIDL::ExceptionOr<String> response_text() const;
-    WebIDL::ExceptionOr<JS::GCPtr<DOM::Document>> response_xml();
+    WebIDL::ExceptionOr<GC::Ptr<DOM::Document>> response_xml();
     WebIDL::ExceptionOr<JS::Value> response();
     Bindings::XMLHttpRequestResponseType response_type() const { return m_response_type; }
     String response_url();
@@ -77,7 +77,7 @@ public:
 
     void abort();
 
-    JS::NonnullGCPtr<XMLHttpRequestUpload> upload() const;
+    GC::Ref<XMLHttpRequestUpload> upload() const;
 
 private:
     virtual void initialize(JS::Realm&) override;
@@ -93,14 +93,14 @@ private:
 
     WebIDL::ExceptionOr<void> handle_response_end_of_body();
     WebIDL::ExceptionOr<void> handle_errors();
-    JS::ThrowCompletionOr<void> request_error_steps(FlyString const& event_name, JS::GCPtr<WebIDL::DOMException> exception = nullptr);
+    JS::ThrowCompletionOr<void> request_error_steps(FlyString const& event_name, GC::Ptr<WebIDL::DOMException> exception = nullptr);
 
     XMLHttpRequest(JS::Realm&, XMLHttpRequestUpload&, Fetch::Infrastructure::HeaderList&, Fetch::Infrastructure::Response&, Fetch::Infrastructure::FetchController&);
 
     // https://xhr.spec.whatwg.org/#upload-object
     // upload object
     //     An XMLHttpRequestUpload object.
-    JS::NonnullGCPtr<XMLHttpRequestUpload> m_upload_object;
+    GC::Ref<XMLHttpRequestUpload> m_upload_object;
 
     // https://xhr.spec.whatwg.org/#concept-xmlhttprequest-state
     // state
@@ -135,12 +135,12 @@ private:
     // https://xhr.spec.whatwg.org/#author-request-headers
     // author request headers
     //     A header list, initially empty.
-    JS::NonnullGCPtr<Fetch::Infrastructure::HeaderList> m_author_request_headers;
+    GC::Ref<Fetch::Infrastructure::HeaderList> m_author_request_headers;
 
     // https://xhr.spec.whatwg.org/#request-body
     // request body
     //     Initially null.
-    JS::GCPtr<Fetch::Infrastructure::Body> m_request_body;
+    GC::Ptr<Fetch::Infrastructure::Body> m_request_body;
 
     // https://xhr.spec.whatwg.org/#synchronous-flag
     // synchronous flag
@@ -165,7 +165,7 @@ private:
     // https://xhr.spec.whatwg.org/#response
     // response
     //     A response, initially a network error.
-    JS::NonnullGCPtr<Fetch::Infrastructure::Response> m_response;
+    GC::Ref<Fetch::Infrastructure::Response> m_response;
 
     // https://xhr.spec.whatwg.org/#received-bytes
     // received bytes
@@ -185,13 +185,13 @@ private:
     // response object
     //     An object, failure, or null, initially null.
     //     NOTE: This needs to be a JS::Value as the JSON response might not actually be an object.
-    Variant<JS::NonnullGCPtr<JS::Object>, Failure, Empty> m_response_object;
+    Variant<GC::Ref<JS::Object>, Failure, Empty> m_response_object;
 
     // https://xhr.spec.whatwg.org/#xmlhttprequest-fetch-controller
     // fetch controller
     //     A fetch controller, initially a new fetch controller.
     //     NOTE: The send() method sets it to a useful fetch controller, but for simplicity it always holds a fetch controller.
-    JS::NonnullGCPtr<Fetch::Infrastructure::FetchController> m_fetch_controller;
+    GC::Ref<Fetch::Infrastructure::FetchController> m_fetch_controller;
 
     // https://xhr.spec.whatwg.org/#override-mime-type
     // override MIME type
diff --git a/Libraries/LibWeb/XHR/XMLHttpRequestUpload.cpp b/Libraries/LibWeb/XHR/XMLHttpRequestUpload.cpp
index 1da8dab95a7..df79fac08b3 100644
--- a/Libraries/LibWeb/XHR/XMLHttpRequestUpload.cpp
+++ b/Libraries/LibWeb/XHR/XMLHttpRequestUpload.cpp
@@ -10,7 +10,7 @@
 
 namespace Web::XHR {
 
-JS_DEFINE_ALLOCATOR(XMLHttpRequestUpload);
+GC_DEFINE_ALLOCATOR(XMLHttpRequestUpload);
 
 XMLHttpRequestUpload::XMLHttpRequestUpload(JS::Realm& realm)
     : XMLHttpRequestEventTarget(realm)
diff --git a/Libraries/LibWeb/XHR/XMLHttpRequestUpload.h b/Libraries/LibWeb/XHR/XMLHttpRequestUpload.h
index b5c22ee5500..4e47f9fc2d1 100644
--- a/Libraries/LibWeb/XHR/XMLHttpRequestUpload.h
+++ b/Libraries/LibWeb/XHR/XMLHttpRequestUpload.h
@@ -12,7 +12,7 @@ namespace Web::XHR {
 
 class XMLHttpRequestUpload : public XMLHttpRequestEventTarget {
     WEB_PLATFORM_OBJECT(XMLHttpRequestUpload, XMLHttpRequestEventTarget);
-    JS_DECLARE_ALLOCATOR(XMLHttpRequestUpload);
+    GC_DECLARE_ALLOCATOR(XMLHttpRequestUpload);
 
 public:
     virtual ~XMLHttpRequestUpload() override;
diff --git a/Libraries/LibWeb/XML/XMLDocumentBuilder.cpp b/Libraries/LibWeb/XML/XMLDocumentBuilder.cpp
index 01c4ffbf5c1..3e8b1be02fd 100644
--- a/Libraries/LibWeb/XML/XMLDocumentBuilder.cpp
+++ b/Libraries/LibWeb/XML/XMLDocumentBuilder.cpp
@@ -177,7 +177,7 @@ void XMLDocumentBuilder::element_end(const XML::Name& name)
 
             // 2. Spin the event loop until the parser's Document has no style sheet that is blocking scripts and the pending parsing-blocking script's "ready to be parser-executed" flag is set.
             if (m_document->has_a_style_sheet_that_is_blocking_scripts() || !pending_parsing_blocking_script->is_ready_to_be_parser_executed()) {
-                HTML::main_thread_event_loop().spin_until(JS::create_heap_function(script_element.heap(), [&] {
+                HTML::main_thread_event_loop().spin_until(GC::create_function(script_element.heap(), [&] {
                     return !m_document->has_a_style_sheet_that_is_blocking_scripts() && pending_parsing_blocking_script->is_ready_to_be_parser_executed();
                 }));
             }
@@ -250,7 +250,7 @@ void XMLDocumentBuilder::document_end()
     while (!m_document->scripts_to_execute_when_parsing_has_finished().is_empty()) {
         // Spin the event loop until the first script in the list of scripts that will execute when the document has finished parsing has its "ready to be parser-executed" flag set
         // and the parser's Document has no style sheet that is blocking scripts.
-        HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+        HTML::main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
             return m_document->scripts_to_execute_when_parsing_has_finished().first()->is_ready_to_be_parser_executed()
                 && !m_document->has_a_style_sheet_that_is_blocking_scripts();
         }));
@@ -262,7 +262,7 @@ void XMLDocumentBuilder::document_end()
         (void)m_document->scripts_to_execute_when_parsing_has_finished().take_first();
     }
     // Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following substeps:
-    queue_global_task(HTML::Task::Source::DOMManipulation, m_document, JS::create_heap_function(m_document->heap(), [document = m_document] {
+    queue_global_task(HTML::Task::Source::DOMManipulation, m_document, GC::create_function(m_document->heap(), [document = m_document] {
         // Set the Document's load timing info's DOM content loaded event start time to the current high resolution time given the Document's relevant global object.
         document->load_timing_info().dom_content_loaded_event_start_time = HighResolutionTime::current_high_resolution_time(relevant_global_object(*document));
 
@@ -280,17 +280,17 @@ void XMLDocumentBuilder::document_end()
     }));
 
     // Spin the event loop until the set of scripts that will execute as soon as possible and the list of scripts that will execute in order as soon as possible are empty.
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
         return m_document->scripts_to_execute_as_soon_as_possible().is_empty();
     }));
 
     // Spin the event loop until there is nothing that delays the load event in the Document.
-    HTML::main_thread_event_loop().spin_until(JS::create_heap_function(heap, [&] {
+    HTML::main_thread_event_loop().spin_until(GC::create_function(heap, [&] {
         return !m_document->anything_is_delaying_the_load_event();
     }));
 
     // Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following steps:
-    queue_global_task(HTML::Task::Source::DOMManipulation, m_document, JS::create_heap_function(m_document->heap(), [document = m_document] {
+    queue_global_task(HTML::Task::Source::DOMManipulation, m_document, GC::create_function(m_document->heap(), [document = m_document] {
         // Update the current document readiness to "complete".
         document->update_readiness(HTML::DocumentReadyState::Complete);
 
@@ -299,7 +299,7 @@ void XMLDocumentBuilder::document_end()
             return;
 
         // Let window be the Document's relevant global object.
-        JS::NonnullGCPtr<HTML::Window> window = verify_cast<HTML::Window>(relevant_global_object(*document));
+        GC::Ref<HTML::Window> window = verify_cast<HTML::Window>(relevant_global_object(*document));
 
         // Set the Document's load timing info's load event start time to the current high resolution time given window.
         document->load_timing_info().load_event_start_time = HighResolutionTime::current_high_resolution_time(window);
diff --git a/Libraries/LibWeb/XML/XMLDocumentBuilder.h b/Libraries/LibWeb/XML/XMLDocumentBuilder.h
index 2bfe8811e4e..3571e4862bd 100644
--- a/Libraries/LibWeb/XML/XMLDocumentBuilder.h
+++ b/Libraries/LibWeb/XML/XMLDocumentBuilder.h
@@ -38,8 +38,8 @@ private:
     virtual void comment(StringView data) override;
     virtual void document_end() override;
 
-    JS::NonnullGCPtr<DOM::Document> m_document;
-    JS::GCPtr<DOM::Node> m_current_node;
+    GC::Ref<DOM::Document> m_document;
+    GC::Ptr<DOM::Node> m_current_node;
     XMLScriptingSupport m_scripting_support { XMLScriptingSupport::Enabled };
     bool m_has_error { false };
     StringBuilder text_builder;
diff --git a/Meta/Lagom/CMakeLists.txt b/Meta/Lagom/CMakeLists.txt
index 126cd44881d..bb59a8bcb2b 100644
--- a/Meta/Lagom/CMakeLists.txt
+++ b/Meta/Lagom/CMakeLists.txt
@@ -382,6 +382,7 @@ set(lagom_standard_libraries
     Compress
     Crypto
     Diff
+    GC
     HTTP
     IPC
     JS
@@ -453,13 +454,13 @@ if (ENABLE_GUI_TARGETS)
     lagom_utility(image SOURCES ../../Utilities/image.cpp LIBS LibGfx LibMain)
 endif()
 
-lagom_utility(js SOURCES ../../Utilities/js.cpp LIBS LibCrypto LibJS LibLine LibUnicode LibMain LibTextCodec Threads::Threads)
+lagom_utility(js SOURCES ../../Utilities/js.cpp LIBS LibCrypto LibJS LibLine LibUnicode LibMain LibTextCodec LibGC Threads::Threads)
 
 lagom_utility(gzip SOURCES ../../Utilities/gzip.cpp LIBS LibCompress LibMain)
 lagom_utility(lzcat SOURCES ../../Utilities/lzcat.cpp LIBS LibCompress LibMain)
 
 lagom_utility(tar SOURCES ../../Utilities/tar.cpp LIBS LibArchive LibCompress LibFileSystem LibMain)
-lagom_utility(test262-runner SOURCES ../../Tests/LibJS/test262-runner.cpp LIBS LibJS LibFileSystem)
+lagom_utility(test262-runner SOURCES ../../Tests/LibJS/test262-runner.cpp LIBS LibJS LibFileSystem LibGC)
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     include(CheckCSourceCompiles)
@@ -554,7 +555,7 @@ if (BUILD_TESTING)
     add_executable(test-js
         ../../Tests/LibJS/test-js.cpp
         ../../Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
-    target_link_libraries(test-js AK LibCore LibFileSystem LibTest LibJS)
+    target_link_libraries(test-js AK LibCore LibFileSystem LibTest LibJS LibGC)
     add_test(
         NAME JS
         COMMAND test-js --show-progress=false
@@ -569,7 +570,7 @@ if (BUILD_TESTING)
     add_executable(test-wasm
         ../../Tests/LibWasm/test-wasm.cpp
         ../../Libraries/LibTest/JavaScriptTestRunnerMain.cpp)
-    target_link_libraries(test-wasm AK LibCore LibFileSystem LibTest LibWasm LibJS LibCrypto)
+    target_link_libraries(test-wasm AK LibCore LibFileSystem LibTest LibWasm LibJS LibCrypto LibGC)
     set(wasm_test_root "${SERENITY_PROJECT_ROOT}")
     if (INCLUDE_WASM_SPEC_TESTS)
        set(wasm_test_root "${CMAKE_CURRENT_BINARY_DIR}")
diff --git a/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.cpp b/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.cpp
index 1d6d3602213..61a7f4a3d3e 100644
--- a/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.cpp
+++ b/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.cpp
@@ -39,9 +39,9 @@ static bool record_inherits_from_cell(clang::CXXRecordDecl const& record)
     if (!record.isCompleteDefinition())
         return false;
 
-    bool inherits_from_cell = record.getQualifiedNameAsString() == "JS::CellImpl";
+    bool inherits_from_cell = record.getQualifiedNameAsString() == "GC::Cell";
     record.forallBases([&](clang::CXXRecordDecl const* base) -> bool {
-        if (base->getQualifiedNameAsString() == "JS::CellImpl") {
+        if (base->getQualifiedNameAsString() == "GC::Cell") {
             inherits_from_cell = true;
             return false;
         }
@@ -58,12 +58,12 @@ static std::vector<clang::QualType> get_all_qualified_types(clang::QualType cons
         auto specialization_name = template_specialization->getTemplateName().getAsTemplateDecl()->getQualifiedNameAsString();
         // Do not unwrap GCPtr/NonnullGCPtr/MarkedVector
         static std::unordered_set<std::string> gc_relevant_type_names {
-            "JS::GCPtr",
-            "JS::NonnullGCPtr",
-            "JS::RawGCPtr",
-            "JS::RawNonnullGCPtr",
-            "JS::MarkedVector",
-            "JS::Handle",
+            "GC::Ptr",
+            "GC::Ref",
+            "GC::RawPtr",
+            "GC::RawRef",
+            "GC::MarkedVector",
+            "GC::Root",
         };
 
         if (gc_relevant_type_names.contains(specialization_name)) {
@@ -86,8 +86,8 @@ static std::vector<clang::QualType> get_all_qualified_types(clang::QualType cons
 }
 enum class OuterType {
     GCPtr,
-    RawGCPtr,
-    Handle,
+    RawPtr,
+    Root,
     Ptr,
     Ref,
 };
@@ -109,12 +109,12 @@ static std::optional<QualTypeGCInfo> validate_qualified_type(clang::QualType con
         auto template_type_name = specialization->getTemplateName().getAsTemplateDecl()->getQualifiedNameAsString();
 
         OuterType outer_type;
-        if (template_type_name == "JS::GCPtr" || template_type_name == "JS::NonnullGCPtr") {
+        if (template_type_name == "GC::Ptr" || template_type_name == "GC::Ref") {
             outer_type = OuterType::GCPtr;
-        } else if (template_type_name == "JS::RawGCPtr" || template_type_name == "JS::RawNonnullGCPtr") {
-            outer_type = OuterType::RawGCPtr;
-        } else if (template_type_name == "JS::Handle") {
-            outer_type = OuterType::Handle;
+        } else if (template_type_name == "GC::RawPtr" || template_type_name == "GC::RawRef") {
+            outer_type = OuterType::RawPtr;
+        } else if (template_type_name == "GC::Root") {
+            outer_type = OuterType::Root;
         } else {
             return {};
         }
@@ -173,7 +173,7 @@ bool LibJSGCVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* record)
     // Cell triggers a bunch of warnings for its empty visit_edges implementation, but
     // it doesn't have any members anyways so it's fine to just ignore.
     auto qualified_name = record->getQualifiedNameAsString();
-    if (qualified_name == "JS::CellImpl")
+    if (qualified_name == "GC::Cell")
         return true;
 
     auto& diag_engine = m_context.getDiagnostics();
@@ -192,29 +192,29 @@ bool LibJSGCVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* record)
 
         if (outer_type == OuterType::Ptr || outer_type == OuterType::Ref) {
             if (base_type_inherits_from_cell) {
-                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "%0 to JS::CellImpl type should be wrapped in %1");
+                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "%0 to GC::Cell type should be wrapped in %1");
                 auto builder = diag_engine.Report(field->getLocation(), diag_id);
                 if (outer_type == OuterType::Ref) {
                     builder << "reference"
-                            << "JS::NonnullGCPtr";
+                            << "GC::Ref";
                 } else {
                     builder << "pointer"
-                            << "JS::GCPtr";
+                            << "GC::Ptr";
                 }
             }
-        } else if (outer_type == OuterType::GCPtr || outer_type == OuterType::RawGCPtr) {
+        } else if (outer_type == OuterType::GCPtr || outer_type == OuterType::RawPtr) {
             if (!base_type_inherits_from_cell) {
-                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Specialization type must inherit from JS::CellImpl");
+                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Specialization type must inherit from GC::Cell");
                 diag_engine.Report(field->getLocation(), diag_id);
             } else if (outer_type == OuterType::GCPtr) {
                 fields_that_need_visiting.push_back(field);
             }
-        } else if (outer_type == OuterType::Handle) {
+        } else if (outer_type == OuterType::Root) {
             if (record_is_cell && m_detect_invalid_function_members) {
                 // FIXME: Change this to an Error when all of the use cases get addressed and remove the plugin argument
-                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Warning, "Types inheriting from JS::CellImpl should not have %0 fields");
+                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Warning, "Types inheriting from GC::Cell should not have %0 fields");
                 auto builder = diag_engine.Report(field->getLocation(), diag_id);
-                builder << "JS::Handle";
+                builder << "GC::Root";
             }
         }
     }
@@ -227,7 +227,7 @@ bool LibJSGCVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* record)
     clang::DeclarationName name = &m_context.Idents.get("visit_edges");
     auto const* visit_edges_method = record->lookup(name).find_first<clang::CXXMethodDecl>();
     if (!visit_edges_method && !fields_that_need_visiting.empty()) {
-        auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "JS::Cell-inheriting class %0 contains a GC-allocated member %1 but has no visit_edges method");
+        auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "GC::Cell-inheriting class %0 contains a GC-allocated member %1 but has no visit_edges method");
         auto builder = diag_engine.Report(record->getLocation(), diag_id);
         builder << record->getName()
                 << fields_that_need_visiting[0];
@@ -236,7 +236,7 @@ bool LibJSGCVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* record)
         return true;
 
     // Search for a call to Base::visit_edges. Note that this also has the nice side effect of
-    // ensuring the classes use JS_CELL/JS_OBJECT, as Base will not be defined if they do not.
+    // ensuring the classes use GC_CELL/GC_OBJECT, as Base will not be defined if they do not.
 
     MatchFinder base_visit_edges_finder;
     SimpleCollectMatchesCallback<clang::MemberExpr> base_visit_edges_callback("member-call");
@@ -311,8 +311,8 @@ static std::optional<CellTypeWithOrigin> find_cell_type_with_origin(clang::CXXRe
         if (auto const* base_record = base.getType()->getAsCXXRecordDecl()) {
             auto base_name = base_record->getQualifiedNameAsString();
 
-            if (base_name == "JS::CellImpl")
-                return CellTypeWithOrigin { *base_record, LibJSCellMacro::Type::JSCell };
+            if (base_name == "GC::Cell")
+                return CellTypeWithOrigin { *base_record, LibJSCellMacro::Type::GCCell };
 
             if (base_name == "JS::Object")
                 return CellTypeWithOrigin { *base_record, LibJSCellMacro::Type::JSObject };
@@ -353,7 +353,7 @@ LibJSGCVisitor::CellMacroExpectation LibJSGCVisitor::get_record_cell_macro_expec
     }
 
     assert(false);
-    std::unreachable();
+    __builtin_unreachable();
 }
 
 void LibJSGCVisitor::validate_record_macros(clang::CXXRecordDecl const& record)
@@ -362,7 +362,7 @@ void LibJSGCVisitor::validate_record_macros(clang::CXXRecordDecl const& record)
     auto record_range = record.getSourceRange();
 
     // FIXME: The current macro detection doesn't recursively search through macro expansion,
-    //        so if the record itself is defined in a macro, the JS_CELL/etc won't be found
+    //        so if the record itself is defined in a macro, the GC_CELL/etc won't be found
     if (source_manager.isMacroBodyExpansion(record_range.getBegin()))
         return;
 
@@ -417,13 +417,13 @@ void LibJSGCVisitor::validate_record_macros(clang::CXXRecordDecl const& record)
                 continue;
 
             if (found_macro) {
-                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Record has multiple JS_CELL-like macro invocations");
+                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Record has multiple GC_CELL-like macro invocations");
                 diag_engine.Report(record_range.getBegin(), diag_id);
             }
 
             found_macro = true;
             if (macro.type != expected_cell_macro_type) {
-                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Invalid JS-CELL-like macro invocation; expected %0");
+                auto diag_id = diag_engine.getCustomDiagID(clang::DiagnosticsEngine::Error, "Invalid GC-CELL-like macro invocation; expected %0");
                 auto builder = diag_engine.Report(macro.range.getBegin(), diag_id);
                 builder << LibJSCellMacro::type_name(expected_cell_macro_type);
             }
@@ -469,8 +469,8 @@ void LibJSGCASTConsumer::HandleTranslationUnit(clang::ASTContext& context)
 char const* LibJSCellMacro::type_name(Type type)
 {
     switch (type) {
-    case Type::JSCell:
-        return "JS_CELL";
+    case Type::GCCell:
+        return "GC_CELL";
     case Type::JSObject:
         return "JS_OBJECT";
     case Type::JSEnvironment:
@@ -498,7 +498,7 @@ void LibJSPPCallbacks::MacroExpands(clang::Token const& name_token, clang::Macro
 {
     if (auto* ident_info = name_token.getIdentifierInfo()) {
         static llvm::StringMap<LibJSCellMacro::Type> libjs_macro_types {
-            { "JS_CELL", LibJSCellMacro::Type::JSCell },
+            { "GC_CELL", LibJSCellMacro::Type::GCCell },
             { "JS_OBJECT", LibJSCellMacro::Type::JSObject },
             { "JS_ENVIRONMENT", LibJSCellMacro::Type::JSEnvironment },
             { "JS_PROTOTYPE_OBJECT", LibJSCellMacro::Type::JSPrototypeObject },
diff --git a/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.h b/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.h
index 4841c944331..667dc8c810d 100644
--- a/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.h
+++ b/Meta/Lagom/ClangPlugins/LibJSGCPluginAction.h
@@ -12,7 +12,7 @@
 
 struct LibJSCellMacro {
     enum class Type {
-        JSCell,
+        GCCell,
         JSObject,
         JSEnvironment,
         JSPrototypeObject,
diff --git a/Meta/Lagom/Fuzzers/CMakeLists.txt b/Meta/Lagom/Fuzzers/CMakeLists.txt
index bfc3266340f..290a6088781 100644
--- a/Meta/Lagom/Fuzzers/CMakeLists.txt
+++ b/Meta/Lagom/Fuzzers/CMakeLists.txt
@@ -42,7 +42,7 @@ target_compile_options(FuzzilliJs
     PRIVATE $<$<CXX_COMPILER_ID:Clang>:-g -O1 -fsanitize-coverage=trace-pc-guard>
     )
 target_link_libraries(FuzzilliJs
-    PUBLIC AK LibCore LibJS
+    PUBLIC AK LibCore LibJS LibGC
     PRIVATE $<$<CXX_COMPILER_ID:Clang>:-fsanitize-coverage=trace-pc-guard>
     )
 endif()
diff --git a/Meta/Lagom/Fuzzers/fuzzers.cmake b/Meta/Lagom/Fuzzers/fuzzers.cmake
index 8f1d73d4b35..9d959b1d8f2 100644
--- a/Meta/Lagom/Fuzzers/fuzzers.cmake
+++ b/Meta/Lagom/Fuzzers/fuzzers.cmake
@@ -61,7 +61,7 @@ set(FUZZER_DEPENDENCIES_GzipRoundtrip LibCompress)
 set(FUZZER_DEPENDENCIES_ICCProfile LibGfx)
 set(FUZZER_DEPENDENCIES_ICOLoader LibGfx)
 set(FUZZER_DEPENDENCIES_JPEGLoader LibGfx)
-set(FUZZER_DEPENDENCIES_Js LibJS)
+set(FUZZER_DEPENDENCIES_Js LibJS LibGC)
 set(FUZZER_DEPENDENCIES_LzmaDecompression LibArchive LibCompress)
 set(FUZZER_DEPENDENCIES_LzmaRoundtrip LibCompress)
 set(FUZZER_DEPENDENCIES_MatroskaReader LibMedia)
diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/BindingsGenerator/IDLGenerators.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/BindingsGenerator/IDLGenerators.cpp
index b31fc1d1ee9..0b4c3eaf969 100644
--- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/BindingsGenerator/IDLGenerators.cpp
+++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/BindingsGenerator/IDLGenerators.cpp
@@ -137,7 +137,7 @@ static StringView sequence_storage_type_to_cpp_storage_type_name(SequenceStorage
     case SequenceStorageType::Vector:
         return "Vector"sv;
     case SequenceStorageType::MarkedVector:
-        return "JS::MarkedVector"sv;
+        return "GC::MarkedVector"sv;
     default:
         VERIFY_NOT_REACHED();
     }
@@ -171,13 +171,13 @@ static ByteString union_type_to_variant(UnionType const& union_type, Interface c
 CppType idl_type_name_to_cpp_type(Type const& type, Interface const& interface)
 {
     if (is_platform_object(type) || type.name() == "WindowProxy"sv)
-        return { .name = ByteString::formatted("JS::Handle<{}>", type.name()), .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = ByteString::formatted("GC::Root<{}>", type.name()), .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (is_javascript_builtin(type))
-        return { .name = ByteString::formatted("JS::Handle<JS::{}>", type.name()), .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = ByteString::formatted("GC::Root<JS::{}>", type.name()), .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (interface.callback_functions.contains(type.name()))
-        return { .name = "JS::Handle<WebIDL::CallbackType>", .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = "GC::Root<WebIDL::CallbackType>", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.is_string())
         return { .name = "String", .sequence_storage_type = SequenceStorageType::Vector };
@@ -213,19 +213,19 @@ CppType idl_type_name_to_cpp_type(Type const& type, Interface const& interface)
         return { .name = "JS::Value", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.name() == "object")
-        return { .name = "JS::Handle<JS::Object>", .sequence_storage_type = SequenceStorageType::Vector };
+        return { .name = "GC::Root<JS::Object>", .sequence_storage_type = SequenceStorageType::Vector };
 
     if (type.name() == "BufferSource")
-        return { .name = "JS::Handle<WebIDL::BufferSource>", .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = "GC::Root<WebIDL::BufferSource>", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.name() == "ArrayBufferView")
-        return { .name = "JS::Handle<WebIDL::ArrayBufferView>", .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = "GC::Root<WebIDL::ArrayBufferView>", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.name() == "File")
-        return { .name = "JS::Handle<FileAPI::File>", .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = "GC::Root<FileAPI::File>", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.name() == "Function")
-        return { .name = "JS::NonnullGCPtr<WebIDL::CallbackType>", .sequence_storage_type = SequenceStorageType::MarkedVector };
+        return { .name = "GC::Ref<WebIDL::CallbackType>", .sequence_storage_type = SequenceStorageType::MarkedVector };
 
     if (type.name() == "sequence") {
         auto& parameterized_type = verify_cast<ParameterizedType>(type);
@@ -577,7 +577,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
 )~~~");
             } else {
                 scoped_generator.append(R"~~~(
-    JS::GCPtr<@parameter.type.name@> @cpp_name@;
+    GC::Ptr<@parameter.type.name@> @cpp_name@;
     if (!@js_name@@js_suffix@.is_undefined()) {
         if (!@js_name@@js_suffix@.is_object() || !is<@parameter.type.name@>(@js_name@@js_suffix@.as_object()))
             return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "@parameter.type.name@");
@@ -589,13 +589,13 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         } else {
             if (explicit_null) {
                 scoped_generator.append(R"~~~(
-    Optional<JS::GCPtr<@parameter.type.name@>> @cpp_name@;
+    Optional<GC::Ptr<@parameter.type.name@>> @cpp_name@;
     if (maybe_@js_name@@js_suffix@.has_value()) {
         auto @js_name@@js_suffix@ = maybe_@js_name@@js_suffix@.release_value();
 )~~~");
             } else {
                 scoped_generator.append(R"~~~(
-    JS::GCPtr<@parameter.type.name@> @cpp_name@;
+    GC::Ptr<@parameter.type.name@> @cpp_name@;
 )~~~");
             }
 
@@ -675,42 +675,42 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
     // 2. Perform ? Call(promiseCapability.[[Resolve]], undefined, « V »).
     TRY(JS::call(vm, *promise_capability->resolve(), JS::js_undefined(), @js_name@@js_suffix@));
     // 3. Return promiseCapability.
-    auto @cpp_name@ = JS::make_handle(promise_capability);
+    auto @cpp_name@ = GC::make_root(promise_capability);
 )~~~");
     } else if (parameter.type->name() == "object") {
         if (parameter.type->is_nullable()) {
             scoped_generator.append(R"~~~(
-    Optional<JS::Handle<JS::Object>> @cpp_name@;
+    Optional<GC::Root<JS::Object>> @cpp_name@;
     if (!@js_name@@js_suffix@.is_null() && !@js_name@@js_suffix@.is_undefined())
-        @cpp_name@ = JS::make_handle(TRY(@js_name@@js_suffix@.to_object(vm)));
+        @cpp_name@ = GC::make_root(TRY(@js_name@@js_suffix@.to_object(vm)));
 )~~~");
         } else if (optional) {
             scoped_generator.append(R"~~~(
-    Optional<JS::Handle<JS::Object>> @cpp_name@;
+    Optional<GC::Root<JS::Object>> @cpp_name@;
     if (!@js_name@@js_suffix@.is_undefined())
-        @cpp_name@ = JS::make_handle(TRY(@js_name@@js_suffix@.to_object(vm)));
+        @cpp_name@ = GC::make_root(TRY(@js_name@@js_suffix@.to_object(vm)));
 )~~~");
         } else {
             scoped_generator.append(R"~~~(
-    auto @cpp_name@ = JS::make_handle(TRY(@js_name@@js_suffix@.to_object(vm)));
+    auto @cpp_name@ = GC::make_root(TRY(@js_name@@js_suffix@.to_object(vm)));
 )~~~");
         }
     } else if (is_javascript_builtin(parameter.type) || parameter.type->name() == "BufferSource"sv) {
         if (optional) {
             scoped_generator.append(R"~~~(
-    Optional<JS::Handle<WebIDL::BufferSource>> @cpp_name@;
+    Optional<GC::Root<WebIDL::BufferSource>> @cpp_name@;
     if (!@js_name@@js_suffix@.is_undefined()) {
 )~~~");
         } else {
             scoped_generator.append(R"~~~(
-    JS::Handle<WebIDL::BufferSource> @cpp_name@;
+    GC::Root<WebIDL::BufferSource> @cpp_name@;
 )~~~");
         }
         scoped_generator.append(R"~~~(
     if (!@js_name@@js_suffix@.is_object() || !(is<JS::TypedArrayBase>(@js_name@@js_suffix@.as_object()) || is<JS::ArrayBuffer>(@js_name@@js_suffix@.as_object()) || is<JS::DataView>(@js_name@@js_suffix@.as_object())))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "@parameter.type.name@");
 
-    @cpp_name@ = JS::make_handle(realm.create<WebIDL::BufferSource>(@js_name@@js_suffix@.as_object()));
+    @cpp_name@ = GC::make_root(realm.create<WebIDL::BufferSource>(@js_name@@js_suffix@.as_object()));
 )~~~");
 
         if (optional) {
@@ -724,7 +724,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
     if (!@js_name@@js_suffix@.is_object() || !(is<JS::TypedArrayBase>(@js_name@@js_suffix@.as_object()) || is<JS::DataView>(@js_name@@js_suffix@.as_object())))
         return vm.throw_completion<JS::TypeError>(JS::ErrorType::NotAnObjectOfType, "@parameter.type.name@");
 
-    auto @cpp_name@ = JS::make_handle(realm.create<WebIDL::ArrayBufferView>(@js_name@@js_suffix@.as_object()));
+    auto @cpp_name@ = GC::make_root(realm.create<WebIDL::ArrayBufferView>(@js_name@@js_suffix@.as_object()));
 )~~~");
         if (optional) {
             scoped_generator.append(R"~~~(
@@ -734,7 +734,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
     } else if (parameter.type->name() == "any") {
         if (variadic) {
             scoped_generator.append(R"~~~(
-    JS::MarkedVector<JS::Value> @cpp_name@ { vm.heap() };
+    GC::MarkedVector<JS::Value> @cpp_name@ { vm.heap() };
 
     if (vm.argument_count() > @js_suffix@) {
         @cpp_name@.ensure_capacity(vm.argument_count() - @js_suffix@);
@@ -918,7 +918,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         // 2. Return the IDL callback function type value that represents a reference to the same object that V represents, with the incumbent settings object as the callback context.
         if (parameter.type->is_nullable() || callback_function.is_legacy_treat_non_object_as_null) {
             callback_function_generator.append(R"~~~(
-    JS::GCPtr<WebIDL::CallbackType> @cpp_name@;
+    GC::Ptr<WebIDL::CallbackType> @cpp_name@;
     if (@js_name@@js_suffix@.is_object())
         @cpp_name@ = vm.heap().allocate<WebIDL::CallbackType>(@js_name@@js_suffix@.as_object(), HTML::incumbent_settings_object(), @operation_returns_promise@);
 )~~~");
@@ -1191,14 +1191,14 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
 
                 union_platform_object_type_generator.append(R"~~~(
                 if (is<@platform_object_type@>(@js_name@@js_suffix@_object))
-                    return JS::make_handle(static_cast<@platform_object_type@&>(@js_name@@js_suffix@_object));
+                    return GC::make_root(static_cast<@platform_object_type@&>(@js_name@@js_suffix@_object));
 )~~~");
             }
 
             //    2. If types includes object, then return the IDL value that is a reference to the object V.
             if (includes_object) {
                 union_generator.append(R"~~~(
-                return JS::make_handle(@js_name@@js_suffix@_object);
+                return GC::make_root(@js_name@@js_suffix@_object);
 )~~~");
             }
 
@@ -1218,7 +1218,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         if (includes_window_proxy) {
             union_generator.append(R"~~~(
             if (is<WindowProxy>(@js_name@@js_suffix@_object))
-                return JS::make_handle(static_cast<WindowProxy&>(@js_name@@js_suffix@_object));
+                return GC::make_root(static_cast<WindowProxy&>(@js_name@@js_suffix@_object));
 )~~~");
         }
 
@@ -1227,8 +1227,8 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         if (any_of(types, [](auto const& type) { return type->name() == "BufferSource"; }) && !includes_object) {
             union_generator.append(R"~~~(
             if (is<JS::ArrayBuffer>(@js_name@@js_suffix@_object) || is<JS::DataView>(@js_name@@js_suffix@_object) || is<JS::TypedArrayBase>(@js_name@@js_suffix@_object)) {
-                JS::NonnullGCPtr<WebIDL::BufferSource> source_object = realm.create<WebIDL::BufferSource>(@js_name@@js_suffix@_object);
-                return JS::make_handle(source_object);
+                GC::Ref<WebIDL::BufferSource> source_object = realm.create<WebIDL::BufferSource>(@js_name@@js_suffix@_object);
+                return GC::make_root(source_object);
             }
 )~~~");
         }
@@ -1239,7 +1239,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         if (any_of(types, [](auto const& type) { return type->name() == "ArrayBuffer"; }) || includes_object) {
             union_generator.append(R"~~~(
             if (is<JS::ArrayBuffer>(@js_name@@js_suffix@_object))
-                return JS::make_handle(@js_name@@js_suffix@_object);
+                return GC::make_root(@js_name@@js_suffix@_object);
 )~~~");
         }
 
@@ -1249,7 +1249,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         if (any_of(types, [](auto const& type) { return type->name() == "DataView"; }) || includes_object) {
             union_generator.append(R"~~~(
             if (is<JS::DataView>(@js_name@@js_suffix@_object))
-                return JS::make_handle(@js_name@@js_suffix@_object);
+                return GC::make_root(@js_name@@js_suffix@_object);
 )~~~");
         }
 
@@ -1263,7 +1263,7 @@ static void generate_to_cpp(SourceGenerator& generator, ParameterType& parameter
         if (has_typed_array_name || includes_object) {
             union_generator.append(R"~~~(
             if (is<JS::TypedArrayBase>(@js_name@@js_suffix@_object))
-                return JS::make_handle(@js_name@@js_suffix@_object);
+                return GC::make_root(@js_name@@js_suffix@_object);
 )~~~");
         }
 
@@ -1589,7 +1589,7 @@ static void generate_arguments(SourceGenerator& generator, Vector<IDL::Parameter
         auto parameter_name = make_input_acceptable_cpp(parameter.name.to_snakecase());
 
         if (parameter.variadic) {
-            // JS::MarkedVector is non-copyable, and the implementations likely want ownership of the
+            // GC::MarkedVector is non-copyable, and the implementations likely want ownership of the
             // list, so we move() it into the parameter list.
             parameter_names.append(ByteString::formatted("move({})", parameter_name));
         } else {
@@ -1765,7 +1765,7 @@ static void generate_wrap_statement(SourceGenerator& generator, ByteString const
 )~~~");
         }
 
-        // If the type is a platform object we currently return a Vector<JS::Handle<T>> from the
+        // If the type is a platform object we currently return a Vector<GC::Root<T>> from the
         // C++ implementation, thus allowing us to unwrap the element (a handle) like below.
         // This might need to change if we switch to a MarkedVector.
         if (is_platform_object(sequence_generic_type.parameters().first())) {
@@ -1801,7 +1801,7 @@ static void generate_wrap_statement(SourceGenerator& generator, ByteString const
 )~~~");
     } else if (type.name() == "Promise") {
         scoped_generator.append(R"~~~(
-    @result_expression@ JS::NonnullGCPtr { verify_cast<JS::Promise>(*@value@->promise()) };
+    @result_expression@ GC::Ref { verify_cast<JS::Promise>(*@value@->promise()) };
 )~~~");
     } else if (type.name() == "ArrayBufferView" || type.name() == "BufferSource") {
         scoped_generator.append(R"~~~(
@@ -2279,7 +2279,7 @@ static void generate_overload_arbiter(SourceGenerator& generator, auto const& ov
 
     if (is_constructor == IsConstructor::Yes) {
         function_generator.append(R"~~~(
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> @constructor_class@::construct(JS::FunctionObject& new_target)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> @constructor_class@::construct(JS::FunctionObject& new_target)
 {
     auto& vm = this->vm();
     WebIDL::log_trace(vm, "@constructor_class@::construct");
@@ -2549,7 +2549,7 @@ static void generate_html_constructor(SourceGenerator& generator, IDL::Construct
         return JS::throw_completion(WebIDL::InvalidStateError::create(realm, "Custom element has already been constructed"_string));
 
     // 12. Perform ? element.[[SetPrototypeOf]](prototype).
-    auto actual_element = element.get<JS::Handle<DOM::Element>>();
+    auto actual_element = element.get<GC::Root<DOM::Element>>();
     TRY(actual_element->internal_set_prototype_of(&prototype.as_object()));
 
     // 13. Replace the last entry in definition's construction stack with an already constructed marker.
@@ -2569,7 +2569,7 @@ static void generate_constructor(SourceGenerator& generator, IDL::Constructor co
     constructor_generator.set("overload_suffix", constructor.is_overloaded ? ByteString::number(constructor.overload_index) : ByteString::empty());
 
     constructor_generator.append(R"~~~(
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> @constructor_class@::construct@overload_suffix@([[maybe_unused]] FunctionObject& new_target)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> @constructor_class@::construct@overload_suffix@([[maybe_unused]] FunctionObject& new_target)
 {
     WebIDL::log_trace(vm(), "@constructor_class@::construct@overload_suffix@");
 )~~~");
@@ -2677,7 +2677,7 @@ static void generate_constructors(SourceGenerator& generator, IDL::Interface con
     if (interface.constructors.is_empty()) {
         // No constructor
         generator.append(R"~~~(
-JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> @constructor_class@::construct([[maybe_unused]] FunctionObject& new_target)
+JS::ThrowCompletionOr<GC::Ref<JS::Object>> @constructor_class@::construct([[maybe_unused]] FunctionObject& new_target)
 {
     WebIDL::log_trace(vm(), "@constructor_class@::construct");
 )~~~");
@@ -3004,7 +3004,7 @@ static void generate_named_properties_object_declarations(IDL::Interface const&
     generator.append(R"~~~(
 class @named_properties_class@ : public JS::Object {
     JS_OBJECT(@named_properties_class@, JS::Object);
-    JS_DECLARE_ALLOCATOR(@named_properties_class@);
+    GC_DECLARE_ALLOCATOR(@named_properties_class@);
 public:
     explicit @named_properties_class@(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
@@ -3020,7 +3020,7 @@ private:
 
     virtual void visit_edges(Visitor&) override;
 
-    JS::NonnullGCPtr<JS::Realm> m_realm; // [[Realm]]
+    GC::Ref<JS::Realm> m_realm; // [[Realm]]
 };
 )~~~");
 }
@@ -3038,7 +3038,7 @@ static void generate_named_properties_object_definitions(IDL::Interface const& i
     generator.append(R"~~~(
 #include <LibWeb/WebIDL/AbstractOperations.h>
 
-JS_DEFINE_ALLOCATOR(@named_properties_class@);
+GC_DEFINE_ALLOCATOR(@named_properties_class@);
 
 @named_properties_class@::@named_properties_class@(JS::Realm& realm)
   : JS::Object(realm, nullptr, MayInterfereWithIndexedPropertyAccess::Yes)
@@ -3859,7 +3859,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::@attribute.setter_callback@)
 {
     WebIDL::log_trace(vm, "@class_name@::@attribute.setter_callback@");
     auto this_value = vm.this_value();
-    JS::GCPtr<Window> window;
+    GC::Ptr<Window> window;
     if (this_value.is_object()) {
         if (is<WindowProxy>(this_value.as_object())) {
             auto& window_proxy = static_cast<WindowProxy&>(this_value.as_object());
@@ -4025,7 +4025,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::get_size)
     WebIDL::log_trace(vm, "@class_name@::size");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     return set->set_size();
 }
@@ -4037,7 +4037,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::entries)
     auto& realm = *vm.current_realm();
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     return TRY(throw_dom_exception_if_needed(vm, [&] { return JS::SetIterator::create(realm, *set, Object::PropertyKind::KeyAndValue); }));
 }
@@ -4049,7 +4049,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::values)
     auto& realm = *vm.current_realm();
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     return TRY(throw_dom_exception_if_needed(vm, [&] { return JS::SetIterator::create(realm, *set, Object::PropertyKind::Value); }));
 }
@@ -4060,7 +4060,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::for_each)
     WebIDL::log_trace(vm, "@class_name@::for_each");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     auto callback = vm.argument(0);
     if (!callback.is_function())
@@ -4080,7 +4080,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::has)
     WebIDL::log_trace(vm, "@class_name@::has");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     auto value_arg = vm.argument(0);
     if (!value_arg.is_object() && !is<@value_type@>(value_arg.as_object())) {
@@ -4102,7 +4102,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::add)
     WebIDL::log_trace(vm, "@class_name@::add");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     auto value_arg = vm.argument(0);
     if (!value_arg.is_object() && !is<@value_type@>(value_arg.as_object())) {
@@ -4126,7 +4126,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::delete_)
     WebIDL::log_trace(vm, "@class_name@::delete_");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     auto value_arg = vm.argument(0);
     if (!value_arg.is_object() && !is<@value_type@>(value_arg.as_object())) {
@@ -4148,7 +4148,7 @@ JS_DEFINE_NATIVE_FUNCTION(@class_name@::clear)
     WebIDL::log_trace(vm, "@class_name@::clear");
     auto* impl = TRY(impl_from(vm));
 
-    JS::NonnullGCPtr<JS::Set> set = impl->set_entries();
+    GC::Ref<JS::Set> set = impl->set_entries();
 
     set->set_clear();
 
@@ -4174,7 +4174,7 @@ namespace Web::Bindings {
 
 class @namespace_class@ final : public JS::Object {
     JS_OBJECT(@namespace_class@, JS::Object);
-    JS_DECLARE_ALLOCATOR(@namespace_class@);
+    GC_DECLARE_ALLOCATOR(@namespace_class@);
 public:
     explicit @namespace_class@(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
@@ -4301,7 +4301,7 @@ void generate_namespace_implementation(IDL::Interface const& interface, StringBu
     generator.append(R"~~~(
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(@namespace_class@);
+GC_DEFINE_ALLOCATOR(@namespace_class@);
 
 @namespace_class@::@namespace_class@(JS::Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().object_prototype())
@@ -4389,14 +4389,14 @@ namespace Web::Bindings {
 
 class @constructor_class@ : public JS::NativeFunction {
     JS_OBJECT(@constructor_class@, JS::NativeFunction);
-    JS_DECLARE_ALLOCATOR(@constructor_class@);
+    GC_DECLARE_ALLOCATOR(@constructor_class@);
 public:
     explicit @constructor_class@(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
     virtual ~@constructor_class@() override;
 
     virtual JS::ThrowCompletionOr<JS::Value> call() override;
-    virtual JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> construct(JS::FunctionObject& new_target) override;
+    virtual JS::ThrowCompletionOr<GC::Ref<JS::Object>> construct(JS::FunctionObject& new_target) override;
 
 private:
     virtual bool has_constructor() const override { return true; }
@@ -4422,7 +4422,7 @@ private:
             for (auto i = 0u; i < overload_set.value.size(); ++i) {
                 constructor_generator.set("overload_suffix", ByteString::number(i));
                 constructor_generator.append(R"~~~(
-    JS::ThrowCompletionOr<JS::NonnullGCPtr<JS::Object>> construct@overload_suffix@(JS::FunctionObject& new_target);
+    JS::ThrowCompletionOr<GC::Ref<JS::Object>> construct@overload_suffix@(JS::FunctionObject& new_target);
 )~~~");
             }
         }
@@ -4484,7 +4484,7 @@ void generate_constructor_implementation(IDL::Interface const& interface, String
 
     generator.append(R"~~~(
 #include <LibIDL/Types.h>
-#include <LibJS/Heap/Heap.h>
+#include <LibGC/Heap.h>
 #include <LibJS/Runtime/ArrayBuffer.h>
 #include <LibJS/Runtime/DataView.h>
 #include <LibJS/Runtime/GlobalObject.h>
@@ -4526,7 +4526,7 @@ void generate_constructor_implementation(IDL::Interface const& interface, String
     generator.append(R"~~~(
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(@constructor_class@);
+GC_DEFINE_ALLOCATOR(@constructor_class@);
 
 @constructor_class@::@constructor_class@(JS::Realm& realm)
     : NativeFunction("@name@"sv, realm.intrinsics().function_prototype())
@@ -4654,7 +4654,7 @@ namespace Web::Bindings {
 
 class @prototype_class@ : public JS::Object {
     JS_OBJECT(@prototype_class@, JS::Object);
-    JS_DECLARE_ALLOCATOR(@prototype_class@);
+    GC_DECLARE_ALLOCATOR(@prototype_class@);
 public:
     explicit @prototype_class@(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
@@ -4770,7 +4770,7 @@ void generate_prototype_implementation(IDL::Interface const& interface, StringBu
     generator.append(R"~~~(
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(@prototype_class@);
+GC_DEFINE_ALLOCATOR(@prototype_class@);
 
 @prototype_class@::@prototype_class@([[maybe_unused]] JS::Realm& realm))~~~");
     if (interface.name == "DOMException") {
@@ -4848,7 +4848,7 @@ namespace Web::Bindings {
 
 class @prototype_class@ : public JS::Object {
     JS_OBJECT(@prototype_class@, JS::Object);
-    JS_DECLARE_ALLOCATOR(@prototype_class@);
+    GC_DECLARE_ALLOCATOR(@prototype_class@);
 public:
     explicit @prototype_class@(JS::Realm&);
     virtual void initialize(JS::Realm&) override;
@@ -4895,7 +4895,7 @@ void generate_iterator_prototype_implementation(IDL::Interface const& interface,
     generator.append(R"~~~(
 namespace Web::Bindings {
 
-JS_DEFINE_ALLOCATOR(@prototype_class@);
+GC_DEFINE_ALLOCATOR(@prototype_class@);
 
 @prototype_class@::@prototype_class@(JS::Realm& realm)
     : Object(ConstructWithPrototypeTag::Tag, realm.intrinsics().iterator_prototype())
diff --git a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp
index 0f7438acf79..46fa350bb78 100644
--- a/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp
+++ b/Meta/Lagom/Tools/CodeGenerators/LibWeb/GenerateWindowOrWorkerInterfaces.cpp
@@ -64,7 +64,7 @@ static ErrorOr<void> generate_intrinsic_definitions(StringView output_path, Vect
     SourceGenerator generator(builder);
 
     generator.append(R"~~~(
-#include <LibJS/Heap/DeferGC.h>
+#include <LibGC/DeferGC.h>
 #include <LibJS/Runtime/Object.h>
 #include <LibWeb/Bindings/Intrinsics.h>)~~~");
 
diff --git a/Services/WebContent/CMakeLists.txt b/Services/WebContent/CMakeLists.txt
index 8e65fccddc1..244a6a6bcf5 100644
--- a/Services/WebContent/CMakeLists.txt
+++ b/Services/WebContent/CMakeLists.txt
@@ -28,7 +28,7 @@ target_include_directories(webcontentservice PUBLIC $<BUILD_INTERFACE:${CMAKE_CU
 target_include_directories(webcontentservice PUBLIC $<BUILD_INTERFACE:${LADYBIRD_SOURCE_DIR}>)
 target_include_directories(webcontentservice PUBLIC $<BUILD_INTERFACE:${LADYBIRD_SOURCE_DIR}/Services/>)
 
-target_link_libraries(webcontentservice PUBLIC LibCore LibFileSystem LibGfx LibIPC LibJS LibMain LibMedia LibWeb LibWebSocket LibRequests LibWebView LibImageDecoderClient)
+target_link_libraries(webcontentservice PUBLIC LibCore LibFileSystem LibGfx LibIPC LibJS LibMain LibMedia LibWeb LibWebSocket LibRequests LibWebView LibImageDecoderClient LibGC)
 
 if (ENABLE_QT)
     qt_add_executable(WebContent main.cpp)
diff --git a/Services/WebContent/ConnectionFromClient.cpp b/Services/WebContent/ConnectionFromClient.cpp
index 11101635b46..9c36a255982 100644
--- a/Services/WebContent/ConnectionFromClient.cpp
+++ b/Services/WebContent/ConnectionFromClient.cpp
@@ -12,10 +12,10 @@
 #include <AK/JsonObject.h>
 #include <AK/QuickSort.h>
 #include <LibCore/EventLoop.h>
+#include <LibGC/Heap.h>
 #include <LibGfx/Bitmap.h>
 #include <LibGfx/Font/FontDatabase.h>
 #include <LibGfx/SystemTheme.h>
-#include <LibJS/Heap/Heap.h>
 #include <LibJS/Runtime/ConsoleObject.h>
 #include <LibJS/Runtime/Date.h>
 #include <LibUnicode/TimeZone.h>
@@ -55,12 +55,12 @@
 
 namespace WebContent {
 
-ConnectionFromClient::ConnectionFromClient(JS::Heap& heap, IPC::Transport transport)
+ConnectionFromClient::ConnectionFromClient(GC::Heap& heap, IPC::Transport transport)
     : IPC::ConnectionFromClient<WebContentClientEndpoint, WebContentServerEndpoint>(*this, move(transport), 1)
     , m_heap(heap)
     , m_page_host(PageHost::create(*this))
 {
-    m_input_event_queue_timer = Web::Platform::Timer::create_single_shot(m_heap, 0, JS::create_heap_function(heap, [this] { process_next_input_event(); }));
+    m_input_event_queue_timer = Web::Platform::Timer::create_single_shot(m_heap, 0, GC::create_function(heap, [this] { process_next_input_event(); }));
 }
 
 ConnectionFromClient::~ConnectionFromClient() = default;
@@ -366,7 +366,7 @@ void ConnectionFromClient::debug_request(u64 page_id, ByteString const& request,
     if (request == "collect-garbage") {
         // NOTE: We use deferred_invoke here to ensure that GC runs with as little on the stack as possible.
         Core::deferred_invoke([] {
-            Web::Bindings::main_thread_vm().heap().collect_garbage(JS::Heap::CollectionType::CollectGarbage, true);
+            Web::Bindings::main_thread_vm().heap().collect_garbage(GC::Heap::CollectionType::CollectGarbage, true);
         });
         return;
     }
diff --git a/Services/WebContent/ConnectionFromClient.h b/Services/WebContent/ConnectionFromClient.h
index efb3e72eac5..d0909eea382 100644
--- a/Services/WebContent/ConnectionFromClient.h
+++ b/Services/WebContent/ConnectionFromClient.h
@@ -11,9 +11,9 @@
 #include <AK/HashMap.h>
 #include <AK/Queue.h>
 #include <AK/SourceLocation.h>
+#include <LibGC/Root.h>
 #include <LibIPC/ConnectionFromClient.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWeb/CSS/PreferredColorScheme.h>
 #include <LibWeb/CSS/PreferredContrast.h>
 #include <LibWeb/CSS/PreferredMotion.h>
@@ -48,7 +48,7 @@ public:
     Function<void(IPC::File const&)> on_image_decoder_connection;
 
 private:
-    explicit ConnectionFromClient(JS::Heap&, IPC::Transport);
+    explicit ConnectionFromClient(GC::Heap&, IPC::Transport);
 
     Optional<PageClient&> page(u64 index, SourceLocation = SourceLocation::current());
     Optional<PageClient const&> page(u64 index, SourceLocation = SourceLocation::current()) const;
@@ -150,7 +150,7 @@ private:
 
     void report_finished_handling_input_event(u64 page_id, Web::EventResult event_was_handled);
 
-    JS::Heap& m_heap;
+    GC::Heap& m_heap;
     NonnullOwnPtr<PageHost> m_page_host;
 
     HashMap<int, Web::FileRequest> m_requested_files {};
@@ -167,7 +167,7 @@ private:
 
     Queue<QueuedInputEvent> m_input_event_queue;
 
-    JS::Handle<Web::Platform::Timer> m_input_event_queue_timer;
+    GC::Root<Web::Platform::Timer> m_input_event_queue_timer;
 };
 
 }
diff --git a/Services/WebContent/ConsoleGlobalEnvironmentExtensions.cpp b/Services/WebContent/ConsoleGlobalEnvironmentExtensions.cpp
index 66936f3befe..8e58ed04653 100644
--- a/Services/WebContent/ConsoleGlobalEnvironmentExtensions.cpp
+++ b/Services/WebContent/ConsoleGlobalEnvironmentExtensions.cpp
@@ -15,7 +15,7 @@
 
 namespace WebContent {
 
-JS_DEFINE_ALLOCATOR(ConsoleGlobalEnvironmentExtensions);
+GC_DEFINE_ALLOCATOR(ConsoleGlobalEnvironmentExtensions);
 
 ConsoleGlobalEnvironmentExtensions::ConsoleGlobalEnvironmentExtensions(JS::Realm& realm, Web::HTML::Window& window)
     : Object(realm, nullptr)
diff --git a/Services/WebContent/ConsoleGlobalEnvironmentExtensions.h b/Services/WebContent/ConsoleGlobalEnvironmentExtensions.h
index 32d9f76a39e..b5c8eb8bec4 100644
--- a/Services/WebContent/ConsoleGlobalEnvironmentExtensions.h
+++ b/Services/WebContent/ConsoleGlobalEnvironmentExtensions.h
@@ -15,7 +15,7 @@ namespace WebContent {
 
 class ConsoleGlobalEnvironmentExtensions final : public JS::Object {
     JS_OBJECT(ConsoleGlobalEnvironmentExtensions, JS::Object);
-    JS_DECLARE_ALLOCATOR(ConsoleGlobalEnvironmentExtensions);
+    GC_DECLARE_ALLOCATOR(ConsoleGlobalEnvironmentExtensions);
 
 public:
     ConsoleGlobalEnvironmentExtensions(JS::Realm&, Web::HTML::Window&);
@@ -36,7 +36,7 @@ private:
     // $$(selector, element), equivalent to `(element || document).querySelectorAll(selector)`
     JS_DECLARE_NATIVE_FUNCTION($$_function);
 
-    JS::NonnullGCPtr<Web::HTML::Window> m_window_object;
+    GC::Ref<Web::HTML::Window> m_window_object;
     JS::Value m_most_recent_result { JS::js_undefined() };
 };
 
diff --git a/Services/WebContent/PageClient.cpp b/Services/WebContent/PageClient.cpp
index 6f51f29b556..f0dfccedd1e 100644
--- a/Services/WebContent/PageClient.cpp
+++ b/Services/WebContent/PageClient.cpp
@@ -33,14 +33,14 @@ namespace WebContent {
 
 static PageClient::UseSkiaPainter s_use_skia_painter = PageClient::UseSkiaPainter::GPUBackendIfAvailable;
 
-JS_DEFINE_ALLOCATOR(PageClient);
+GC_DEFINE_ALLOCATOR(PageClient);
 
 void PageClient::set_use_skia_painter(UseSkiaPainter use_skia_painter)
 {
     s_use_skia_painter = use_skia_painter;
 }
 
-JS::NonnullGCPtr<PageClient> PageClient::create(JS::VM& vm, PageHost& page_host, u64 id)
+GC::Ref<PageClient> PageClient::create(JS::VM& vm, PageHost& page_host, u64 id)
 {
     return vm.heap().allocate<PageClient>(page_host, id);
 }
@@ -626,7 +626,7 @@ void PageClient::inspector_did_set_dom_node_tag(Web::UniqueNodeID node_id, Strin
     client().async_inspector_did_set_dom_node_tag(m_id, node_id, tag);
 }
 
-static Vector<WebView::Attribute> named_node_map_to_vector(JS::NonnullGCPtr<Web::DOM::NamedNodeMap> map)
+static Vector<WebView::Attribute> named_node_map_to_vector(GC::Ref<Web::DOM::NamedNodeMap> map)
 {
     Vector<WebView::Attribute> attributes;
     attributes.ensure_capacity(map->length());
@@ -641,12 +641,12 @@ static Vector<WebView::Attribute> named_node_map_to_vector(JS::NonnullGCPtr<Web:
     return attributes;
 }
 
-void PageClient::inspector_did_add_dom_node_attributes(Web::UniqueNodeID node_id, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> attributes)
+void PageClient::inspector_did_add_dom_node_attributes(Web::UniqueNodeID node_id, GC::Ref<Web::DOM::NamedNodeMap> attributes)
 {
     client().async_inspector_did_add_dom_node_attributes(m_id, node_id, named_node_map_to_vector(attributes));
 }
 
-void PageClient::inspector_did_replace_dom_node_attribute(Web::UniqueNodeID node_id, size_t attribute_index, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> replacement_attributes)
+void PageClient::inspector_did_replace_dom_node_attribute(Web::UniqueNodeID node_id, size_t attribute_index, GC::Ref<Web::DOM::NamedNodeMap> replacement_attributes)
 {
     client().async_inspector_did_replace_dom_node_attribute(m_id, node_id, attribute_index, named_node_map_to_vector(replacement_attributes));
 }
diff --git a/Services/WebContent/PageClient.h b/Services/WebContent/PageClient.h
index 3e68943cb03..f8680b11d5b 100644
--- a/Services/WebContent/PageClient.h
+++ b/Services/WebContent/PageClient.h
@@ -20,11 +20,11 @@
 namespace WebContent {
 
 class PageClient final : public Web::PageClient {
-    JS_CELL(PageClient, Web::PageClient);
-    JS_DECLARE_ALLOCATOR(PageClient);
+    GC_CELL(PageClient, Web::PageClient);
+    GC_DECLARE_ALLOCATOR(PageClient);
 
 public:
-    static JS::NonnullGCPtr<PageClient> create(JS::VM& vm, PageHost& page_host, u64 id);
+    static GC::Ref<PageClient> create(JS::VM& vm, PageHost& page_host, u64 id);
 
     virtual ~PageClient() override;
 
@@ -164,8 +164,8 @@ private:
     virtual void inspector_did_select_dom_node(Web::UniqueNodeID, Optional<Web::CSS::Selector::PseudoElement::Type> const& pseudo_element) override;
     virtual void inspector_did_set_dom_node_text(Web::UniqueNodeID, String const& text) override;
     virtual void inspector_did_set_dom_node_tag(Web::UniqueNodeID, String const& tag) override;
-    virtual void inspector_did_add_dom_node_attributes(Web::UniqueNodeID, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> attributes) override;
-    virtual void inspector_did_replace_dom_node_attribute(Web::UniqueNodeID, size_t attribute_index, JS::NonnullGCPtr<Web::DOM::NamedNodeMap> replacement_attributes) override;
+    virtual void inspector_did_add_dom_node_attributes(Web::UniqueNodeID, GC::Ref<Web::DOM::NamedNodeMap> attributes) override;
+    virtual void inspector_did_replace_dom_node_attribute(Web::UniqueNodeID, size_t attribute_index, GC::Ref<Web::DOM::NamedNodeMap> replacement_attributes) override;
     virtual void inspector_did_request_dom_tree_context_menu(Web::UniqueNodeID, Web::CSSPixelPoint position, String const& type, Optional<String> const& tag, Optional<size_t> const& attribute_index) override;
     virtual void inspector_did_request_cookie_context_menu(size_t cookie_index, Web::CSSPixelPoint position) override;
     virtual void inspector_did_request_style_sheet_source(Web::CSS::StyleSheetIdentifier const& stylesheet_source) override;
@@ -177,7 +177,7 @@ private:
     ConnectionFromClient& client() const;
 
     PageHost& m_owner;
-    JS::NonnullGCPtr<Web::Page> m_page;
+    GC::Ref<Web::Page> m_page;
     RefPtr<Gfx::PaletteImpl> m_palette_impl;
     Web::DevicePixelRect m_screen_rect;
     Web::DevicePixelSize m_content_size;
@@ -208,7 +208,7 @@ private:
 
     WeakPtr<WebContentConsoleClient> m_top_level_document_console_client;
 
-    JS::Handle<JS::GlobalObject> m_console_global_object;
+    GC::Root<JS::GlobalObject> m_console_global_object;
 
     RefPtr<Core::Timer> m_paint_refresh_timer;
 };
diff --git a/Services/WebContent/PageHost.h b/Services/WebContent/PageHost.h
index 3ab94b3c10d..fad72de3329 100644
--- a/Services/WebContent/PageHost.h
+++ b/Services/WebContent/PageHost.h
@@ -11,7 +11,7 @@
 #include <AK/Function.h>
 #include <AK/HashMap.h>
 #include <AK/NonnullOwnPtr.h>
-#include <LibJS/Heap/Handle.h>
+#include <LibGC/Root.h>
 #include <WebContent/Forward.h>
 
 namespace WebContent {
@@ -34,7 +34,7 @@ private:
     explicit PageHost(ConnectionFromClient&);
 
     ConnectionFromClient& m_client;
-    HashMap<u64, JS::Handle<PageClient>> m_pages;
+    HashMap<u64, GC::Root<PageClient>> m_pages;
     u64 m_next_id { 0 };
 };
 
diff --git a/Services/WebContent/WebContentConsoleClient.cpp b/Services/WebContent/WebContentConsoleClient.cpp
index b29b0377358..821df1cb2b8 100644
--- a/Services/WebContent/WebContentConsoleClient.cpp
+++ b/Services/WebContent/WebContentConsoleClient.cpp
@@ -24,7 +24,7 @@
 
 namespace WebContent {
 
-JS_DEFINE_ALLOCATOR(WebContentConsoleClient);
+GC_DEFINE_ALLOCATOR(WebContentConsoleClient);
 
 WebContentConsoleClient::WebContentConsoleClient(JS::Console& console, JS::Realm& realm, PageClient& client)
     : ConsoleClient(console)
@@ -150,7 +150,7 @@ JS::ThrowCompletionOr<JS::Value> WebContentConsoleClient::printer(JS::Console::L
     if (log_level == JS::Console::LogLevel::Table) {
         auto& vm = m_console->realm().vm();
 
-        auto table_args = arguments.get<JS::MarkedVector<JS::Value>>();
+        auto table_args = arguments.get<GC::MarkedVector<JS::Value>>();
         auto& table = table_args.at(0).as_object();
         auto& columns = TRY(table.get(JS::PropertyKey("columns"))).as_array().indexed_properties();
         auto& rows = TRY(table.get(JS::PropertyKey("rows"))).as_array().indexed_properties();
@@ -244,7 +244,7 @@ JS::ThrowCompletionOr<JS::Value> WebContentConsoleClient::printer(JS::Console::L
         return JS::js_undefined();
     }
 
-    auto output = TRY(generically_format_values(arguments.get<JS::MarkedVector<JS::Value>>()));
+    auto output = TRY(generically_format_values(arguments.get<GC::MarkedVector<JS::Value>>()));
     m_console->output_debug_message(log_level, output);
 
     StringBuilder html;
diff --git a/Services/WebContent/WebContentConsoleClient.h b/Services/WebContent/WebContentConsoleClient.h
index a28b3f7ccdc..6be8c60f50a 100644
--- a/Services/WebContent/WebContentConsoleClient.h
+++ b/Services/WebContent/WebContentConsoleClient.h
@@ -19,8 +19,8 @@
 namespace WebContent {
 
 class WebContentConsoleClient final : public JS::ConsoleClient {
-    JS_CELL(WebContentConsoleClient, JS::ConsoleClient);
-    JS_DECLARE_ALLOCATOR(WebContentConsoleClient);
+    GC_CELL(WebContentConsoleClient, JS::ConsoleClient);
+    GC_DECLARE_ALLOCATOR(WebContentConsoleClient);
 
 public:
     virtual ~WebContentConsoleClient() override;
@@ -42,8 +42,8 @@ private:
         m_current_message_style.append(';');
     }
 
-    JS::NonnullGCPtr<PageClient> m_client;
-    JS::GCPtr<ConsoleGlobalEnvironmentExtensions> m_console_global_environment_extensions;
+    GC::Ref<PageClient> m_client;
+    GC::Ptr<ConsoleGlobalEnvironmentExtensions> m_console_global_environment_extensions;
 
     void clear_output();
     void print_html(ByteString const& line);
diff --git a/Services/WebContent/WebDriverConnection.cpp b/Services/WebContent/WebDriverConnection.cpp
index d25e1275a62..17829154877 100644
--- a/Services/WebContent/WebDriverConnection.cpp
+++ b/Services/WebContent/WebDriverConnection.cpp
@@ -114,7 +114,7 @@ static Gfx::IntRect compute_window_rect(Web::Page const& page)
 }
 
 // https://w3c.github.io/webdriver/#dfn-no-longer-open
-static ErrorOr<void, Web::WebDriver::Error> ensure_browsing_context_is_open(JS::GCPtr<Web::HTML::BrowsingContext> browsing_context)
+static ErrorOr<void, Web::WebDriver::Error> ensure_browsing_context_is_open(GC::Ptr<Web::HTML::BrowsingContext> browsing_context)
 {
     // A browsing context is said to be no longer open if its navigable has been destroyed.
     if (!browsing_context || browsing_context->has_navigable_been_destroyed())
@@ -309,7 +309,7 @@ Messages::WebDriverClient::NavigateToResponse WebDriverConnection::navigate_to(J
         // 7. Navigate the current top-level browsing context to url.
         current_top_level_browsing_context()->page().load(url);
 
-        auto navigation_complete = JS::create_heap_function(current_top_level_browsing_context()->heap(), [this](Web::WebDriver::Response result) {
+        auto navigation_complete = GC::create_function(current_top_level_browsing_context()->heap(), [this](Web::WebDriver::Response result) {
             // 9. Set the current browsing context with the current top-level browsing context.
             set_current_browsing_context(*current_top_level_browsing_context());
 
@@ -372,7 +372,7 @@ Messages::WebDriverClient::BackResponse WebDriverConnection::back()
         // 4. Let timer be a new timer.
         auto timer = realm.create<Web::WebDriver::HeapTimer>();
 
-        auto on_complete = JS::create_heap_function(realm.heap(), [this, timer]() {
+        auto on_complete = GC::create_function(realm.heap(), [this, timer]() {
             timer->stop();
 
             if (m_document_observer) {
@@ -406,7 +406,7 @@ Messages::WebDriverClient::BackResponse WebDriverConnection::back()
 
         // 7. If the previous step completed results in a pageHide event firing, wait until pageShow event fires or
         //    timer' timeout fired flag to be set, whichever occurs first.
-        current_top_level_browsing_context()->top_level_traversable()->append_session_history_traversal_steps(JS::create_heap_function(realm.heap(), [this, timer, on_complete]() {
+        current_top_level_browsing_context()->top_level_traversable()->append_session_history_traversal_steps(GC::create_function(realm.heap(), [this, timer, on_complete]() {
             if (timer->is_timed_out())
                 return;
 
@@ -442,7 +442,7 @@ Messages::WebDriverClient::ForwardResponse WebDriverConnection::forward()
         // 4. Let timer be a new timer.
         auto timer = realm.create<Web::WebDriver::HeapTimer>();
 
-        auto on_complete = JS::create_heap_function(realm.heap(), [this, timer]() {
+        auto on_complete = GC::create_function(realm.heap(), [this, timer]() {
             timer->stop();
 
             if (m_document_observer) {
@@ -476,7 +476,7 @@ Messages::WebDriverClient::ForwardResponse WebDriverConnection::forward()
 
         // 7. If the previous step completed results in a pageHide event firing, wait until pageShow event fires or
         //    timer' timeout fired flag to be set, whichever occurs first.
-        current_top_level_browsing_context()->top_level_traversable()->append_session_history_traversal_steps(JS::create_heap_function(realm.heap(), [this, timer, on_complete]() {
+        current_top_level_browsing_context()->top_level_traversable()->append_session_history_traversal_steps(GC::create_function(realm.heap(), [this, timer, on_complete]() {
             if (timer->is_timed_out())
                 return;
 
@@ -562,7 +562,7 @@ Messages::WebDriverClient::CloseWindowResponse WebDriverConnection::close_window
         //        traversable. We must also do so asynchronously, as the implementation will spin the event loop in some
         //        steps. If a user dialog is open in another window within this agent, the event loop will be paused, and
         //        those spins will hang. So we must return control to the client, who can deal with the dialog.
-        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(current_top_level_browsing_context()->heap(), [this]() {
+        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(current_top_level_browsing_context()->heap(), [this]() {
             current_top_level_browsing_context()->top_level_traversable()->close_top_level_traversable();
         }));
 
@@ -856,7 +856,7 @@ Messages::WebDriverClient::SetWindowRectResponse WebDriverConnection::set_window
         // FIXME: 10. Fully exit fullscreen.
 
         // 11. Restore the window.
-        restore_the_window(JS::create_heap_function(current_top_level_browsing_context()->heap(), [this, x, y, width, height]() {
+        restore_the_window(GC::create_function(current_top_level_browsing_context()->heap(), [this, x, y, width, height]() {
             auto& page = current_top_level_browsing_context()->page();
 
             // 11. If width and height are not null:
@@ -896,7 +896,7 @@ Messages::WebDriverClient::MaximizeWindowResponse WebDriverConnection::maximize_
         // FIXME: 4. Fully exit fullscreen.
 
         // 5. Restore the window.
-        restore_the_window(JS::create_heap_function(current_top_level_browsing_context()->heap(), [this]() {
+        restore_the_window(GC::create_function(current_top_level_browsing_context()->heap(), [this]() {
             // 6. Maximize the window of the current top-level browsing context.
             maximize_the_window();
         }));
@@ -919,7 +919,7 @@ Messages::WebDriverClient::MinimizeWindowResponse WebDriverConnection::minimize_
         // FIXME: 4. Fully exit fullscreen.
 
         // 5. Iconify the window.
-        iconify_the_window(JS::create_heap_function(current_top_level_browsing_context()->heap(), [this]() {
+        iconify_the_window(GC::create_function(current_top_level_browsing_context()->heap(), [this]() {
             auto& page = current_top_level_browsing_context()->page();
             async_driver_execution_complete(serialize_rect(compute_window_rect(page)));
         }));
@@ -940,7 +940,7 @@ Messages::WebDriverClient::FullscreenWindowResponse WebDriverConnection::fullscr
     // 3. Handle any user prompts and return its value if it is an error.
     handle_any_user_prompts([this]() {
         // 4. Restore the window.
-        restore_the_window(JS::create_heap_function(current_top_level_browsing_context()->heap(), [this]() {
+        restore_the_window(GC::create_function(current_top_level_browsing_context()->heap(), [this]() {
             // 5. FIXME: Call fullscreen an element with the current top-level browsing context’s active document’s document element.
             //           As described in https://fullscreen.spec.whatwg.org/#fullscreen-an-element
             //    NOTE: What we do here is basically `requestFullscreen(options)` with options["navigationUI"]="show"
@@ -1006,7 +1006,7 @@ Messages::WebDriverClient::FindElementResponse WebDriverConnection::find_element
 
     // 6. Try to handle any user prompts with session.
     handle_any_user_prompts([this, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be session's current browsing context's document element.
             auto* start_node = current_browsing_context().active_document();
 
@@ -1018,7 +1018,7 @@ Messages::WebDriverClient::FindElementResponse WebDriverConnection::find_element
         });
 
         // 9. Let result be the result of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             // 10. If result is empty, return error with error code no such element. Otherwise, return the first element of result.
             async_driver_execution_complete(extract_first_element(move(result)));
         }));
@@ -1048,7 +1048,7 @@ Messages::WebDriverClient::FindElementsResponse WebDriverConnection::find_elemen
 
     // 6. Try to handle any user prompts with session.
     handle_any_user_prompts([this, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be session's current browsing context's document element.
             auto* start_node = current_browsing_context().active_document();
 
@@ -1060,7 +1060,7 @@ Messages::WebDriverClient::FindElementsResponse WebDriverConnection::find_elemen
         });
 
         // 9. Return the result of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             async_driver_execution_complete(move(result));
         }));
     });
@@ -1088,13 +1088,13 @@ Messages::WebDriverClient::FindElementFromElementResponse WebDriverConnection::f
 
     // 6. Try to handle any user prompts with session.
     handle_any_user_prompts([this, element_id, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this, element_id]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this, element_id]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be the result of trying to get a known element with session and URL variables["element id"].
             return Web::WebDriver::get_known_element(current_browsing_context(), element_id);
         });
 
         // 8. Let result be the value of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             // 9. If result is empty, return error with error code no such element. Otherwise, return the first element of result.
             async_driver_execution_complete(extract_first_element(move(result)));
         }));
@@ -1123,13 +1123,13 @@ Messages::WebDriverClient::FindElementsFromElementResponse WebDriverConnection::
 
     // 6. Try to handle any user prompts with session.
     handle_any_user_prompts([this, element_id, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this, element_id]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this, element_id]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be the result of trying to get a known element with session and URL variables["element id"].
             return Web::WebDriver::get_known_element(current_browsing_context(), element_id);
         });
 
         // 8. Return the result of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             async_driver_execution_complete(move(result));
         }));
     });
@@ -1157,13 +1157,13 @@ Messages::WebDriverClient::FindElementFromShadowRootResponse WebDriverConnection
 
     // 6. Handle any user prompts and return its value if it is an error.
     handle_any_user_prompts([this, shadow_id, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this, shadow_id]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this, shadow_id]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be the result of trying to get a known shadow root with session and URL variables["shadow id"].
             return Web::WebDriver::get_known_shadow_root(current_browsing_context(), shadow_id);
         });
 
         // 8. Let result be the value of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             // 9. If result is empty, return error with error code no such element. Otherwise, return the first element of result.
             async_driver_execution_complete(extract_first_element(move(result)));
         }));
@@ -1192,13 +1192,13 @@ Messages::WebDriverClient::FindElementsFromShadowRootResponse WebDriverConnectio
 
     // 6. Handle any user prompts and return its value if it is an error.
     handle_any_user_prompts([this, shadow_id, location_strategy, selector = move(selector)]() mutable {
-        auto get_start_node = JS::create_heap_function(current_browsing_context().heap(), [this, shadow_id]() -> ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error> {
+        auto get_start_node = GC::create_function(current_browsing_context().heap(), [this, shadow_id]() -> ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error> {
             // 7. Let start node be the result of trying to get a known shadow root with session and URL variables["shadow id"].
             return Web::WebDriver::get_known_shadow_root(current_browsing_context(), shadow_id);
         });
 
         // 8. Return the result of trying to Find with session, start node, location strategy, and selector.
-        find(*location_strategy, move(selector), get_start_node, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        find(*location_strategy, move(selector), get_start_node, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             async_driver_execution_complete(move(result));
         }));
     });
@@ -1595,7 +1595,7 @@ Web::WebDriver::Response WebDriverConnection::element_click_impl(String const& e
     if (Web::WebDriver::is_element_obscured(paint_tree, *element_container))
         return Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::ElementClickIntercepted, "Element is obscured by another element"sv);
 
-    auto on_complete = JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+    auto on_complete = GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
         // 9. Wait until the user agent event loop has spun enough times to process the DOM events generated by the
         //    previous step.
         m_action_executor = nullptr;
@@ -1603,7 +1603,7 @@ Web::WebDriver::Response WebDriverConnection::element_click_impl(String const& e
         // FIXME: 10. Perform implementation-defined steps to allow any navigations triggered by the click to start.
 
         // 11. Try to wait for navigation to complete.
-        wait_for_navigation_to_complete(JS::create_heap_function(current_browsing_context().heap(), [this, result = move(result)](Web::WebDriver::Response navigation_result) mutable {
+        wait_for_navigation_to_complete(GC::create_function(current_browsing_context().heap(), [this, result = move(result)](Web::WebDriver::Response navigation_result) mutable {
             WEBDRIVER_TRY(navigation_result);
 
             // FIXME: 12. Try to run the post-navigation checks.
@@ -1662,7 +1662,7 @@ Web::WebDriver::Response WebDriverConnection::element_click_impl(String const& e
         // 8. Fire a click event at parent node.
         fire_an_event<Web::UIEvents::MouseEvent>(Web::UIEvents::EventNames::click, parent_node);
 
-        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(current_browsing_context().heap(), [on_complete]() {
+        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(current_browsing_context().heap(), [on_complete]() {
             on_complete->function()(JsonValue {});
         }));
     }
@@ -1721,7 +1721,7 @@ Web::WebDriver::Response WebDriverConnection::element_click_impl(String const& e
         Vector actions { move(pointer_move_action), move(pointer_down_action), move(pointer_up_action) };
 
         // 16. Dispatch a list of actions with input state, actions, current browsing context, and actions options.
-        m_action_executor = Web::WebDriver::dispatch_list_of_actions(input_state, move(actions), current_browsing_context(), move(actions_options), JS::create_heap_function(current_browsing_context().heap(), [on_complete, &input_state, input_id = move(input_id)](Web::WebDriver::Response result) {
+        m_action_executor = Web::WebDriver::dispatch_list_of_actions(input_state, move(actions), current_browsing_context(), move(actions_options), GC::create_function(current_browsing_context().heap(), [on_complete, &input_state, input_id = move(input_id)](Web::WebDriver::Response result) {
             // 17. Remove an input source with input state and input id.
             Web::WebDriver::remove_input_source(input_state, input_id);
 
@@ -1941,7 +1941,7 @@ Web::WebDriver::Response WebDriverConnection::element_send_keys_impl(String cons
         //     2. change
         // NOTE: These events are fired by `did_select_files` as an element task. So instead of firing them here, we spin
         //       the event loop once before informing the client that the action is complete.
-        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(current_browsing_context().heap(), [this]() {
+        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(current_browsing_context().heap(), [this]() {
             async_driver_execution_complete(JsonValue {});
         }));
 
@@ -2016,7 +2016,7 @@ Web::WebDriver::Response WebDriverConnection::element_send_keys_impl(String cons
     Web::WebDriver::add_input_source(input_state, input_id, move(source));
 
     // 13. Dispatch actions for a string with arguments input state, input id, and source, text, and session's current browsing context.
-    m_action_executor = Web::WebDriver::dispatch_actions_for_a_string(input_state, input_id, source, text, current_browsing_context(), JS::create_heap_function(current_browsing_context().heap(), [this, &input_state, input_id](Web::WebDriver::Response result) {
+    m_action_executor = Web::WebDriver::dispatch_actions_for_a_string(input_state, input_id, source, text, current_browsing_context(), GC::create_function(current_browsing_context().heap(), [this, &input_state, input_id](Web::WebDriver::Response result) {
         m_action_executor = nullptr;
 
         // 14. Remove an input source with input state and input id.
@@ -2078,7 +2078,7 @@ Messages::WebDriverClient::ExecuteScriptResponse WebDriverConnection::execute_sc
         auto timeout_ms = m_timeouts_configuration.script_timeout;
 
         // This handles steps 5 to 9 and produces the appropriate result type for the following steps.
-        Web::WebDriver::execute_script(current_browsing_context(), move(body), move(arguments), timeout_ms, JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::ExecutionResult result) {
+        Web::WebDriver::execute_script(current_browsing_context(), move(body), move(arguments), timeout_ms, GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::ExecutionResult result) {
             dbgln_if(WEBDRIVER_DEBUG, "Executing script returned: {}", result.value);
             handle_script_response(result);
         }));
@@ -2107,7 +2107,7 @@ Messages::WebDriverClient::ExecuteAsyncScriptResponse WebDriverConnection::execu
         auto timeout_ms = m_timeouts_configuration.script_timeout;
 
         // This handles steps 5 to 9 and produces the appropriate result type for the following steps.
-        Web::WebDriver::execute_async_script(current_browsing_context(), move(body), move(arguments), timeout_ms, JS::create_heap_function(current_browsing_context().heap(), [&](Web::WebDriver::ExecutionResult result) {
+        Web::WebDriver::execute_async_script(current_browsing_context(), move(body), move(arguments), timeout_ms, GC::create_function(current_browsing_context().heap(), [&](Web::WebDriver::ExecutionResult result) {
             dbgln_if(WEBDRIVER_DEBUG, "Executing async script returned: {}", result.value);
             handle_script_response(result);
         }));
@@ -2357,7 +2357,7 @@ Messages::WebDriverClient::PerformActionsResponse WebDriverConnection::perform_a
     handle_any_user_prompts([this, &input_state, actions_options = move(actions_options), actions_by_tick = move(actions_by_tick)]() mutable {
         // 6. Dispatch actions with input state, actions by tick, current browsing context, and actions options. If this
         //    results in an error return that error.
-        auto on_complete = JS::create_heap_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
+        auto on_complete = GC::create_function(current_browsing_context().heap(), [this](Web::WebDriver::Response result) {
             m_action_executor = nullptr;
             async_driver_execution_complete(move(result));
         });
@@ -2410,7 +2410,7 @@ Messages::WebDriverClient::DismissAlertResponse WebDriverConnection::dismiss_ale
         return Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::NoSuchAlert, "No user dialog is currently open"sv);
 
     // 3. Dismiss the current user prompt.
-    current_browsing_context().page().dismiss_dialog(JS::create_heap_function(current_browsing_context().heap(), [this]() {
+    current_browsing_context().page().dismiss_dialog(GC::create_function(current_browsing_context().heap(), [this]() {
         async_driver_execution_complete(JsonValue {});
     }));
 
@@ -2429,7 +2429,7 @@ Messages::WebDriverClient::AcceptAlertResponse WebDriverConnection::accept_alert
         return Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::NoSuchAlert, "No user dialog is currently open"sv);
 
     // 3. Accept the current user prompt.
-    current_browsing_context().page().accept_dialog(JS::create_heap_function(current_browsing_context().heap(), [this]() {
+    current_browsing_context().page().accept_dialog(GC::create_function(current_browsing_context().heap(), [this]() {
         async_driver_execution_complete(JsonValue {});
     }));
 
@@ -2510,7 +2510,7 @@ Messages::WebDriverClient::TakeScreenshotResponse WebDriverConnection::take_scre
         auto window = document->window();
 
         // 2. When the user agent is next to run the animation frame callbacks:
-        (void)window->animation_frame_callback_driver().add(JS::create_heap_function(document->heap(), [this, document](double) mutable {
+        (void)window->animation_frame_callback_driver().add(GC::create_function(document->heap(), [this, document](double) mutable {
             // a. Let root rect be session's current top-level browsing context's document element's rectangle.
             auto root_rect = calculate_absolute_rect_of_element(*document->document_element());
 
@@ -2548,7 +2548,7 @@ Messages::WebDriverClient::TakeElementScreenshotResponse WebDriverConnection::ta
         scroll_element_into_view(element);
 
         // 5. When the user agent is next to run the animation frame callbacks:
-        (void)window->animation_frame_callback_driver().add(JS::create_heap_function(document->heap(), [this, element](double) {
+        (void)window->animation_frame_callback_driver().add(GC::create_function(document->heap(), [this, element](double) {
             // a. Let element rect be element's rectangle.
             auto element_rect = calculate_absolute_rect_of_element(element);
 
@@ -2602,7 +2602,7 @@ void WebDriverConnection::set_current_top_level_browsing_context(Web::HTML::Brow
     m_current_top_level_browsing_context = browsing_context;
 
     if (m_current_top_level_browsing_context) {
-        m_current_top_level_browsing_context->page().set_window_rect_observer(JS::create_heap_function(m_current_top_level_browsing_context->heap(), [this](Web::DevicePixelRect rect) {
+        m_current_top_level_browsing_context->page().set_window_rect_observer(GC::create_function(m_current_top_level_browsing_context->heap(), [this](Web::DevicePixelRect rect) {
             if (m_pending_window_rect_requests > 0 && --m_pending_window_rect_requests == 0)
                 async_driver_execution_complete(serialize_rect(rect.to_type<int>()));
         }));
@@ -2645,19 +2645,19 @@ void WebDriverConnection::handle_any_user_prompts(Function<void()> on_dialog_clo
     // -> dismiss state
     case Web::WebDriver::UnhandledPromptBehavior::Dismiss:
         // Dismiss the current user prompt.
-        page.dismiss_dialog(JS::create_heap_function(heap, move(on_dialog_closed)));
+        page.dismiss_dialog(GC::create_function(heap, move(on_dialog_closed)));
         break;
 
     // -> accept state
     case Web::WebDriver::UnhandledPromptBehavior::Accept:
         // Accept the current user prompt.
-        page.accept_dialog(JS::create_heap_function(heap, move(on_dialog_closed)));
+        page.accept_dialog(GC::create_function(heap, move(on_dialog_closed)));
         break;
 
     // -> dismiss and notify state
     case Web::WebDriver::UnhandledPromptBehavior::DismissAndNotify:
         // Dismiss the current user prompt.
-        page.dismiss_dialog(JS::create_heap_function(heap, [this]() {
+        page.dismiss_dialog(GC::create_function(heap, [this]() {
             // Return an annotated unexpected alert open error.
             async_driver_execution_complete(Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::UnexpectedAlertOpen, "A user dialog is open"sv));
         }));
@@ -2666,7 +2666,7 @@ void WebDriverConnection::handle_any_user_prompts(Function<void()> on_dialog_clo
     // -> accept and notify state
     case Web::WebDriver::UnhandledPromptBehavior::AcceptAndNotify:
         // Accept the current user prompt.
-        page.accept_dialog(JS::create_heap_function(heap, [this]() {
+        page.accept_dialog(GC::create_function(heap, [this]() {
             // Return an annotated unexpected alert open error.
             async_driver_execution_complete(Web::WebDriver::Error::from_code(Web::WebDriver::ErrorCode::UnexpectedAlertOpen, "A user dialog is open"sv));
         }));
@@ -2755,7 +2755,7 @@ void WebDriverConnection::wait_for_navigation_to_complete(OnNavigationComplete o
         }
     });
 
-    m_navigation_timer->start(m_timeouts_configuration.page_load_timeout.value_or(300'000), JS::create_heap_function(realm.heap(), [this, on_complete, reset_observers]() {
+    m_navigation_timer->start(m_timeouts_configuration.page_load_timeout.value_or(300'000), GC::create_function(realm.heap(), [this, on_complete, reset_observers]() {
         reset_observers(*this);
 
         auto did_time_out = m_navigation_timer->is_timed_out();
@@ -2802,7 +2802,7 @@ void WebDriverConnection::maximize_the_window()
 }
 
 // https://w3c.github.io/webdriver/#dfn-iconify-the-window
-void WebDriverConnection::iconify_the_window(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_complete)
+void WebDriverConnection::iconify_the_window(GC::Ref<GC::Function<void()>> on_complete)
 {
     // To iconify the window, given an operating system level window with an associated top-level browsing context, run
     // implementation-specific steps to iconify, minimize, or hide the window from the visible screen.
@@ -2814,7 +2814,7 @@ void WebDriverConnection::iconify_the_window(JS::NonnullGCPtr<JS::HeapFunction<v
 }
 
 // https://w3c.github.io/webdriver/#dfn-restore-the-window
-void WebDriverConnection::restore_the_window(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_complete)
+void WebDriverConnection::restore_the_window(GC::Ref<GC::Function<void()>> on_complete)
 {
     // To restore the window, given an operating system level window with an associated top-level browsing context, run
     // implementation-specific steps to restore or unhide the window to the visible screen.
@@ -2825,7 +2825,7 @@ void WebDriverConnection::restore_the_window(JS::NonnullGCPtr<JS::HeapFunction<v
     wait_for_visibility_state(on_complete, Web::HTML::VisibilityState::Visible);
 }
 
-void WebDriverConnection::wait_for_visibility_state(JS::NonnullGCPtr<JS::HeapFunction<void()>> on_complete, Web::HTML::VisibilityState target_visibility_state)
+void WebDriverConnection::wait_for_visibility_state(GC::Ref<GC::Function<void()>> on_complete, Web::HTML::VisibilityState target_visibility_state)
 {
     static constexpr auto VISIBILITY_STATE_TIMEOUT_MS = 5'000;
 
@@ -2845,7 +2845,7 @@ void WebDriverConnection::wait_for_visibility_state(JS::NonnullGCPtr<JS::HeapFun
             timer->stop_and_fire_timeout_handler();
     });
 
-    timer->start(VISIBILITY_STATE_TIMEOUT_MS, JS::create_heap_function(realm.heap(), [this, on_complete]() {
+    timer->start(VISIBILITY_STATE_TIMEOUT_MS, GC::create_function(realm.heap(), [this, on_complete]() {
         m_document_observer->set_document_visibility_state_observer({});
         m_document_observer = nullptr;
 
@@ -2854,8 +2854,8 @@ void WebDriverConnection::wait_for_visibility_state(JS::NonnullGCPtr<JS::HeapFun
 }
 
 class ElementLocator final : public JS::Cell {
-    JS_CELL(ElementLocator, JS::Cell);
-    JS_DECLARE_ALLOCATOR(ElementLocator);
+    GC_CELL(ElementLocator, JS::Cell);
+    GC_DECLARE_ALLOCATOR(ElementLocator);
 
 public:
     ElementLocator(
@@ -2864,7 +2864,7 @@ public:
         ByteString selector,
         WebDriverConnection::GetStartNode get_start_node,
         WebDriverConnection::OnFindComplete on_complete,
-        JS::NonnullGCPtr<Web::WebDriver::HeapTimer> timer)
+        GC::Ref<Web::WebDriver::HeapTimer> timer)
         : m_browsing_context(browsing_context)
         , m_location_strategy(location_strategy)
         , m_selector(move(selector))
@@ -2884,7 +2884,7 @@ public:
         if (m_timer->is_timed_out())
             return;
 
-        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, JS::create_heap_function(heap(), [this]() {
+        Web::HTML::queue_a_task(Web::HTML::Task::Source::Unspecified, nullptr, nullptr, GC::create_function(heap(), [this]() {
             search_for_element();
         }));
     }
@@ -2927,7 +2927,7 @@ private:
         visitor.visit(m_timer);
     }
 
-    JS::NonnullGCPtr<Web::HTML::BrowsingContext const> m_browsing_context;
+    GC::Ref<Web::HTML::BrowsingContext const> m_browsing_context;
 
     Web::WebDriver::LocationStrategy m_location_strategy;
     ByteString m_selector;
@@ -2935,10 +2935,10 @@ private:
     WebDriverConnection::GetStartNode m_get_start_node;
     WebDriverConnection::OnFindComplete m_on_complete;
 
-    JS::NonnullGCPtr<Web::WebDriver::HeapTimer> m_timer;
+    GC::Ref<Web::WebDriver::HeapTimer> m_timer;
 };
 
-JS_DEFINE_ALLOCATOR(ElementLocator);
+GC_DEFINE_ALLOCATOR(ElementLocator);
 
 // https://w3c.github.io/webdriver/#dfn-find
 void WebDriverConnection::find(Web::WebDriver::LocationStrategy location_strategy, ByteString selector, GetStartNode get_start_node, OnFindComplete on_complete)
@@ -2954,7 +2954,7 @@ void WebDriverConnection::find(Web::WebDriver::LocationStrategy location_strateg
     // 4. Let timer be a new timer.
     auto timer = realm.create<Web::WebDriver::HeapTimer>();
 
-    auto wrapped_on_complete = JS::create_heap_function(realm.heap(), [this, on_complete, timer](Web::WebDriver::Response result) {
+    auto wrapped_on_complete = GC::create_function(realm.heap(), [this, on_complete, timer](Web::WebDriver::Response result) {
         m_element_locator = nullptr;
         timer->stop();
 
@@ -2964,7 +2964,7 @@ void WebDriverConnection::find(Web::WebDriver::LocationStrategy location_strateg
     // 5. If timeout is not null:
     if (timeout.has_value()) {
         // 1. Start the timer with timer and timeout.
-        timer->start(*timeout, JS::create_heap_function(realm.heap(), [wrapped_on_complete]() {
+        timer->start(*timeout, GC::create_function(realm.heap(), [wrapped_on_complete]() {
             wrapped_on_complete->function()({ JsonArray {} });
         }));
     }
@@ -2990,7 +2990,7 @@ ErrorOr<WebDriverConnection::ScriptArguments, Web::WebDriver::Error> WebDriverCo
     auto const& args = *TRY(Web::WebDriver::get_property<JsonArray const*>(payload, "args"sv));
 
     // 5. Let arguments be the result of calling the JSON deserialize algorithm with arguments args.
-    JS::MarkedVector<JS::Value> arguments { vm.heap() };
+    GC::MarkedVector<JS::Value> arguments { vm.heap() };
     auto& browsing_context = current_browsing_context();
 
     TRY(args.try_for_each([&](JsonValue const& arg) -> ErrorOr<void, Web::WebDriver::Error> {
@@ -3024,7 +3024,7 @@ void WebDriverConnection::delete_cookies(Optional<StringView> const& name)
 }
 
 // https://w3c.github.io/webdriver/#dfn-calculate-the-absolute-position
-Gfx::IntPoint WebDriverConnection::calculate_absolute_position_of_element(JS::NonnullGCPtr<Web::Geometry::DOMRect> rect)
+Gfx::IntPoint WebDriverConnection::calculate_absolute_position_of_element(GC::Ref<Web::Geometry::DOMRect> rect)
 {
     // 1. Let rect be the value returned by calling getBoundingClientRect().
 
diff --git a/Services/WebContent/WebDriverConnection.h b/Services/WebContent/WebDriverConnection.h
index d4dfe8abaad..a5d7380df47 100644
--- a/Services/WebContent/WebDriverConnection.h
+++ b/Services/WebContent/WebDriverConnection.h
@@ -11,11 +11,11 @@
 #include <AK/ByteString.h>
 #include <AK/HashMap.h>
 #include <AK/String.h>
+#include <LibGC/MarkedVector.h>
 #include <LibGfx/Rect.h>
 #include <LibIPC/ConnectionToServer.h>
 #include <LibIPC/Transport.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/MarkedVector.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/HTML/VisibilityState.h>
 #include <LibWeb/WebDriver/ElementLocationStrategies.h>
@@ -114,10 +114,10 @@ private:
 
     void set_current_browsing_context(Web::HTML::BrowsingContext&);
     Web::HTML::BrowsingContext& current_browsing_context() { return *m_current_browsing_context; }
-    JS::GCPtr<Web::HTML::BrowsingContext> current_parent_browsing_context() { return m_current_parent_browsing_context; }
+    GC::Ptr<Web::HTML::BrowsingContext> current_parent_browsing_context() { return m_current_parent_browsing_context; }
 
     void set_current_top_level_browsing_context(Web::HTML::BrowsingContext&);
-    JS::GCPtr<Web::HTML::BrowsingContext> current_top_level_browsing_context() { return m_current_top_level_browsing_context; }
+    GC::Ptr<Web::HTML::BrowsingContext> current_top_level_browsing_context() { return m_current_top_level_browsing_context; }
 
     ErrorOr<void, Web::WebDriver::Error> ensure_current_browsing_context_is_open();
     ErrorOr<void, Web::WebDriver::Error> ensure_current_top_level_browsing_context_is_open();
@@ -130,23 +130,23 @@ private:
     void handle_any_user_prompts(Function<void()> on_dialog_closed);
 
     void maximize_the_window();
-    void iconify_the_window(JS::NonnullGCPtr<JS::HeapFunction<void()>>);
-    void restore_the_window(JS::NonnullGCPtr<JS::HeapFunction<void()>>);
-    void wait_for_visibility_state(JS::NonnullGCPtr<JS::HeapFunction<void()>>, Web::HTML::VisibilityState);
+    void iconify_the_window(GC::Ref<GC::Function<void()>>);
+    void restore_the_window(GC::Ref<GC::Function<void()>>);
+    void wait_for_visibility_state(GC::Ref<GC::Function<void()>>, Web::HTML::VisibilityState);
 
-    using OnNavigationComplete = JS::NonnullGCPtr<JS::HeapFunction<void(Web::WebDriver::Response)>>;
+    using OnNavigationComplete = GC::Ref<GC::Function<void(Web::WebDriver::Response)>>;
     void wait_for_navigation_to_complete(OnNavigationComplete);
 
-    Gfx::IntPoint calculate_absolute_position_of_element(JS::NonnullGCPtr<Web::Geometry::DOMRect> rect);
+    Gfx::IntPoint calculate_absolute_position_of_element(GC::Ref<Web::Geometry::DOMRect> rect);
     Gfx::IntRect calculate_absolute_rect_of_element(Web::DOM::Element const& element);
 
-    using GetStartNode = JS::NonnullGCPtr<JS::HeapFunction<ErrorOr<JS::NonnullGCPtr<Web::DOM::ParentNode>, Web::WebDriver::Error>()>>;
-    using OnFindComplete = JS::NonnullGCPtr<JS::HeapFunction<void(Web::WebDriver::Response)>>;
+    using GetStartNode = GC::Ref<GC::Function<ErrorOr<GC::Ref<Web::DOM::ParentNode>, Web::WebDriver::Error>()>>;
+    using OnFindComplete = GC::Ref<GC::Function<void(Web::WebDriver::Response)>>;
     void find(Web::WebDriver::LocationStrategy, ByteString, GetStartNode, OnFindComplete);
 
     struct ScriptArguments {
         ByteString script;
-        JS::MarkedVector<JS::Value> arguments;
+        GC::MarkedVector<JS::Value> arguments;
     };
     ErrorOr<ScriptArguments, Web::WebDriver::Error> extract_the_script_arguments_from_a_request(JS::VM&, JsonValue const& payload);
     void handle_script_response(Web::WebDriver::ExecutionResult);
@@ -166,25 +166,25 @@ private:
     Web::WebDriver::TimeoutsConfiguration m_timeouts_configuration;
 
     // https://w3c.github.io/webdriver/#dfn-current-browsing-context
-    JS::GCPtr<Web::HTML::BrowsingContext> m_current_browsing_context;
+    GC::Ptr<Web::HTML::BrowsingContext> m_current_browsing_context;
 
     // https://w3c.github.io/webdriver/#dfn-current-parent-browsing-context
-    JS::GCPtr<Web::HTML::BrowsingContext> m_current_parent_browsing_context;
+    GC::Ptr<Web::HTML::BrowsingContext> m_current_parent_browsing_context;
 
     // https://w3c.github.io/webdriver/#dfn-current-top-level-browsing-context
-    JS::GCPtr<Web::HTML::BrowsingContext> m_current_top_level_browsing_context;
+    GC::Ptr<Web::HTML::BrowsingContext> m_current_top_level_browsing_context;
 
     size_t m_pending_window_rect_requests { 0 };
     bool m_has_pending_script_execution { false };
 
     friend class ElementLocator;
-    JS::GCPtr<ElementLocator> m_element_locator;
+    GC::Ptr<ElementLocator> m_element_locator;
 
-    JS::GCPtr<JS::Cell> m_action_executor;
+    GC::Ptr<JS::Cell> m_action_executor;
 
-    JS::GCPtr<Web::DOM::DocumentObserver> m_document_observer;
-    JS::GCPtr<Web::HTML::NavigationObserver> m_navigation_observer;
-    JS::GCPtr<Web::WebDriver::HeapTimer> m_navigation_timer;
+    GC::Ptr<Web::DOM::DocumentObserver> m_document_observer;
+    GC::Ptr<Web::HTML::NavigationObserver> m_navigation_observer;
+    GC::Ptr<Web::WebDriver::HeapTimer> m_navigation_timer;
 };
 
 }
diff --git a/Services/WebContent/main.cpp b/Services/WebContent/main.cpp
index 457724af6c6..d0fbfbe2860 100644
--- a/Services/WebContent/main.cpp
+++ b/Services/WebContent/main.cpp
@@ -48,7 +48,7 @@
 
 static ErrorOr<void> load_content_filters(StringView config_path);
 static ErrorOr<void> load_autoplay_allowlist(StringView config_path);
-static ErrorOr<void> initialize_resource_loader(JS::Heap&, int request_server_socket);
+static ErrorOr<void> initialize_resource_loader(GC::Heap&, int request_server_socket);
 static ErrorOr<void> initialize_image_decoder(int image_decoder_socket);
 static ErrorOr<void> reinitialize_image_decoder(IPC::File const& image_decoder_socket);
 
@@ -256,7 +256,7 @@ static ErrorOr<void> load_autoplay_allowlist(StringView config_path)
     return {};
 }
 
-ErrorOr<void> initialize_resource_loader(JS::Heap& heap, int request_server_socket)
+ErrorOr<void> initialize_resource_loader(GC::Heap& heap, int request_server_socket)
 {
     static_assert(IsSame<IPC::Transport, IPC::TransportSocket>, "Need to handle other IPC transports here");
 
diff --git a/Services/WebWorker/CMakeLists.txt b/Services/WebWorker/CMakeLists.txt
index 7aab10451c0..6b65d3a6be1 100644
--- a/Services/WebWorker/CMakeLists.txt
+++ b/Services/WebWorker/CMakeLists.txt
@@ -13,7 +13,7 @@ target_include_directories(webworkerservice PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/
 target_include_directories(webworkerservice PRIVATE ${LADYBIRD_SOURCE_DIR})
 target_include_directories(webworkerservice PRIVATE ${LADYBIRD_SOURCE_DIR}/Services/)
 
-target_link_libraries(webworkerservice PUBLIC LibCore LibFileSystem LibGfx LibIPC LibJS LibRequests LibWeb LibWebView LibUnicode LibImageDecoderClient LibMain LibURL)
+target_link_libraries(webworkerservice PUBLIC LibCore LibFileSystem LibGfx LibIPC LibJS LibRequests LibWeb LibWebView LibUnicode LibImageDecoderClient LibMain LibURL LibGC)
 
 if (ENABLE_QT)
     qt_add_executable(WebWorker main.cpp)
diff --git a/Services/WebWorker/ConnectionFromClient.h b/Services/WebWorker/ConnectionFromClient.h
index 77aa66dea32..a3c9d0018ee 100644
--- a/Services/WebWorker/ConnectionFromClient.h
+++ b/Services/WebWorker/ConnectionFromClient.h
@@ -7,9 +7,9 @@
 #pragma once
 
 #include <AK/HashMap.h>
+#include <LibGC/Root.h>
 #include <LibIPC/ConnectionFromClient.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Heap/Handle.h>
 #include <LibWeb/Forward.h>
 #include <LibWeb/Loader/FileRequest.h>
 #include <LibWeb/Worker/WebWorkerClientEndpoint.h>
@@ -44,7 +44,7 @@ private:
     virtual void start_dedicated_worker(URL::URL const& url, Web::Bindings::WorkerType const& type, Web::Bindings::RequestCredentials const& credentials, String const& name, Web::HTML::TransferDataHolder const&, Web::HTML::SerializedEnvironmentSettingsObject const&) override;
     virtual void handle_file_return(i32 error, Optional<IPC::File> const& file, i32 request_id) override;
 
-    JS::Handle<PageHost> m_page_host;
+    GC::Root<PageHost> m_page_host;
 
     // FIXME: Route console messages to the Browser UI using a ConsoleClient
 
diff --git a/Services/WebWorker/DedicatedWorkerHost.cpp b/Services/WebWorker/DedicatedWorkerHost.cpp
index 8e53036658b..74ae018161f 100644
--- a/Services/WebWorker/DedicatedWorkerHost.cpp
+++ b/Services/WebWorker/DedicatedWorkerHost.cpp
@@ -33,7 +33,7 @@ DedicatedWorkerHost::~DedicatedWorkerHost() = default;
 
 // https://html.spec.whatwg.org/multipage/workers.html#run-a-worker
 // FIXME: Extract out into a helper for both shared and dedicated workers
-void DedicatedWorkerHost::run(JS::NonnullGCPtr<Web::Page> page, Web::HTML::TransferDataHolder message_port_data, Web::HTML::SerializedEnvironmentSettingsObject const& outside_settings_snapshot)
+void DedicatedWorkerHost::run(GC::Ref<Web::Page> page, Web::HTML::TransferDataHolder message_port_data, Web::HTML::SerializedEnvironmentSettingsObject const& outside_settings_snapshot)
 {
     bool const is_shared = false;
 
@@ -55,7 +55,7 @@ void DedicatedWorkerHost::run(JS::NonnullGCPtr<Web::Page> page, Web::HTML::Trans
 
     // 8. Let worker global scope be the global object of realm execution context's Realm component.
     // NOTE: This is the DedicatedWorkerGlobalScope or SharedWorkerGlobalScope object created in the previous step.
-    JS::NonnullGCPtr<Web::HTML::WorkerGlobalScope> worker_global_scope = verify_cast<Web::HTML::WorkerGlobalScope>(realm_execution_context->realm->global_object());
+    GC::Ref<Web::HTML::WorkerGlobalScope> worker_global_scope = verify_cast<Web::HTML::WorkerGlobalScope>(realm_execution_context->realm->global_object());
 
     // 9. Set up a worker environment settings object with realm execution context,
     //    outside settings, and unsafeWorkerCreationTime, and let inside settings be the result.
@@ -92,7 +92,7 @@ void DedicatedWorkerHost::run(JS::NonnullGCPtr<Web::Page> page, Web::HTML::Trans
                                  : Web::Fetch::Infrastructure::Request::Destination::Worker;
 
     // In both cases, let performFetch be the following perform the fetch hook given request, isTopLevel and processCustomFetchResponse:
-    auto perform_fetch_function = [inner_settings, worker_global_scope](JS::NonnullGCPtr<Web::Fetch::Infrastructure::Request> request, Web::HTML::TopLevelModule is_top_level, Web::Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction process_custom_fetch_response) -> Web::WebIDL::ExceptionOr<void> {
+    auto perform_fetch_function = [inner_settings, worker_global_scope](GC::Ref<Web::Fetch::Infrastructure::Request> request, Web::HTML::TopLevelModule is_top_level, Web::Fetch::Infrastructure::FetchAlgorithms::ProcessResponseConsumeBodyFunction process_custom_fetch_response) -> Web::WebIDL::ExceptionOr<void> {
         auto& realm = inner_settings->realm();
         auto& vm = realm.vm();
 
@@ -106,10 +106,10 @@ void DedicatedWorkerHost::run(JS::NonnullGCPtr<Web::Page> page, Web::HTML::Trans
         }
 
         // 2. Set request's reserved client to inside settings.
-        request->set_reserved_client(JS::GCPtr<Web::HTML::EnvironmentSettingsObject>(inner_settings));
+        request->set_reserved_client(GC::Ptr<Web::HTML::EnvironmentSettingsObject>(inner_settings));
 
         // We need to store the process custom fetch response function on the heap here, because we're storing it in another heap function
-        auto process_custom_fetch_response_function = JS::create_heap_function(vm.heap(), move(process_custom_fetch_response));
+        auto process_custom_fetch_response_function = GC::create_function(vm.heap(), move(process_custom_fetch_response));
 
         // 3. Fetch request with processResponseConsumeBody set to the following steps given response response and null, failure, or a byte sequence bodyBytes:
         fetch_algorithms_input.process_response_consume_body = [worker_global_scope, process_custom_fetch_response_function](auto response, auto body_bytes) {
@@ -142,7 +142,7 @@ void DedicatedWorkerHost::run(JS::NonnullGCPtr<Web::Page> page, Web::HTML::Trans
     };
     auto perform_fetch = Web::HTML::create_perform_the_fetch_hook(inner_settings->heap(), move(perform_fetch_function));
 
-    auto on_complete_function = [inner_settings, worker_global_scope, message_port_data = move(message_port_data), url = m_url](JS::GCPtr<Web::HTML::Script> script) mutable {
+    auto on_complete_function = [inner_settings, worker_global_scope, message_port_data = move(message_port_data), url = m_url](GC::Ptr<Web::HTML::Script> script) mutable {
         auto& realm = inner_settings->realm();
         // 1. If script is null or if script's error to rethrow is non-null, then:
         if (!script || !script->error_to_rethrow().is_null()) {
diff --git a/Services/WebWorker/DedicatedWorkerHost.h b/Services/WebWorker/DedicatedWorkerHost.h
index 7712ec157d4..891e1c6ef79 100644
--- a/Services/WebWorker/DedicatedWorkerHost.h
+++ b/Services/WebWorker/DedicatedWorkerHost.h
@@ -21,10 +21,10 @@ public:
     explicit DedicatedWorkerHost(URL::URL url, Web::Bindings::WorkerType type, String name);
     ~DedicatedWorkerHost();
 
-    void run(JS::NonnullGCPtr<Web::Page>, Web::HTML::TransferDataHolder message_port_data, Web::HTML::SerializedEnvironmentSettingsObject const&);
+    void run(GC::Ref<Web::Page>, Web::HTML::TransferDataHolder message_port_data, Web::HTML::SerializedEnvironmentSettingsObject const&);
 
 private:
-    JS::Handle<Web::HTML::WorkerDebugConsoleClient> m_console;
+    GC::Root<Web::HTML::WorkerDebugConsoleClient> m_console;
 
     URL::URL m_url;
     Web::Bindings::WorkerType m_type;
diff --git a/Services/WebWorker/PageHost.cpp b/Services/WebWorker/PageHost.cpp
index 51faf108d99..c977200c307 100644
--- a/Services/WebWorker/PageHost.cpp
+++ b/Services/WebWorker/PageHost.cpp
@@ -11,9 +11,9 @@
 
 namespace WebWorker {
 
-JS_DEFINE_ALLOCATOR(PageHost);
+GC_DEFINE_ALLOCATOR(PageHost);
 
-JS::NonnullGCPtr<PageHost> PageHost::create(JS::VM& vm, ConnectionFromClient& client)
+GC::Ref<PageHost> PageHost::create(JS::VM& vm, ConnectionFromClient& client)
 {
     return vm.heap().allocate<PageHost>(client);
 }
diff --git a/Services/WebWorker/PageHost.h b/Services/WebWorker/PageHost.h
index 0a4e0524406..dc2ea373b72 100644
--- a/Services/WebWorker/PageHost.h
+++ b/Services/WebWorker/PageHost.h
@@ -14,11 +14,11 @@
 namespace WebWorker {
 
 class PageHost final : public Web::PageClient {
-    JS_CELL(PageHost, Web::PageClient);
-    JS_DECLARE_ALLOCATOR(PageHost);
+    GC_CELL(PageHost, Web::PageClient);
+    GC_DECLARE_ALLOCATOR(PageHost);
 
 public:
-    static JS::NonnullGCPtr<PageHost> create(JS::VM& vm, ConnectionFromClient& client);
+    static GC::Ref<PageHost> create(JS::VM& vm, ConnectionFromClient& client);
 
     virtual ~PageHost();
 
@@ -45,7 +45,7 @@ private:
     void setup_palette();
 
     ConnectionFromClient& m_client;
-    JS::NonnullGCPtr<Web::Page> m_page;
+    GC::Ref<Web::Page> m_page;
     RefPtr<Gfx::PaletteImpl> m_palette_impl;
 };
 
diff --git a/Services/WebWorker/main.cpp b/Services/WebWorker/main.cpp
index f579f65b2aa..b987d5a7db7 100644
--- a/Services/WebWorker/main.cpp
+++ b/Services/WebWorker/main.cpp
@@ -29,7 +29,7 @@
 #    include <QCoreApplication>
 #endif
 
-static ErrorOr<void> initialize_resource_loader(JS::Heap&, int request_server_socket);
+static ErrorOr<void> initialize_resource_loader(GC::Heap&, int request_server_socket);
 
 ErrorOr<int> serenity_main(Main::Arguments arguments)
 {
@@ -71,7 +71,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     return event_loop.exec();
 }
 
-static ErrorOr<void> initialize_resource_loader(JS::Heap& heap, int request_server_socket)
+static ErrorOr<void> initialize_resource_loader(GC::Heap& heap, int request_server_socket)
 {
     static_assert(IsSame<IPC::Transport, IPC::TransportSocket>, "Need to handle other IPC transports here");
 
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_are_missing_expected_macros.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_are_missing_expected_macros.cpp
index c79066d26c9..8933653b7a9 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_are_missing_expected_macros.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_are_missing_expected_macros.cpp
@@ -9,7 +9,7 @@
 #include <LibJS/Runtime/PrototypeObject.h>
 #include <LibWeb/Bindings/PlatformObject.h>
 
-// expected-error@+1 {{Expected record to have a JS_CELL macro invocation}}
+// expected-error@+1 {{Expected record to have a GC_CELL macro invocation}}
 class TestCellClass : JS::Cell {
 };
 
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_expected_macros.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_expected_macros.cpp
index e02fe9259e8..a4759fcb666 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_expected_macros.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_expected_macros.cpp
@@ -11,7 +11,7 @@
 #include <LibWeb/Bindings/PlatformObject.h>
 
 class TestCellClass : JS::Cell {
-    JS_CELL(TestCellClass, JS::Cell);
+    GC_CELL(TestCellClass, JS::Cell);
 };
 
 class TestObjectClass : JS::Object {
@@ -37,16 +37,16 @@ class TestPrototypeClass : JS::PrototypeObject<TestCellClass, TestCellClass> {
 // Nested classes
 class Parent1 { };
 class Parent2 : JS::Cell {
-    JS_CELL(Parent2, JS::Cell);
+    GC_CELL(Parent2, JS::Cell);
 };
 class Parent3 { };
 class Parent4 : public Parent2 {
-    JS_CELL(Parent4, Parent2);
+    GC_CELL(Parent4, Parent2);
 };
 
 class NestedCellClass
     : Parent1
     , Parent3
     , Parent4 {
-    JS_CELL(NestedCellClass, Parent4); // Not Parent2
+    GC_CELL(NestedCellClass, Parent4); // Not Parent2
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_incorrect_macro_types.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_incorrect_macro_types.cpp
index eb777ac1c16..c9322f86c71 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_incorrect_macro_types.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/classes_have_incorrect_macro_types.cpp
@@ -15,22 +15,22 @@
 //       have a comma in it, and wouldn't be passable as the basename without a typedef.
 
 class CellWithObjectMacro : JS::Cell {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_CELL}}
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected GC_CELL}}
     JS_OBJECT(CellWithObjectMacro, JS::Cell);
 };
 
 class CellWithEnvironmentMacro : JS::Cell {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_CELL}}
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected GC_CELL}}
     JS_ENVIRONMENT(CellWithEnvironmentMacro, JS::Cell);
 };
 
 class ObjectWithCellMacro : JS::Object {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_OBJECT}}
-    JS_CELL(ObjectWithCellMacro, JS::Object);
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected JS_OBJECT}}
+    GC_CELL(ObjectWithCellMacro, JS::Object);
 };
 
 class ObjectWithEnvironmentMacro : JS::Object {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_OBJECT}}
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected JS_OBJECT}}
     JS_ENVIRONMENT(ObjectWithEnvironmentMacro, JS::Object);
 };
 
@@ -38,12 +38,12 @@ class ObjectWithEnvironmentMacro : JS::Object {
 namespace JS {
 
 class CellWithPrototypeMacro : Cell {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_CELL}}
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected GC_CELL}}
     JS_PROTOTYPE_OBJECT(CellWithPrototypeMacro, Cell, Cell);
 };
 
 class ObjectWithPrototypeMacro : Object {
-    // expected-error@+1 {{Invalid JS-CELL-like macro invocation; expected JS_OBJECT}}
+    // expected-error@+1 {{Invalid GC-CELL-like macro invocation; expected JS_OBJECT}}
     JS_PROTOTYPE_OBJECT(ObjectWithPrototypeMacro, Object, Object);
 };
 
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/nested_macros.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/nested_macros.cpp
index b8778d26fe5..85247d3a54c 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/nested_macros.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/nested_macros.cpp
@@ -12,7 +12,7 @@ class TestClass : JS::Object {
     JS_OBJECT(TestClass, JS::Object);
 
     struct NestedClassOk : JS::Cell {
-        JS_CELL(NestedClassOk, JS::Cell);
+        GC_CELL(NestedClassOk, JS::Cell);
     };
 
     // expected-error@+1 {{Expected record to have a JS_OBJECT macro invocation}}
@@ -26,7 +26,7 @@ class TestClass : JS::Object {
 // Same test, but the parent object is not a cell
 class TestClass2 {
     struct NestedClassOk : JS::Cell {
-        JS_CELL(NestedClassOk, JS::Cell);
+        GC_CELL(NestedClassOk, JS::Cell);
     };
 
     // expected-error@+1 {{Expected record to have a JS_OBJECT macro invocation}}
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_basename_arg.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_basename_arg.cpp
index 0204748760a..f398ece5b38 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_basename_arg.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_basename_arg.cpp
@@ -33,17 +33,17 @@ class TestClass : ::ParentObject {
 // Nested classes
 class Parent1 { };
 class Parent2 : JS::Cell {
-    JS_CELL(Parent2, JS::Cell);
+    GC_CELL(Parent2, JS::Cell);
 };
 class Parent3 { };
 class Parent4 : public Parent2 {
-    JS_CELL(Parent4, Parent2);
+    GC_CELL(Parent4, Parent2);
 };
 
 class NestedCellClass
     : Parent1
     , Parent3
     , Parent4 {
-    // expected-error@+1 {{Expected second argument of JS_CELL macro invocation to be Parent4}}
-    JS_CELL(NestedCellClass, Parent2);
+    // expected-error@+1 {{Expected second argument of GC_CELL macro invocation to be Parent4}}
+    GC_CELL(NestedCellClass, Parent2);
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_classname_arg.cpp b/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_classname_arg.cpp
index a51a5a69a83..9f5e9f7aca0 100644
--- a/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_classname_arg.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/Macros/wrong_classname_arg.cpp
@@ -12,8 +12,8 @@
 // An incorrect first argument for JS_PROTOTYPE_OBJECT is a compile error, so that is not tested
 
 class TestCellClass : JS::Cell {
-    // expected-error@+1 {{Expected first argument of JS_CELL macro invocation to be TestCellClass}}
-    JS_CELL(bad, JS::Cell);
+    // expected-error@+1 {{Expected first argument of GC_CELL macro invocation to be TestCellClass}}
+    GC_CELL(bad, JS::Cell);
 };
 
 class TestObjectClass : JS::Object {
@@ -36,6 +36,6 @@ struct Outer {
 };
 
 struct Outer::Inner : JS::Cell {
-    // expected-error@+1 {{Expected first argument of JS_CELL macro invocation to be Outer::Inner}}
-    JS_CELL(Inner, JS::Cell);
+    // expected-error@+1 {{Expected first argument of GC_CELL macro invocation to be Outer::Inner}}
+    GC_CELL(Inner, JS::Cell);
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/cell_member_not_wrapped.cpp b/Tests/ClangPlugins/LibJSGCTests/cell_member_not_wrapped.cpp
index 1c01200d016..f9c718cf69e 100644
--- a/Tests/ClangPlugins/LibJSGCTests/cell_member_not_wrapped.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/cell_member_not_wrapped.cpp
@@ -30,15 +30,15 @@ private:
         visitor.visit(m_object_ptr);
     }
 
-    // expected-error@+1 {{reference to JS::CellImpl type should be wrapped in JS::NonnullGCPtr}}
+    // expected-error@+1 {{reference to GC::Cell type should be wrapped in GC::Ref}}
     JS::Object& m_object_ref;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     JS::Object* m_object_ptr;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     Vector<JS::Object*> m_objects;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     NewType1* m_newtype_1;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     NewType2* m_newtype_2;
 };
 
@@ -50,14 +50,14 @@ public:
     }
 
 private:
-    // expected-error@+1 {{reference to JS::CellImpl type should be wrapped in JS::NonnullGCPtr}}
+    // expected-error@+1 {{reference to GC::Cell type should be wrapped in GC::Ref}}
     JS::Object& m_object_ref;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     JS::Object* m_object_ptr;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     Vector<JS::Object*> m_objects;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     NewType1* m_newtype_1;
-    // expected-error@+1 {{pointer to JS::CellImpl type should be wrapped in JS::GCPtr}}
+    // expected-error@+1 {{pointer to GC::Cell type should be wrapped in GC::Ptr}}
     NewType2* m_newtype_2;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_accessed.cpp b/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_accessed.cpp
index ee534facaf8..7541fac0fbd 100644
--- a/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_accessed.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_accessed.cpp
@@ -20,5 +20,5 @@ class TestClass : public JS::Object {
         (void)m_object;
     }
 
-    JS::GCPtr<JS::Object> m_object;
+    GC::Ptr<JS::Object> m_object;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_visited.cpp b/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_visited.cpp
index 15e3a8e24b7..1dfe5e16e7d 100644
--- a/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_visited.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/gc_allocated_member_is_visited.cpp
@@ -18,5 +18,5 @@ class TestClass : public JS::Object {
         visitor.visit(m_object);
     }
 
-    JS::GCPtr<JS::Object> m_object;
+    GC::Ptr<JS::Object> m_object;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/missing_member_in_visit_edges.cpp b/Tests/ClangPlugins/LibJSGCTests/missing_member_in_visit_edges.cpp
index 5f41cedbaa0..fc3e580593b 100644
--- a/Tests/ClangPlugins/LibJSGCTests/missing_member_in_visit_edges.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/missing_member_in_visit_edges.cpp
@@ -17,5 +17,5 @@ class TestClass : public JS::Object {
     }
 
     // expected-error@+1 {{GC-allocated member is not visited in TestClass::visit_edges}}
-    JS::GCPtr<JS::Object> m_object;
+    GC::Ptr<JS::Object> m_object;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/missing_visit_edges_method.cpp b/Tests/ClangPlugins/LibJSGCTests/missing_visit_edges_method.cpp
index 8f49ba0e4c6..836fbaff15a 100644
--- a/Tests/ClangPlugins/LibJSGCTests/missing_visit_edges_method.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/missing_visit_edges_method.cpp
@@ -8,9 +8,9 @@
 
 #include <LibJS/Runtime/Object.h>
 
-// expected-error@+1 {{JS::Cell-inheriting class TestClass contains a GC-allocated member 'm_cell' but has no visit_edges method}}
+// expected-error@+1 {{GC::Cell-inheriting class TestClass contains a GC-allocated member 'm_cell' but has no visit_edges method}}
 class TestClass : public JS::Object {
     JS_OBJECT(TestClass, JS::Object);
 
-    JS::GCPtr<JS::Object> m_cell;
+    GC::Ptr<JS::Object> m_cell;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/non_cell_class.cpp b/Tests/ClangPlugins/LibJSGCTests/non_cell_class.cpp
index c77abf0a081..b5a4e2a3933 100644
--- a/Tests/ClangPlugins/LibJSGCTests/non_cell_class.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/non_cell_class.cpp
@@ -10,5 +10,5 @@
 #include <LibJS/Runtime/Object.h>
 
 class NonCell {
-    JS::GCPtr<JS::Object> m_object;
+    GC::Ptr<JS::Object> m_object;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/not_visiting_rawgcptr.cpp b/Tests/ClangPlugins/LibJSGCTests/not_visiting_rawgcptr.cpp
index de541818d73..381f2ef5493 100644
--- a/Tests/ClangPlugins/LibJSGCTests/not_visiting_rawgcptr.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/not_visiting_rawgcptr.cpp
@@ -7,10 +7,11 @@
 // RUN: %clang++ -cc1 -verify %plugin_opts% %s 2>&1
 // expected-no-diagnostics
 
+#include <LibGC/Cell.h>
 #include <LibJS/Runtime/Object.h>
 
 class TestClass : public JS::Object {
     JS_OBJECT(TestClass, JS::Object);
 
-    JS::RawGCPtr<JS::Object> m_object;
+    GC::RawPtr<JS::Object> m_object;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/strong_root_fields_in_gc_allocated_types.cpp b/Tests/ClangPlugins/LibJSGCTests/strong_root_fields_in_gc_allocated_types.cpp
index 270ebe2a50c..8acc71d3334 100644
--- a/Tests/ClangPlugins/LibJSGCTests/strong_root_fields_in_gc_allocated_types.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/strong_root_fields_in_gc_allocated_types.cpp
@@ -12,12 +12,12 @@
 #include <LibJS/Heap/Handle.h>
 
 class CellClass : JS::Cell {
-    JS_CELL(CellClass, JS::Cell);
+    GC_CELL(CellClass, JS::Cell);
 
-    // expected-warning@+1 {{Types inheriting from JS::Cell should not have JS::Handle fields}}
-    JS::Handle<JS::Cell> m_handle;
+    // expected-warning@+1 {{Types inheriting from GC::Cell should not have GC::Root fields}}
+    GC::Root<JS::Cell> m_handle;
 };
 
 class NonCellClass {
-    JS::Handle<JS::Cell> m_handle;
+    GC::Root<JS::Cell> m_handle;
 };
diff --git a/Tests/ClangPlugins/LibJSGCTests/wrapping_non_cell_member.cpp b/Tests/ClangPlugins/LibJSGCTests/wrapping_non_cell_member.cpp
index ce524e66d45..b642e89452e 100644
--- a/Tests/ClangPlugins/LibJSGCTests/wrapping_non_cell_member.cpp
+++ b/Tests/ClangPlugins/LibJSGCTests/wrapping_non_cell_member.cpp
@@ -6,16 +6,16 @@
 
 // RUN: %clang++ -cc1 -verify %plugin_opts% %s 2>&1
 
-#include <LibJS/Heap/GCPtr.h>
-#include <LibJS/Heap/MarkedVector.h>
+#include <LibGC/MarkedVector.h>
+#include <LibGC/Ptr.h>
 
 struct NotACell { };
 
 class TestClass {
-    // expected-error@+1 {{Specialization type must inherit from JS::Cell}}
-    JS::GCPtr<NotACell> m_member_1;
-    // expected-error@+1 {{Specialization type must inherit from JS::Cell}}
-    JS::NonnullGCPtr<NotACell> m_member_2;
-    // expected-error@+1 {{Specialization type must inherit from JS::Cell}}
-    JS::RawGCPtr<NotACell> m_member_3;
+    // expected-error@+1 {{Specialization type must inherit from GC::Cell}}
+    GC::Ptr<NotACell> m_member_1;
+    // expected-error@+1 {{Specialization type must inherit from GC::Cell}}
+    GC::Ref<NotACell> m_member_2;
+    // expected-error@+1 {{Specialization type must inherit from GC::Cell}}
+    GC::RawPtr<NotACell> m_member_3;
 };
diff --git a/Tests/LibJS/test-value-js.cpp b/Tests/LibJS/test-value-js.cpp
index 8095680c6d9..786d1bc5d3f 100644
--- a/Tests/LibJS/test-value-js.cpp
+++ b/Tests/LibJS/test-value-js.cpp
@@ -90,27 +90,27 @@ TEST_CASE(non_canon_nans)
         EXPECT(!val.is_nullish());             \
     }
 
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | 0x1);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | 0x10);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (NULL_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (UNDEFINED_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (INT32_TAG << TAG_SHIFT) | 0x88);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (OBJECT_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (OBJECT_TAG << TAG_SHIFT) | 0x1230);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (STRING_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | (STRING_TAG << TAG_SHIFT) | 0x1230);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | 0x1);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | 0x10);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (NULL_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (UNDEFINED_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (INT32_TAG << GC::TAG_SHIFT) | 0x88);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (OBJECT_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (OBJECT_TAG << GC::TAG_SHIFT) | 0x1230);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (STRING_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | (STRING_TAG << GC::TAG_SHIFT) | 0x1230);
 
     u64 sign_bit = 1ULL << 63;
 
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | 0x1);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | 0x10);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (NULL_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (UNDEFINED_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (INT32_TAG << TAG_SHIFT) | 0x88);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (OBJECT_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (OBJECT_TAG << TAG_SHIFT) | 0x1230);
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (STRING_TAG << TAG_SHIFT));
-    EXPECT_TO_BE_NAN(CANON_NAN_BITS | sign_bit | (STRING_TAG << TAG_SHIFT) | 0x1230);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | 0x1);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | 0x10);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (NULL_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (UNDEFINED_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (INT32_TAG << GC::TAG_SHIFT) | 0x88);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (OBJECT_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (OBJECT_TAG << GC::TAG_SHIFT) | 0x1230);
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (STRING_TAG << GC::TAG_SHIFT));
+    EXPECT_TO_BE_NAN(GC::CANON_NAN_BITS | sign_bit | (STRING_TAG << GC::TAG_SHIFT) | 0x1230);
 
 #undef EXPECT_TO_BE_NAN
 }
diff --git a/Tests/LibJS/test262-runner.cpp b/Tests/LibJS/test262-runner.cpp
index 93f352f19f9..1579a775fe8 100644
--- a/Tests/LibJS/test262-runner.cpp
+++ b/Tests/LibJS/test262-runner.cpp
@@ -51,7 +51,7 @@ struct TestError {
     ByteString harness_file;
 };
 
-using ScriptOrModuleProgram = Variant<JS::NonnullGCPtr<JS::Script>, JS::NonnullGCPtr<JS::SourceTextModule>>;
+using ScriptOrModuleProgram = Variant<GC::Ref<JS::Script>, GC::Ref<JS::SourceTextModule>>;
 
 template<typename ScriptType>
 static Result<ScriptOrModuleProgram, TestError> parse_program(JS::Realm& realm, StringView source, StringView filepath)
@@ -147,7 +147,7 @@ static Result<StringView, TestError> read_harness_file(StringView harness_file)
     return cache->value.view();
 }
 
-static Result<JS::NonnullGCPtr<JS::Script>, TestError> parse_harness_files(JS::Realm& realm, StringView harness_file)
+static Result<GC::Ref<JS::Script>, TestError> parse_harness_files(JS::Realm& realm, StringView harness_file)
 {
     auto source_or_error = read_harness_file(harness_file);
     if (source_or_error.is_error())
@@ -161,7 +161,7 @@ static Result<JS::NonnullGCPtr<JS::Script>, TestError> parse_harness_files(JS::R
             harness_file
         };
     }
-    return program_or_error.release_value().get<JS::NonnullGCPtr<JS::Script>>();
+    return program_or_error.release_value().get<GC::Ref<JS::Script>>();
 }
 
 enum class StrictMode {
@@ -216,8 +216,8 @@ static Result<void, TestError> run_test(StringView source, StringView filepath,
     auto vm = MUST(JS::VM::create());
     vm->set_dynamic_imports_allowed(true);
 
-    JS::GCPtr<JS::Realm> realm;
-    JS::GCPtr<JS::Test262::GlobalObject> global_object;
+    GC::Ptr<JS::Realm> realm;
+    GC::Ptr<JS::Test262::GlobalObject> global_object;
     auto root_execution_context = MUST(JS::Realm::initialize_host_defined_realm(
         *vm,
         [&](JS::Realm& realm_) -> JS::GlobalObject* {
diff --git a/Utilities/js.cpp b/Utilities/js.cpp
index 56ff46f4a95..af3c49ffac7 100644
--- a/Utilities/js.cpp
+++ b/Utilities/js.cpp
@@ -32,7 +32,7 @@
 
 RefPtr<JS::VM> g_vm;
 Vector<String> g_repl_statements;
-JS::Handle<JS::Value> g_last_value = JS::make_handle(JS::js_undefined());
+GC::Root<JS::Value> g_last_value = GC::make_root(JS::js_undefined());
 
 class ReplObject final : public JS::GlobalObject {
     JS_OBJECT(ReplObject, JS::GlobalObject);
@@ -259,7 +259,7 @@ static ErrorOr<bool> parse_and_run(JS::Realm& realm, StringView source, StringVi
     };
 
     if (!result.is_error())
-        g_last_value = JS::make_handle(result.value());
+        g_last_value = GC::make_root(result.value());
 
     if (result.is_error()) {
         VERIFY(result.throw_completion().value().has_value());
@@ -448,7 +448,7 @@ static ErrorOr<void> repl(JS::Realm& realm)
 }
 
 class ReplConsoleClient final : public JS::ConsoleClient {
-    JS_CELL(ReplConsoleClient, JS::ConsoleClient);
+    GC_CELL(ReplConsoleClient, JS::ConsoleClient);
 
 public:
     ReplConsoleClient(JS::Console& console)
@@ -494,7 +494,7 @@ public:
             return JS::js_undefined();
         }
 
-        auto output = TRY(generically_format_values(arguments.get<JS::MarkedVector<JS::Value>>()));
+        auto output = TRY(generically_format_values(arguments.get<GC::MarkedVector<JS::Value>>()));
 
         switch (log_level) {
         case JS::Console::LogLevel::Debug: