fix(core): release extension parent/child graph on Editor.destroy() to prevent memory leak (ueberdosis#7795)

* fix(core): release extension parent/child graph on Editor.destroy() to prevent memory leak (ueberdosis#7769)

* fix(core): make Editor.destroy() idempotent with a destroyed flag

* fix(core): avoid nulling ancestor.child in ExtensionManager.destroy() to prevent cross-editor side effects

* fix(core): address PR review feedback — preserve extension.parent/child on shared instances, clear extensionStorage, fix walk-up loop

* fix(core): walk full parent chain in ExtensionManager.destroy() and add multi-level test

* docs(core): clarify ExtensionManager.destroy() JSDoc on what is mutated

Author: bdbch

.changeset/ninety-icons-hide.md

@@ -0,0 +1,5 @@
+---
+'@tiptap/core': patch
+---
+
+Fixed a memory leak where `Editor.destroy()` did not release the Extension parent/child graph. Module-scope extension singletons retained references to configured extensions, preventing garbage collection of extension options (including DOM closures). The fix also cleans up `ExtensionManager`, `schema`, and `commandManager` references on destroy.

packages/core/__tests__/extendExtensions.spec.ts

@@ -1,4 +1,7 @@
-import { Extension, getExtensionField, Mark, Node } from '@tiptap/core'
+import { Editor, Extension, getExtensionField, Mark, Node } from '@tiptap/core'
+import Document from '@tiptap/extension-document'
+import Paragraph from '@tiptap/extension-paragraph'
+import Text from '@tiptap/extension-text'
 import { describe, expect, it } from 'vitest'
 
 declare module '@tiptap/core' {
@@ -416,3 +419,116 @@ describe('extend extensions', () => {
     })
   })
 })
+
+describe('parent/child cleanup on destroy', () => {
+  it('should not leak child reference when configure() is called on a singleton', () => {
+    const singleton = Extension.create({
+      name: 'testExtension',
+      addOptions() {
+        return { foo: 'bar' }
+      },
+    })
+
+    const configuredExtension = singleton.configure({ foo: 'baz' })
+
+    expect(singleton.child).toBeNull()
+    expect(configuredExtension.parent).toBeNull()
+  })
+
+  it('should break parent/child chain when editor is destroyed (extend path)', () => {
+    const singleton = Extension.create({
+      name: 'testExtension',
+      addOptions() {
+        return { foo: 'bar' }
+      },
+    })
+
+    const childExtension = singleton.extend({
+      addOptions() {
+        return { ...this.parent?.(), foo: 'baz' }
+      },
+    })
+
+    expect(singleton.child).toBe(childExtension)
+    expect(childExtension.parent).toBe(singleton)
+
+    const editor = new Editor({
+      element: null,
+      extensions: [Document, Paragraph, Text, childExtension],
+    })
+
+    editor.destroy()
+
+    expect(singleton.child).toBeNull()
+  })
+
+  it('should clear forward parent.child links on all extensions after editor.destroy()', () => {
+    const singletonA = Extension.create({
+      name: 'extA',
+      addOptions() {
+        return { value: 'a' }
+      },
+    })
+    const singletonB = Extension.create({
+      name: 'extB',
+      addOptions() {
+        return { value: 'b' }
+      },
+    })
+
+    const configuredA = singletonA.configure({ value: 'a-configured' })
+    const childB = singletonB.extend({ name: 'extB-child' })
+
+    const editor = new Editor({
+      element: null,
+      extensions: [Document, Paragraph, Text, configuredA, childB],
+    })
+
+    const { extensions } = editor.extensionManager
+
+    editor.destroy()
+
+    extensions.forEach(ext => {
+      if (ext.parent?.child === ext) {
+        // This should never be true after destroy — the forward link is always broken
+        expect(ext.parent.child).toBeNull()
+      }
+    })
+  })
+
+  it('should break all ancestor child links in a multi-level extend chain after editor.destroy()', () => {
+    const root = Extension.create({
+      name: 'root',
+      addOptions() {
+        return { level: 0 }
+      },
+    })
+
+    const child = root.extend({
+      addOptions() {
+        return { ...this.parent?.(), level: 1 }
+      },
+    })
+
+    const grandchild = child.extend({
+      addOptions() {
+        return { ...this.parent?.(), level: 2 }
+      },
+    })
+
+    expect(root.child).toBe(child)
+    expect(child.child).toBe(grandchild)
+    expect(grandchild.parent).toBe(child)
+    expect(child.parent).toBe(root)
+
+    const editor = new Editor({
+      element: null,
+      extensions: [Document, Paragraph, Text, grandchild],
+    })
+
+    editor.destroy()
+
+    expect(root.child).toBeNull()
+    expect(child.child).toBeNull()
+  })
+})

packages/core/src/Editor.ts

@@ -68,6 +68,8 @@ export class Editor extends EventEmitter<EditorEvents> {
 
   public isFocused = false
 
+  private destroyed = false
+
   private editorState!: EditorState
 
   /**
@@ -764,11 +766,23 @@ export class Editor extends EventEmitter<EditorEvents> {
    * Destroy the editor.
    */
   public destroy(): void {
+    if (this.destroyed) {
+      return
+    }
+
+    this.destroyed = true
+
     this.emit('destroy')
 
     this.unmount()
 
     this.removeAllListeners()
+
+    this.extensionManager.destroy()
+    this.extensionManager = null as any
+    this.schema = null as any
+    this.commandManager = null as any
+    this.extensionStorage = {} as Storage
   }
 
   /**

packages/core/src/Extendable.ts

@@ -580,6 +580,8 @@ export class Extendable<
     extension.name = this.name
     extension.parent = this.parent
 
+    this.child = null
+
     return extension
   }
 

packages/core/src/ExtensionManager.ts

@@ -363,6 +363,41 @@ export class ExtensionManager {
     )
   }
 
+  /**
+   * Destroy the extension manager and clean up all extension references
+   * to prevent memory leaks through parent/child extension chains.
+   *
+   * Walks each extension's full parent chain and nulls every forward
+   * `parent.child → current` link where the parent still points to the
+   * current node. This breaks the retention path from module-scope
+   * singleton roots through deep extend() chains.
+   *
+   * Only ancestor `.child` links matching the current chain are cleared.
+   * The `.parent` pointer on ancestors is never touched — extensions
+   * may be shared across live editors, so their own backward references
+   * and non-matching forward links must remain intact.
+   */
+  destroy() {
+    this.extensions.forEach(extension => {
+      let current: any = extension
+
+      while (current.parent) {
+        const parent = current.parent
+
+        if (parent.child === current) {
+          parent.child = null
+        }
+
+        current = parent
+      }
+    })
+
+    this.extensions = []
+    this.baseExtensions = []
+    this.schema = null as any
+    this.editor = null as any
+  }
+
   /**
    * Go through all extensions, create extension storages & setup marks
    * & bind editor event listener.