@@ -0,0 +1,54 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '../fixtures/muya';
+import { getMarkdown } from '../helpers/api';
+import { loadMarkdown } from '../helpers/keyboard';
+import { editor } from '../helpers/selectors';
+
+// #5371: Backspace over a selection that ends in a code block's language line
+// duplicated the language into the start paragraph and removed the language
+// input, so the language could no longer be edited.
+
+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()));
+    }));
+}
+
+test('a cut ending in a language line keeps the code block and its language input (#5371)', async ({ page }) => {
+    const errors = collectPageErrors(page);
+    await loadMarkdown(page, 'intro\n\n- item\n\n  ```js\n  const a = 1\n  ```\n\n  tail\n');
+    await expect(page.locator(`${editor.codeContent} .token`).first()).toBeAttached();
+    await nextFrames(page);
+
+    await page.evaluate(() => {
+        const { scrollPage, selection } = window.muya!.editor;
+        const intro = scrollPage!.firstContentInDescendant()!;
+        let languageInput = intro.nextContentInContext();
+        while (languageInput && languageInput.blockName !== 'language-input')
+            languageInput = languageInput.nextContentInContext() ?? null;
+        selection.setSelection(
+            { offset: 2, block: intro, path: intro.path },
+            { offset: 0, block: languageInput!, path: languageInput!.path },
+        );
+    });
+    await page.keyboard.press('Backspace');
+    await expect.poll(() => getMarkdown(page)).toBe('in\n\n- ```js\n  const a = 1\n  ```\n\n  tail\n');
+    await expect(page.locator(`${editor.codeBlock} ${editor.languageInput}`)).toHaveCount(1);
+
+    // The language input is still there and editable.
+    await page.evaluate(() => {
+        let languageInput = window.muya!.editor.scrollPage!.firstContentInDescendant();
+        while (languageInput && languageInput.blockName !== 'language-input')
+            languageInput = languageInput.nextContentInContext() ?? null;
+        languageInput!.setCursor(2, 2, true);
+    });
+    await page.keyboard.type('x');
+    await expect.poll(() => getMarkdown(page)).toBe('in\n\n- ```jsx\n  const a = 1\n  ```\n\n  tail\n');
+    expect(errors).toEqual([]);
+});
@@ -0,0 +1,143 @@
+// @vitest-environment happy-dom
+
+import type Content from '../../block/base/content';
+import type Parent from '../../block/base/parent';
+import type { Muya } from '../../muya';
+import type { TState } from '../../state/types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Muya as MuyaClass } from '../../muya';
+import { SelectionCaretType, SelectionDirection } from '../../selection/types';
+
+// #5371: a cross-block cut that ends inside a code block's language line
+// keeps that code block and its language input; only the selected start of
+// the language goes. The rest of the language used to be merged into the
+// start block (duplicating it) and the language input node was dropped.
+
+vi.mock('../../utils/prism/index', () => ({
+    default: {},
+    walkTokens: () => null,
+    loadedLanguages: new Set(),
+    transformAliasToOrigin: (s: string) => s,
+    loadLanguage: () => Promise.resolve([]),
+    search: () => [],
+}));
+
+const bootedHosts: HTMLElement[] = [];
+let hadVersion = false;
+let originalVersion: string | undefined;
+
+beforeEach(() => {
+    hadVersion = 'MUYA_VERSION' in window;
+    originalVersion = window.MUYA_VERSION;
+    window.MUYA_VERSION = 'test';
+});
+
+afterEach(() => {
+    while (bootedHosts.length)
+        bootedHosts.pop()!.remove();
+    if (hadVersion)
+        window.MUYA_VERSION = originalVersion as string;
+    else
+        delete (window as Partial<Window>).MUYA_VERSION;
+});
+
+function bootMuya(markdown: string): Muya {
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const muya = new MuyaClass(host, { markdown } as ConstructorParameters<typeof MuyaClass>[1]);
+    muya.init();
+    bootedHosts.push(muya.domNode);
+    return muya;
+}
+
+function contentBlocks(muya: Muya): Content[] {
+    const blocks: Content[] = [];
+    let block: Content | null = muya.editor.scrollPage!.firstContentInDescendant();
+    while (block) {
+        blocks.push(block);
+        block = block.nextContentInContext() ?? null;
+    }
+    return blocks;
+}
+
+function findContent(muya: Muya, blockName: string, text: string, nth = 0): Content {
+    const block = contentBlocks(muya).filter(b => b.blockName === blockName && b.text.includes(text))[nth];
+    if (!block)
+        throw new Error(`no ${blockName} containing ${JSON.stringify(text)}`);
+    return block;
+}
+
+function cut(muya: Muya, anchor: Content, anchorOffset: number, focus: Content, focusOffset: number): void {
+    const anchorPath = anchor.path;
+    const focusPath = focus.path;
+    muya.editor.selection.getSelection = () => ({
+        anchor: { offset: anchorOffset, block: anchor, path: anchorPath },
+        focus: { offset: focusOffset, block: focus, path: focusPath },
+        isCollapsed: false,
+        isSelectionInSameBlock: false,
+        direction: SelectionDirection.FORWARD,
+        type: SelectionCaretType.RANGE,
+    });
+    muya.editor.clipboard.cutHandler();
+}
+
+function settledState(muya: Muya): TState[] {
+    muya.editor.jsonState.flush();
+    const state = muya.editor.jsonState.getState();
+    const tree: TState[] = [];
+    muya.editor.scrollPage!.forEach(block => tree.push((block as Parent).getState()));
+    expect(state).toEqual(tree);
+    return state;
+}
+
+// Every code block still starts with its language input, holding its language.
+function expectLanguageInputs(muya: Muya, languages: string[]): void {
+    const inputs = contentBlocks(muya).filter(b => b.blockName === 'language-input');
+    expect(inputs.map(input => input.text)).toEqual(languages);
+    const codeBlocks = contentBlocks(muya).filter(b => b.blockName === 'codeblock.content').map(code => code.parent!.parent!);
+    expect(codeBlocks.map(codeBlock => (codeBlock as Parent).firstContentInDescendant()?.blockName)).toEqual(languages.map(() => 'language-input'));
+}
+
+const paragraph = (text: string) => ({ name: 'paragraph', text });
+const codeBlock = (lang: string, text: string) => ({ name: 'code-block', meta: { type: 'fenced', lang }, text });
+
+describe('cross-block cut ending in a code block\'s language line (#5371)', () => {
+    it('trims the selected start of the language and keeps the code block', () => {
+        const muya = bootMuya('Intro paragraph\n\n```js\ncode\n```\n\nOutro\n');
+
+        cut(muya, findContent(muya, 'paragraph.content', 'Intro'), 3, findContent(muya, 'language-input', 'js'), 1);
+
+        expect(settledState(muya)).toEqual([paragraph('Int'), codeBlock('s', 'code'), paragraph('Outro')]);
+        expectLanguageInputs(muya, ['s']);
+    });
+
+    it('removes the blocks before a nested code block and keeps its language', () => {
+        const muya = bootMuya('intro\n\n- item\n\n  ```js\n  code\n  ```\n\n  tail\n');
+
+        cut(muya, findContent(muya, 'paragraph.content', 'intro'), 2, findContent(muya, 'language-input', 'js'), 0);
+
+        const [first, list] = settledState(muya) as [unknown, { name: string; children: Array<{ children: unknown[] }> }];
+        expect(first).toEqual(paragraph('in'));
+        expect(list.name).toBe('bullet-list');
+        expect(list.children.map(item => item.children)).toEqual([[codeBlock('js', 'code'), paragraph('tail')]]);
+        expectLanguageInputs(muya, ['js']);
+    });
+
+    it('clears the language when the whole language line is selected', () => {
+        const muya = bootMuya('Intro\n\n```js\ncode\n```\n');
+
+        cut(muya, findContent(muya, 'paragraph.content', 'Intro'), 5, findContent(muya, 'language-input', 'js'), 2);
+
+        expect(settledState(muya)).toEqual([paragraph('Intro'), codeBlock('', 'code')]);
+        expectLanguageInputs(muya, ['']);
+    });
+
+    it('from one language line into another: collapses the first code block and keeps the second', () => {
+        const muya = bootMuya('```js\na\n```\n\nmid\n\n```py\nb\n```\n');
+
+        cut(muya, findContent(muya, 'language-input', 'js'), 1, findContent(muya, 'language-input', 'py'), 1);
+
+        expect(settledState(muya)).toEqual([paragraph('j'), codeBlock('y', 'b')]);
+        expectLanguageInputs(muya, ['y']);
+    });
+});
@@ -7,6 +7,7 @@ import type { Nullable } from '../types';
 import type Clipboard from './index';
 import Format from '../block/base/format';
 import CodeBlockContent from '../block/content/codeBlockContent';
+import LangInputContent from '../block/content/langInputContent';
 import { ScrollPage } from '../block/scrollPage';
 import { CLASS_NAMES } from '../config';
 import { SelectionDirection, SelectionType } from '../selection/types';
@@ -419,16 +420,44 @@ export function cutSelection(clipboard: Clipboard): void {
     // only the structure strictly between the two leaves (and the emptied
     // end-side containers). The start block keeps its container — a list
     // item stays a list item, a quote stays a quote.
-    startBlock.text
-        = startBlock.text.substring(0, startOffset)
-            + endBlock.text.substring(endOffset);
+    const { tail, lastRemoved } = resolveCutEnd(startBlock, endBlock, endOffset);
+    startBlock.text = startBlock.text.substring(0, startOffset) + tail;
 
-    removeBlocks(startBlock, endBlock);
+    if (lastRemoved)
+        removeBlocks(startBlock, lastRemoved);
 
     setCursorAndConvert(startBlock, startOffset);
     resetIfEmpty(clipboard);
 }
 
+interface ICutEnd {
+    // Text after the selection end that joins the start block.
+    tail: string;
+    // The last content leaf whose branch the cut removes; null when nothing
+    // lies between the start block and the end.
+    lastRemoved: Nullable<Content>;
+}
+
+// Where a cross-block cut stops. Normally at the end leaf, whose text after the
+// caret joins the start block. A cut ending inside a code block's language
+// line stops before that code block instead: the code block keeps its code and
+// language input, and loses only the selected start of its language (#5371).
+function resolveCutEnd(startBlock: Content, endBlock: Content, endOffset: number): ICutEnd {
+    if (!(endBlock instanceof LangInputContent))
+        return { tail: endBlock.text.substring(endOffset), lastRemoved: endBlock };
+
+    const language = endBlock.text.substring(endOffset);
+    if (language !== endBlock.text) {
+        endBlock.text = language;
+        endBlock.parent!.lang = language;
+        endBlock.update();
+    }
+
+    const beforeCodeBlock = endBlock.previousContentInContext();
+
+    return { tail: '', lastRemoved: beforeCodeBlock === startBlock ? null : beforeCodeBlock };
+}
+
 // #918: collapse the start code block (whose language line begins the
 // selection) into a paragraph carrying the merged head + end-tail text, then
 // remove the spanned structure.
@@ -439,9 +468,8 @@ function collapseLanguageInputCut(
     startOffset: number,
     endOffset: number,
 ): void {
-    const mergedText
-        = startBlock.text.substring(0, startOffset)
-            + endBlock.text.substring(endOffset);
+    const { tail, lastRemoved } = resolveCutEnd(startBlock, endBlock, endOffset);
+    const mergedText = startBlock.text.substring(0, startOffset) + tail;
     // The code block itself, even inside a list item or quote: replacing the
     // outermost block would take the rest of that list or quote with it (#5368).
     const codeBlock = startBlock.getAnchor();
@@ -450,8 +478,8 @@ function collapseLanguageInputCut(
     // the replacement below removes that code with its block. `removeBlocks`
     // would detach the inner `code` node, which shares the code block's json
     // path, so the json state would lose the following block (#4903, #5148).
-    if (codeBlock == null || !endBlock.isInBlock(codeBlock))
-        removeBlocks(startBlock, endBlock);
+    if (lastRemoved && (codeBlock == null || !lastRemoved.isInBlock(codeBlock)))
+        removeBlocks(startBlock, lastRemoved);
 
     const paragraph = ScrollPage.loadBlock('paragraph').create(clipboard.muya, {
         name: 'paragraph',