diff --git a/.changeset/2026-08-23-inline-math-lookbehind.md b/.changeset/2026-08-23-inline-math-lookbehind.md
new file mode 100644
index 0000000000..228dae200d
--- /dev/null
+++ b/.changeset/2026-08-23-inline-math-lookbehind.md
@@ -0,0 +1,5 @@
+---
+'@tiptap/extension-mathematics': patch
+---
+
+The mathematics extension no longer crashes the editor in older WebKit browsers and WKWebView.
diff --git a/.changeset/2026-08-26-cross-editor-drop-destroyed-source.md b/.changeset/2026-08-26-cross-editor-drop-destroyed-source.md
new file mode 100644
index 0000000000..3fb5bacbc9
--- /dev/null
+++ b/.changeset/2026-08-26-cross-editor-drop-destroyed-source.md
@@ -0,0 +1,5 @@
+---
+'@tiptap/core': patch
+---
+
+Fix a `TypeError` thrown when the source editor is destroyed right after dragging content into another editor.
diff --git a/.changeset/2026-09-25-static-renderer-audio-closing-tag.md b/.changeset/2026-09-25-static-renderer-audio-closing-tag.md
new file mode 100644
index 0000000000..43463e6fd8
--- /dev/null
+++ b/.changeset/2026-09-25-static-renderer-audio-closing-tag.md
@@ -0,0 +1,5 @@
+---
+'@tiptap/static-renderer': patch
+---
+
+Render `<audio>` and `<video>` with a closing tag instead of self-closing them, so browsers no longer nest the following content inside the first audio element.
diff --git a/.changeset/2026-09-25-static-renderer-stray-commas.md b/.changeset/2026-09-25-static-renderer-stray-commas.md
new file mode 100644
index 0000000000..988335e77f
--- /dev/null
+++ b/.changeset/2026-09-25-static-renderer-stray-commas.md
@@ -0,0 +1,5 @@
+---
+'@tiptap/static-renderer': patch
+---
+
+Rendering a node whose `renderHTML` returns several nested child elements no longer adds stray commas between them in the HTML string output.
diff --git a/.changeset/fix-split-list-item-checked-state.md b/.changeset/fix-split-list-item-checked-state.md
new file mode 100644
index 0000000000..fe86b5a395
--- /dev/null
+++ b/.changeset/fix-split-list-item-checked-state.md
@@ -0,0 +1,5 @@
+---
+'@tiptap/core': patch
+---
+
+Pressing Enter before the text of a checked task item now leaves the new empty item unchecked and the item with the text checked. Attributes declared with `keepOnSplit: false` now reset on the new item, not on the one that keeps the text.
diff --git a/demos/src/Extensions/Mathematics/React/index.jsx b/demos/src/Extensions/Mathematics/React/index.jsx
index 462f4da106..8a6cf7f2a2 100644
--- a/demos/src/Extensions/Mathematics/React/index.jsx
+++ b/demos/src/Extensions/Mathematics/React/index.jsx
@@ -25,12 +25,12 @@ export default () => {
           },
         },
         inlineOptions: {
-          onClick: node => {
+          onClick: (node, pos) => {
             const newCalculation = prompt('Enter new calculation:', node.attrs.latex)
             if (newCalculation) {
               editor
                 .chain()
-                .setNodeSelection(node.pos)
+                .setNodeSelection(pos)
                 .updateInlineMath({ latex: newCalculation })
                 .focus()
                 .run()
diff --git a/packages/core/__tests__/crossEditorDrop.spec.ts b/packages/core/__tests__/crossEditorDrop.spec.ts
new file mode 100644
index 0000000000..cb674a1acf
--- /dev/null
+++ b/packages/core/__tests__/crossEditorDrop.spec.ts
@@ -0,0 +1,121 @@
+import { Editor, Mark, markPasteRule } from '@tiptap/core'
+import Document from '@tiptap/extension-document'
+import Paragraph from '@tiptap/extension-paragraph'
+import Text from '@tiptap/extension-text'
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+const editorElClass = 'tiptap-cross-editor-drop-test'
+
+const createEditorEl = () => {
+  const editorEl = document.createElement('div')
+
+  editorEl.classList.add(editorElClass)
+  document.body.appendChild(editorEl)
+
+  return editorEl
+}
+
+const PasteMark = Mark.create({
+  name: 'pasteMark',
+  addPasteRules() {
+    return [
+      markPasteRule({
+        find: /==(.*?)==/g,
+        type: this.type,
+      }),
+    ]
+  },
+})
+
+const createEditor = () =>
+  new Editor({
+    element: createEditorEl(),
+    extensions: [Document, Paragraph, Text, PasteMark],
+    content: '<p>content</p>',
+  })
+
+const dragBetween = (source: Editor, target: Editor) => {
+  source.view.dom.dispatchEvent(new Event('dragstart', { bubbles: true }))
+  target.view.dom.dispatchEvent(new Event('drop', { bubbles: true }))
+}
+
+describe('cross editor drop', () => {
+  let source: Editor
+  let target: Editor
+
+  afterEach(() => {
+    vi.useRealTimers()
+    source?.destroy()
+    target?.destroy()
+    document.querySelectorAll(`.${editorElClass}`).forEach(element => element.remove())
+  })
+
+  it('does not throw when the source editor is destroyed before the deferred delete runs', () => {
+    vi.useFakeTimers()
+    source = createEditor()
+    target = createEditor()
+
+    dragBetween(source, target)
+    source.destroy()
+
+    expect(() => vi.advanceTimersByTime(10)).not.toThrow()
+  })
+
+  it('deletes the dragged selection from a source editor that is still alive', () => {
+    vi.useFakeTimers()
+    source = createEditor()
+    target = createEditor()
+
+    source.commands.setTextSelection({ from: 1, to: 8 })
+    dragBetween(source, target)
+    vi.advanceTimersByTime(10)
+
+    expect(source.getHTML()).toBe('<p></p>')
+  })
+
+  it('does not queue a delete when the source editor was destroyed before the drop', () => {
+    vi.useFakeTimers()
+    source = createEditor()
+    target = createEditor()
+
+    source.view.dom.dispatchEvent(new Event('dragstart', { bubbles: true }))
+    source.destroy()
+
+    const queuedBeforeDrop = vi.getTimerCount()
+
+    target.view.dom.dispatchEvent(new Event('drop', { bubbles: true }))
+
+    expect(vi.getTimerCount()).toBe(queuedBeforeDrop)
+  })
+
+  it('keeps the queued delete when the source editor registers a plugin during the drag', () => {
+    vi.useFakeTimers()
+    source = createEditor()
+    target = createEditor()
+
+    source.commands.setTextSelection({ from: 1, to: 8 })
+    source.view.dom.dispatchEvent(new Event('dragstart', { bubbles: true }))
+    source.registerPlugin(new Plugin({ key: new PluginKey('noop') }))
+    target.view.dom.dispatchEvent(new Event('drop', { bubbles: true }))
+    vi.advanceTimersByTime(10)
+
+    expect(source.getHTML()).toBe('<p></p>')
+  })
+
+  it('does not queue a delete when the source editor is unmounted then destroyed', () => {
+    vi.useFakeTimers()
+    source = createEditor()
+    target = createEditor()
+
+    source.view.dom.dispatchEvent(new Event('dragstart', { bubbles: true }))
+    source.unmount()
+    source.destroy()
+
+    const queuedBeforeDrop = vi.getTimerCount()
+
+    target.view.dom.dispatchEvent(new Event('drop', { bubbles: true }))
+
+    expect(vi.getTimerCount()).toBe(queuedBeforeDrop)
+  })
+})
diff --git a/packages/core/src/PasteRule.ts b/packages/core/src/PasteRule.ts
index b993c3ebfe..ac240bc5dc 100644
--- a/packages/core/src/PasteRule.ts
+++ b/packages/core/src/PasteRule.ts
@@ -254,6 +254,12 @@ export function pasteRulesPlugin(props: { editor: Editor; rules: PasteRule[] }):
     return tr
   }
 
+  editor.on('destroy', () => {
+    if (tiptapDragFromOtherEditor === editor) {
+      tiptapDragFromOtherEditor = null
+    }
+  })
+
   const plugins = rules.map(rule => {
     return new Plugin({
       // we register a global drag handler to track the current drag source element
@@ -297,6 +303,10 @@ export function pasteRulesPlugin(props: { editor: Editor; rules: PasteRule[] }):
               if (dragFromOtherEditor?.isEditable) {
                 // setTimeout to avoid the wrong content after drop, timeout arg can't be empty or 0
                 setTimeout(() => {
+                  if (dragFromOtherEditor.isDestroyed) {
+                    return
+                  }
+
                   const selection = dragFromOtherEditor.state.selection
 
                   if (selection) {
diff --git a/packages/core/src/commands/splitListItem.ts b/packages/core/src/commands/splitListItem.ts
index 00eda39c6a..bafd43600e 100644
--- a/packages/core/src/commands/splitListItem.ts
+++ b/packages/core/src/commands/splitListItem.ts
@@ -124,14 +124,26 @@ export const splitListItem: RawCommands['splitListItem'] =
       ...overrideAttrs,
     }
 
+    // `Transform.split` only ever applies `types` to the node created *after* the split, so
+    // attributes that should not survive a split (`keepOnSplit: false`) normally land on the
+    // trailing item, which is the newly created one. When the cursor sits at the very start
+    // of the item, that is inverted: the empty new item is the *leading* one and the trailing
+    // item is the original content. Detect that case and swap the two sets of attributes.
+    const splitsAtStartOfItem = $from.parentOffset === 0 && $from.index(-1) === 0
+    const itemStart = $from.before(-1)
+
     tr.delete($from.pos, $to.pos)
 
+    // The trailing item keeps the attributes of the item being split when it is the half that
+    // carries the content over; the reset is applied to the leading item after the split.
+    const trailingTypeAttributes = splitsAtStartOfItem ? grandParent.attrs : newTypeAttributes
+
     const types = nextType
       ? [
-          { type, attrs: newTypeAttributes },
+          { type, attrs: trailingTypeAttributes },
           { type: nextType, attrs: newNextTypeAttributes },
         ]
-      : [{ type, attrs: newTypeAttributes }]
+      : [{ type, attrs: trailingTypeAttributes }]
 
     if (!canSplit(tr.doc, $from.pos, 2)) {
       return false
@@ -144,6 +156,10 @@ export const splitListItem: RawCommands['splitListItem'] =
 
       tr.split($from.pos, 2, types).scrollIntoView()
 
+      if (splitsAtStartOfItem) {
+        tr.setNodeMarkup(itemStart, undefined, newTypeAttributes)
+      }
+
       if (!marks || !dispatch) {
         return true
       }
diff --git a/packages/extension-list/src/task-item/task-item.test.ts b/packages/extension-list/src/task-item/task-item.test.ts
index 4dc951f5a3..d34053b2a0 100644
--- a/packages/extension-list/src/task-item/task-item.test.ts
+++ b/packages/extension-list/src/task-item/task-item.test.ts
@@ -901,4 +901,97 @@ describe('TaskItem', () => {
     expect(from).toBe(1)
     expect(to).toBe(14)
   })
+
+  describe('splitListItem', () => {
+    function createTaskEditor(checked: boolean, text: string) {
+      return new Editor({
+        extensions: [Document, Paragraph, Text, TaskList, TaskItem],
+        content: {
+          type: 'doc',
+          content: [
+            {
+              type: 'taskList',
+              content: [
+                {
+                  type: 'taskItem',
+                  attrs: { checked },
+                  content: [{ type: 'paragraph', content: [{ type: 'text', text }] }],
+                },
+              ],
+            },
+          ],
+        },
+      })
+    }
+
+    /** `[checked, text]` for every task item in the first (and only) task list. */
+    function readTaskItems(instance: Editor) {
+      return (instance.getJSON().content?.[0].content ?? []).map(item => [
+        item.attrs?.checked,
+        item.content?.[0].content?.[0]?.text ?? '',
+      ])
+    }
+
+    it('leaves the checked state on the half that keeps the text when splitting at the start', () => {
+      editor = createTaskEditor(true, 'Task')
+      // Offset 0 of the paragraph inside the first task item.
+      editor.commands.setTextSelection(3)
+
+      expect(editor.commands.splitListItem('taskItem')).toBe(true)
+      expect(readTaskItems(editor)).toEqual([
+        [false, ''],
+        [true, 'Task'],
+      ])
+    })
+
+    it('resets the checked state on the trailing half when splitting mid-text', () => {
+      editor = createTaskEditor(true, 'Task')
+      editor.commands.setTextSelection(5)
+
+      expect(editor.commands.splitListItem('taskItem')).toBe(true)
+      expect(readTaskItems(editor)).toEqual([
+        [true, 'Ta'],
+        [false, 'sk'],
+      ])
+    })
+
+    it('resets the checked state on the trailing half when splitting at the end', () => {
+      editor = createTaskEditor(true, 'Task')
+      editor.commands.setTextSelection(7)
+
+      expect(editor.commands.splitListItem('taskItem')).toBe(true)
+      expect(readTaskItems(editor)).toEqual([
+        [true, 'Task'],
+        [false, ''],
+      ])
+    })
+
+    it('splits a plain list item at the start without moving its content', () => {
+      editor = new Editor({
+        extensions: [Document, Paragraph, Text, BulletList, ListItem],
+        content: {
+          type: 'doc',
+          content: [
+            {
+              type: 'bulletList',
+              content: [
+                {
+                  type: 'listItem',
+                  content: [{ type: 'paragraph', content: [{ type: 'text', text: 'Item' }] }],
+                },
+              ],
+            },
+          ],
+        },
+      })
+      editor.commands.setTextSelection(3)
+
+      expect(editor.commands.splitListItem('listItem')).toBe(true)
+      expect(
+        (editor.getJSON().content?.[0].content ?? []).map(
+          item => item.content?.[0].content?.[0]?.text ?? '',
+        ),
+      ).toEqual(['', 'Item'])
+    })
+  })
 })
diff --git a/packages/extension-mathematics/src/extensions/InlineMath.test.ts b/packages/extension-mathematics/src/extensions/InlineMath.test.ts
index 93d4920cc3..c8dd54a197 100644
--- a/packages/extension-mathematics/src/extensions/InlineMath.test.ts
+++ b/packages/extension-mathematics/src/extensions/InlineMath.test.ts
@@ -77,4 +77,70 @@ describe('InlineMath', () => {
     // Expect no input rule to match
     expect(handled).toBeFalsy()
   })
+
+  // Types a trailing `$` and returns whether an input rule handled it.
+  const typeTrailingDollar = (initialText: string) => {
+    editor = new Editor({
+      extensions: [Document, Paragraph, Text, InlineMath],
+      content: {
+        type: 'doc',
+        content: [
+          {
+            type: 'paragraph',
+            content: [{ type: 'text', text: initialText }],
+          },
+        ],
+      },
+    })
+
+    editor.commands.setTextSelection(editor.state.doc.nodeSize)
+
+    return editor.view.someProp('handleTextInput', f =>
+      f(editor.view, editor.state.selection.from, editor.state.selection.from, '$'),
+    )
+  }
+
+  it('replaces only the math when the preceding character is not a space', () => {
+    typeTrailingDollar('x$$a$')
+
+    expect(editor.getJSON().content).toEqual([
+      {
+        type: 'paragraph',
+        content: [
+          { type: 'text', text: 'x' },
+          { type: 'inlineMath', attrs: { latex: 'a' } },
+        ],
+      },
+    ])
+  })
+
+  it('matches math at the very start of a paragraph', () => {
+    typeTrailingDollar('$$a$')
+
+    expect(editor.getJSON().content).toEqual([
+      {
+        type: 'paragraph',
+        content: [{ type: 'inlineMath', attrs: { latex: 'a' } }],
+      },
+    ])
+  })
+
+  it('skips a rejected match and still matches the one that follows it', () => {
+    // The first `$$a$$` is rejected, but a valid match starts at its trailing `$$`.
+    typeTrailingDollar('$$$a$$b$')
+
+    expect(editor.getJSON().content).toEqual([
+      {
+        type: 'paragraph',
+        content: [
+          { type: 'text', text: '$$$a' },
+          { type: 'inlineMath', attrs: { latex: 'b' } },
+        ],
+      },
+    ])
+  })
+
+  it('does not match when the closing delimiter is followed by a third $', () => {
+    expect(typeTrailingDollar('$$a$$')).toBeFalsy()
+  })
 })
diff --git a/packages/extension-mathematics/src/extensions/InlineMath.ts b/packages/extension-mathematics/src/extensions/InlineMath.ts
index 5e23171a44..6ffe113f06 100644
--- a/packages/extension-mathematics/src/extensions/InlineMath.ts
+++ b/packages/extension-mathematics/src/extensions/InlineMath.ts
@@ -1,3 +1,4 @@
+import type { InputRuleMatch } from '@tiptap/core'
 import { InputRule, mergeAttributes, Node } from '@tiptap/core'
 import type { Node as PMNode } from '@tiptap/pm/model'
 import katex, { type KatexOptions } from 'katex'
@@ -65,6 +66,28 @@ declare module '@tiptap/core' {
   }
 }
 
+/**
+ * A negative lookbehind would crash old WebKit, and a consuming group like `(^|[^$])`
+ * would get replaced along with the math, so reject the preceding `$` in code instead.
+ */
+const findInlineMath = (text: string): InputRuleMatch | null => {
+  const pattern = /\$\$([^$\n]+?)\$\$(?!\$)/g
+
+  let match = pattern.exec(text)
+
+  while (match !== null) {
+    if (match.index === 0 || text[match.index - 1] !== '$') {
+      return { index: match.index, text: match[0], data: { latex: match[1] } }
+    }
+
+    // A valid match can start inside a rejected one, at its trailing `$$`.
+    pattern.lastIndex = match.index + 1
+    match = pattern.exec(text)
+  }
+
+  return null
+}
+
 /**
  * InlineMath is a Tiptap extension for rendering inline mathematical expressions using KaTeX.
  * It allows users to insert LaTeX formatted math expressions inline within text.
@@ -220,9 +243,14 @@ export const InlineMath = Node.create<InlineMathOptions>({
   addInputRules() {
     return [
       new InputRule({
-        find: /(?<!\$)(\$\$([^$\n]+?)\$\$)(?!\$)/,
+        find: findInlineMath,
         handler: ({ state, range, match }) => {
-          const latex = match[2]
+          const latex = match.data?.latex
+
+          if (typeof latex !== 'string') {
+            return null
+          }
+
           const { tr } = state
           const start = range.from
           const end = range.to
diff --git a/packages/extension-mathematics/src/extensions/lookbehind.test.ts b/packages/extension-mathematics/src/extensions/lookbehind.test.ts
new file mode 100644
index 0000000000..0132215759
--- /dev/null
+++ b/packages/extension-mathematics/src/extensions/lookbehind.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+// Old WebKit rejects a lookbehind in a regex literal at parse time and takes the whole
+// chunk down with it. Coarse on purpose: the sequence must not appear in comments either.
+const sources = import.meta.glob('../**/*.ts', {
+  query: '?raw',
+  import: 'default',
+  eager: true,
+}) as Record<string, string>
+
+describe('WebKit compatibility', () => {
+  it('uses no regex lookbehind anywhere in the package source', () => {
+    const offenders = Object.entries(sources)
+      .filter(([path]) => !/\.(test|spec)\.ts$/.test(path))
+      .filter(([, source]) => /\(\?<[=!]/.test(source))
+      .map(([path]) => path)
+
+    expect(offenders).toEqual([])
+  })
+})
diff --git a/packages/static-renderer/src/pm/html-string/html-string.test.ts b/packages/static-renderer/src/pm/html-string/html-string.test.ts
index 221540d44a..dcabff8c60 100644
--- a/packages/static-renderer/src/pm/html-string/html-string.test.ts
+++ b/packages/static-renderer/src/pm/html-string/html-string.test.ts
@@ -1,4 +1,5 @@
 import { extensions as coreExtensions } from '@tiptap/core'
+import Audio from '@tiptap/extension-audio'
 import Bold from '@tiptap/extension-bold'
 import CodeBlock from '@tiptap/extension-code-block'
 import Document from '@tiptap/extension-document'
@@ -9,6 +10,7 @@ import { generateTocIds, TableOfContents } from '@tiptap/extension-table-of-cont
 import Text from '@tiptap/extension-text'
 import { generateUniqueIds, UniqueID } from '@tiptap/extension-unique-id'
 import Youtube from '@tiptap/extension-youtube'
+import type { DOMOutputSpec } from '@tiptap/pm/model'
 import { Mark, Node as PMNode } from '@tiptap/pm/model'
 import { describe, expect, it } from 'vite-plus/test'
 
@@ -236,6 +238,38 @@ describe('static render json to string (with prosemirror)', () => {
     expect(html).to.include('<p>text after youtube</p>')
   })
 
+  it('renders audio nodes with a closing tag so the next audio is not nested inside', () => {
+    const json = {
+      type: 'doc',
+      content: [
+        { type: 'audio', attrs: { src: 'https://example.com/first.mp3' } },
+        { type: 'audio', attrs: { src: 'https://example.com/second.mp3' } },
+      ],
+    }
+
+    const html = renderToHTMLString({
+      content: json,
+      extensions: [Document, Paragraph, Text, Audio],
+    })
+
+    expect(html).toBe(
+      '<audio controls="true" preload="metadata" src="https://example.com/first.mp3"></audio>' +
+        '<audio controls="true" preload="metadata" src="https://example.com/second.mp3"></audio>',
+    )
+  })
+
+  it('renders an audio spec without attributes with a closing tag', () => {
+    expect(domOutputSpecToHTMLString(['audio'])()).toBe('<audio></audio>')
+  })
+
+  it('renders multiple child specs without commas when the first child is an array', () => {
+    const spec: DOMOutputSpec = ['div', ['span', 0], ['em', 0], ['strong', 0]]
+
+    expect(domOutputSpecToHTMLString(spec)('x')).toBe(
+      '<div><span>x</span><em>x</em><strong>x</strong></div>',
+    )
+  })
+
   const headingDoc = {
     type: 'doc',
     content: [
diff --git a/packages/static-renderer/src/pm/html-string/html-string.ts b/packages/static-renderer/src/pm/html-string/html-string.ts
index 28f399d50e..6dba993bcb 100644
--- a/packages/static-renderer/src/pm/html-string/html-string.ts
+++ b/packages/static-renderer/src/pm/html-string/html-string.ts
@@ -31,6 +31,8 @@ const NON_SELF_CLOSING_TAGS = new Set([
   'span',
   'a',
   'button',
+  'audio',
+  'video',
 ])
 
 /**
@@ -54,6 +56,9 @@ export function domOutputSpecToHTMLString(
     }
 
     if (attrs === undefined) {
+      if (NON_SELF_CLOSING_TAGS.has(tag)) {
+        return () => `<${tag}></${tag}>`
+      }
       return () => `<${tag}/>`
     }
     if (attrs === 0) {
@@ -72,7 +77,8 @@ export function domOutputSpecToHTMLString(
         return child =>
           `<${tag}>${domOutputSpecToHTMLString(attrs as DOMOutputSpecArray)(child)}${[children]
             .concat(rest)
-            .map(a => domOutputSpecToHTMLString(a)(child))}</${tag}>`
+            .map(a => domOutputSpecToHTMLString(a)(child))
+            .join('')}</${tag}>`
       }
       if (children === undefined) {
         if (NON_SELF_CLOSING_TAGS.has(tag)) {