@@ -0,0 +1,196 @@
+import type { Page } from '@playwright/test';
+import process from 'node:process';
+import { expect, test } from '../fixtures/muya';
+import { getMarkdown } from '../helpers/api';
+import { loadMarkdown } from '../helpers/keyboard';
+
+// #5415: muya cut a cross-block selection only from its `keydown` handler, and
+// that handler skipped every chord carrying Cmd or Ctrl. Several of those
+// chords are editing commands, and text committed without a key press at all
+// (emoji picker, dictation) never reached the handler either. The browser then
+// deleted across the block elements itself: the second block vanished from the
+// screen but stayed in the block tree with a detached DOM node and in the
+// saved markdown, and the next structural edit near it threw "Failed to
+// execute 'insertBefore' on 'Node'".
+
+const DOC = '- one\n- two\n\ntext\n';
+
+// Playwright forwards the AppKit editing commands a real keyboard produces
+// (`deleteToBeginningOfLine:`, `deleteToEndOfLine:`, `yank:`, …) only when the
+// host is macOS, so the chords that depend on them are gated here. Ctrl+
+// Backspace needs no such command — it is Chromium's own delete-word binding
+// on every platform — and is what covers this fix on CI.
+const isMac = process.platform === 'darwin';
+
+function collectPageErrors(page: Page): string[] {
+    const errors: string[] = [];
+    page.on('pageerror', err => errors.push(String(err?.message ?? err)));
+    return errors;
+}
+
+async function nextFrames(page: Page): Promise<void> {
+    await page.evaluate(() => new Promise<void>((resolve) => {
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+    }));
+}
+
+async function detachedBlocks(page: Page): Promise<string[]> {
+    return page.evaluate(() => {
+        const detached: string[] = [];
+        window.muya!.editor.scrollPage!.depthFirstTraverse((block) => {
+            if (!block.domNode?.isConnected)
+                detached.push(block.blockName);
+        });
+        return detached;
+    });
+}
+
+async function expectTreeMatchesJson(page: Page): Promise<void> {
+    await nextFrames(page);
+    const { tree, json } = await page.evaluate(() => {
+        const muya = window.muya!;
+        const blocks: unknown[] = [];
+        muya.editor.scrollPage!.forEach((block) => {
+            if (block.isParent())
+                blocks.push(block.getState());
+        });
+        return { tree: blocks, json: muya.getState() };
+    });
+    expect(json).toEqual(tree);
+}
+
+// Viewport coordinates of the caret position `offset` characters into the
+// first text node of the `nth` match of `selector`.
+async function caretAt(page: Page, selector: string, nth: number, offset: number) {
+    return page.evaluate(({ selector, nth, offset }) => {
+        const el = document.querySelectorAll(selector)[nth] as HTMLElement;
+        const text = document.createTreeWalker(el, NodeFilter.SHOW_TEXT).nextNode()!;
+        const range = document.createRange();
+        range.setStart(text, offset);
+        range.setEnd(text, offset);
+        const rect = range.getBoundingClientRect();
+        return { x: rect.left, y: rect.top + rect.height / 2 };
+    }, { selector, nth, offset });
+}
+
+const BULLET_TEXT = '.mu-list-item .mu-paragraph-content';
+const PARAGRAPH_TEXT = '.mu-paragraph:not(.mu-list-item .mu-paragraph) .mu-paragraph-content';
+
+// Click between `tw` and `o` in the second bullet, then shift-click between
+// `te` and `xt` in the paragraph below the list.
+async function selectFromBulletIntoParagraph(page: Page): Promise<void> {
+    const start = await caretAt(page, BULLET_TEXT, 1, 2);
+    const end = await caretAt(page, PARAGRAPH_TEXT, 0, 2);
+
+    await page.mouse.click(start.x, start.y);
+    await page.keyboard.down('Shift');
+    await page.mouse.click(end.x, end.y);
+    await page.keyboard.up('Shift');
+    await nextFrames(page);
+}
+
+// Enter, Enter at the end of the bullet list — the edit that used to throw
+// once a detached paragraph was still sitting in the tree.
+async function enterTwiceAtEndOfList(page: Page): Promise<void> {
+    await page.evaluate(() => {
+        let block = window.muya!.editor.scrollPage!.firstContentInDescendant();
+        let lastInList = block;
+        while (block) {
+            if (block.closestBlock('list-item'))
+                lastInList = block;
+            block = block.nextContentInContext() ?? null;
+        }
+        const end = lastInList!.text.length;
+        lastInList!.setCursor(end, end, true);
+    });
+    await page.keyboard.press('Enter');
+    await nextFrames(page);
+    await page.keyboard.press('Enter');
+    await nextFrames(page);
+}
+
+async function expectClean(page: Page, errors: string[], markdown: string): Promise<void> {
+    expect.soft(await detachedBlocks(page)).toEqual([]);
+    await expect.soft.poll(() => getMarkdown(page)).toBe(markdown);
+
+    await enterTwiceAtEndOfList(page);
+
+    expect(errors).toEqual([]);
+    expect(await detachedBlocks(page)).toEqual([]);
+    await expectTreeMatchesJson(page);
+}
+
+// Chromium's own delete-word binding — no AppKit command behind it, so this is
+// the platform-independent form of the bug. Plain Backspace and Delete are not
+// here: carrying no modifier, they were always taken over by the keydown
+// handler.
+const DELETE_CHORDS = [
+    'Control+Backspace',
+    // macOS only: ⌘⌫ deleteToBeginningOfLine, ⌃K deleteToEndOfLine,
+    // ⌃D deleteForward, ⌃H deleteBackward.
+    ...(isMac ? ['Meta+Backspace', 'Control+k', 'Control+d', 'Control+h'] : []),
+];
+
+for (const chord of DELETE_CHORDS) {
+    test(`${chord} over a selection spanning two blocks deletes it from the document (#5415)`, async ({ page }) => {
+        const errors = collectPageErrors(page);
+        await loadMarkdown(page, DOC);
+        await nextFrames(page);
+        await selectFromBulletIntoParagraph(page);
+
+        await page.keyboard.press(chord);
+        await nextFrames(page);
+
+        await expectClean(page, errors, '- one\n- twxt\n');
+    });
+}
+
+// Ctrl+Y is the one insertion route reachable from a keyboard alone, so it
+// stands in for the rest of the family (`insertText` from the emoji picker or
+// dictation, `insertReplacementText` from autocorrect), which arrive the same
+// way but cannot be produced from a test.
+test('Ctrl+Y over a selection spanning two blocks replaces it with the yanked text (#5415)', async ({ page }) => {
+    test.skip(!isMac, 'yank: is a macOS-only editing command');
+
+    const errors = collectPageErrors(page);
+    await loadMarkdown(page, DOC);
+    await nextFrames(page);
+
+    // Fill the kill ring: Ctrl+K from the start of the paragraph takes `text`.
+    const paragraphStart = await caretAt(page, PARAGRAPH_TEXT, 0, 0);
+    await page.mouse.click(paragraphStart.x, paragraphStart.y);
+    await page.keyboard.press('Control+k');
+    await nextFrames(page);
+
+    await loadMarkdown(page, DOC);
+    await nextFrames(page);
+    await selectFromBulletIntoParagraph(page);
+
+    await page.keyboard.press('Control+y');
+    await nextFrames(page);
+
+    await expectClean(page, errors, '- one\n- twtextxt\n');
+});
+
+test('Ctrl+C over a selection spanning two blocks still does not delete it (#3491)', async ({ page }) => {
+    await loadMarkdown(page, DOC);
+    await nextFrames(page);
+    await selectFromBulletIntoParagraph(page);
+
+    await page.keyboard.press('Control+c');
+    await nextFrames(page);
+
+    await expect.poll(() => getMarkdown(page)).toBe(DOC);
+});
+
+test('typing a printable character over a selection spanning two blocks replaces it', async ({ page }) => {
+    await loadMarkdown(page, DOC);
+    await nextFrames(page);
+    await selectFromBulletIntoParagraph(page);
+
+    await page.keyboard.press('z');
+    await nextFrames(page);
+
+    expect(await detachedBlocks(page)).toEqual([]);
+    await expect.poll(() => getMarkdown(page)).toBe('- one\n- twzxt\n');
+});