@@ -300,7 +300,7 @@ void MemoryTracker::Track(const CppgcMixin* retainer, const char* edge_name) {
   auto it = seen_.find(retainer);
   if (it != seen_.end()) {
     if (CurrentNode() != nullptr) {
-      AddEdge(CurrentNode(), it->second, edge_name);
+      AddEdge(CurrentNode(), it->second->JSWrapperNode(), edge_name);
     }
     return;  // It has already been tracked, no need to call MemoryInfo again
   }
@@ -357,6 +357,11 @@ inline void MemoryTracker::TraitTrackInline(const T& retainer,
       -(static_cast<int>(MemoryRetainerTraits<T>::SelfSize(retainer))));
 }
 
+MemoryTracker::MemoryTracker(v8::Isolate* isolate, v8::EmbedderGraph* graph)
+    : isolate_(isolate), graph_(graph) {}
+
+MemoryTracker::~MemoryTracker() = default;
+
 v8::EmbedderGraph::Node* MemoryTracker::CurrentNode() const {
   if (node_stack_.empty()) return nullptr;
   MemoryRetainerNode* n = node_stack_.top();
@@ -373,7 +378,8 @@ MemoryRetainerNode* MemoryTracker::AddNode(const CppgcMixin* retainer,
     return it->second;
   }
 
-  MemoryRetainerNode* n = new MemoryRetainerNode(this, retainer);
+  cppgc_nodes_.push_back(std::make_unique<MemoryRetainerNode>(this, retainer));
+  MemoryRetainerNode* n = cppgc_nodes_.back().get();
   seen_[retainer] = n;
   if (CurrentNode() != nullptr) {
     AddEdge(CurrentNode(), n->JSWrapperNode(), edge_name);
 
@@ -8,10 +8,12 @@
 #include <uv.h>
 
 #include <limits>
+#include <memory>
 #include <queue>
 #include <stack>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace v8 {
 class BackingStore;
@@ -294,9 +296,8 @@ class MemoryTracker {
   inline v8::EmbedderGraph* graph() { return graph_; }
   inline v8::Isolate* isolate() { return isolate_; }
 
-  inline explicit MemoryTracker(v8::Isolate* isolate,
-                                v8::EmbedderGraph* graph)
-    : isolate_(isolate), graph_(graph) {}
+  inline explicit MemoryTracker(v8::Isolate* isolate, v8::EmbedderGraph* graph);
+  inline ~MemoryTracker();
 
   // Can be passed to Track() if it is not desirable
   // to create a strong edge between nodes, i.e. when
@@ -334,6 +335,8 @@ class MemoryTracker {
   v8::EmbedderGraph* graph_;
   std::stack<MemoryRetainerNode*> node_stack_;
   NodeMap seen_;
+  // Placeholder nodes for cppgc wrappers; the graph only owns their JS nodes.
+  std::vector<std::unique_ptr<MemoryRetainerNode>> cppgc_nodes_;
 };
 
 }  // namespace node
 
@@ -1,13 +1,15 @@
 'use strict';
 require('../common');
 const { validateByRetainingPath } = require('../common/heap');
+const vm = require('vm');
 const source = 'const foo = 123';
-const script = require('vm').createScript(source);
+const script = new vm.Script(source);
+const context = vm.createContext();
 
 validateByRetainingPath('Node / ContextifyScript', [
   { node_name: '(shared function info)' },  // This is the UnboundScript referenced by ContextifyScript.
   { edge_name: 'script' },
   { edge_name: 'source', node_type: 'string', node_name: source },
 ]);
 
-console.log(script); // Keep the script alive.
+console.log(script, context); // Keep the script and context alive.