diff --git a/packages/desktop/electron.vite.config.ts b/packages/desktop/electron.vite.config.ts
index 5cd88b0cc9..faadce610e 100644
--- a/packages/desktop/electron.vite.config.ts
+++ b/packages/desktop/electron.vite.config.ts
@@ -101,7 +101,14 @@ export default defineConfig({
         plugins: [
           postcssPresetEnv({
             stage: 0,
-            features: { 'nesting-rules': true }
+            features: {
+              'nesting-rules': true,
+              // Electron ships Chromium, which supports CSS logical properties
+              // natively. Leave them untouched so `padding-inline-start` /
+              // `inset-inline-start` mirror correctly under `dir="rtl"` instead
+              // of being down-compiled to hard-coded LTR physical props (#4673).
+              'logical-properties-and-values': false
+            }
           })
         ]
       }
diff --git a/packages/desktop/src/main/app/index.ts b/packages/desktop/src/main/app/index.ts
index 372b74d5ea..74411b3f34 100644
--- a/packages/desktop/src/main/app/index.ts
+++ b/packages/desktop/src/main/app/index.ts
@@ -828,12 +828,20 @@ class App {
     })
 
     ipcMain.handle('mt::keybinding-save-user-keybindings', async(_event, userKeybindings) => {
-      const { keybindings } = this._accessor
+      const { keybindings, menu } = this._accessor
       const editorWindows = this._windowManager
         .getWindowsByType(WindowType.EDITOR)
         .map(({ win }) => win.browserWindow)
         .filter((win): win is BrowserWindow => win != null)
-      return keybindings.setUserKeybindings(userKeybindings, editorWindows)
+      const saved = await keybindings.setUserKeybindings(userKeybindings, editorWindows)
+
+      menu.updateKeybindings()
+      const keybindingMap = Object.fromEntries(keybindings.keys)
+      for (const win of editorWindows) {
+        win.webContents.send('mt::keybindings-response', keybindingMap)
+      }
+
+      return saved
     })
 
     ipcMain.handle('mt::fs-trash-item', async(_event, fullPath: string) => {
diff --git a/packages/desktop/src/main/menu/index.ts b/packages/desktop/src/main/menu/index.ts
index a66c873c9b..db818946cd 100644
--- a/packages/desktop/src/main/menu/index.ts
+++ b/packages/desktop/src/main/menu/index.ts
@@ -309,6 +309,42 @@ class AppMenu {
     })
   }
 
+  /**
+   * Rebuild every window menu so updated keybinding accelerators are reflected
+   * wherever shortcuts are shown: the menu bar on Windows/Linux and the macOS
+   * application menu for both editor and settings windows.
+   */
+  updateKeybindings(): void {
+    const recentUsedDocuments = this.getRecentlyUsedDocuments()
+    this.windowMenus.forEach((value, key) => {
+      const { menu: oldMenu, type } = value
+
+      let newMenu: Menu | null = null
+      if (type === MenuType.EDITOR) {
+        if (!oldMenu) return
+        const { menu: rebuilt } = this._buildEditorMenu(recentUsedDocuments)
+        if (!rebuilt) return
+
+        updateMenuItem(oldMenu, rebuilt, 'sourceCodeModeMenuItem')
+        updateMenuItem(oldMenu, rebuilt, 'typewriterModeMenuItem')
+        updateMenuItem(oldMenu, rebuilt, 'focusModeMenuItem')
+        updateMenuItem(oldMenu, rebuilt, 'sideBarMenuItem')
+        updateMenuItem(oldMenu, rebuilt, 'tabBarMenuItem')
+        newMenu = rebuilt
+      } else if (type === MenuType.SETTINGS) {
+        newMenu = this._buildSettingMenu().menu
+        if (!newMenu) return
+      } else {
+        return
+      }
+
+      value.menu = newMenu
+      if (this.activeWindowId === key) {
+        this._setApplicationMenu(newMenu)
+      }
+    })
+  }
+
   /**
    * Update line ending menu items.
    *
diff --git a/packages/desktop/src/renderer/src/components/search/index.vue b/packages/desktop/src/renderer/src/components/search/index.vue
index c835a5f736..6ae87b26cc 100644
--- a/packages/desktop/src/renderer/src/components/search/index.vue
+++ b/packages/desktop/src/renderer/src/components/search/index.vue
@@ -170,6 +170,11 @@ watch(searchValue, () => {
 })
 
 watch(searchMatches, (newValue, oldValue) => {
+  // Once the search bar is open it owns the query. Ignore editor
+  // selection-changes while open — notably the spurious selection-change the
+  // engine emits when the bar steals editor focus, which would otherwise
+  // clobber the just-prefilled value (e.g. leaving a stale single character).
+  if (showSearch.value) return
   if (!newValue || !oldValue) return
   const { value } = newValue
   if (value !== oldValue.value) {
@@ -177,6 +182,16 @@ watch(searchMatches, (newValue, oldValue) => {
   }
 })
 
+// Seed the find input from the current selection synchronously, before the bar
+// opens and steals focus. Relying on the reactive `searchMatches` watch alone
+// races with the focus-steal selection-change and can drop the prefill.
+const prefillFromSelection = () => {
+  const selected = searchMatches.value?.value
+  if (selected) {
+    searchValue.value = selected
+  }
+}
+
 const highlightIndex = computed(() => {
   if (searchMatches.value) {
     return searchMatches.value.index
@@ -229,6 +244,7 @@ const toggleCtrl = (ctrl: 'isCaseSensitive' | 'isWholeWord' | 'isRegexp') => {
 }
 
 const listenFind = () => {
+  prefillFromSelection()
   showSearch.value = true
   type.value = 'search'
   nextTick(() => {
@@ -240,6 +256,7 @@ const listenFind = () => {
 }
 
 const listenReplace = () => {
+  prefillFromSelection()
   showSearch.value = true
   type.value = 'replace'
 }
diff --git a/packages/desktop/test/unit/specs/keybinding-menu-rebuild.spec.ts b/packages/desktop/test/unit/specs/keybinding-menu-rebuild.spec.ts
new file mode 100644
index 0000000000..f7cf565aaf
--- /dev/null
+++ b/packages/desktop/test/unit/specs/keybinding-menu-rebuild.spec.ts
@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// Main-process slice: after the user saves new keybindings the application menu
+// must be rebuilt so the menu bar shows the updated accelerators (#3998). Drive
+// `AppMenu.updateKeybindings()` with a fake Electron `Menu` and stubbed menu
+// templates and assert every window menu (editor + macOS settings) is rebuilt
+// from the current keybindings and the active window's menu is re-applied.
+
+const { buildFromTemplate, setApplicationMenu, configureMenu, configSettingMenu } = vi.hoisted(
+  () => ({
+    buildFromTemplate: vi.fn((template: unknown) => ({
+      template,
+      getMenuItemById: () => ({ checked: false, enabled: true })
+    })),
+    setApplicationMenu: vi.fn(),
+    configureMenu: vi.fn(() => ['EDITOR_TEMPLATE']),
+    configSettingMenu: vi.fn(() => ['SETTINGS_TEMPLATE'])
+  })
+)
+
+vi.mock('electron', () => ({
+  app: { addRecentDocument: vi.fn(), clearRecentDocuments: vi.fn() },
+  ipcMain: { on: vi.fn(), handle: vi.fn(), emit: vi.fn() },
+  Menu: { buildFromTemplate, setApplicationMenu, getApplicationMenu: vi.fn() }
+}))
+
+vi.mock('common/filesystem', () => ({
+  ensureDirSync: vi.fn(),
+  isDirectory2: () => false,
+  isFile2: () => false
+}))
+
+// macOS so the settings window also owns a (non-null) menu that must rebuild.
+vi.mock('main_renderer/config', () => ({ isLinux: false, isOsx: true, isWindows: false }))
+
+vi.mock('main_renderer/menu/actions/edit', () => ({ updateSidebarMenu: vi.fn() }))
+vi.mock('main_renderer/menu/actions/format', () => ({ updateFormatMenu: vi.fn() }))
+vi.mock('main_renderer/menu/actions/paragraph', () => ({ updateSelectionMenus: vi.fn() }))
+vi.mock('main_renderer/menu/actions/view', () => ({ viewLayoutChanged: vi.fn() }))
+vi.mock('main_renderer/utils/internalIpc', () => ({ onInternalChannel: vi.fn() }))
+vi.mock('main_renderer/i18n.js', () => ({ setLanguage: vi.fn() }))
+vi.mock('main_renderer/menu/templates', () => ({
+  default: configureMenu,
+  configSettingMenu
+}))
+
+import AppMenu from 'main_renderer/menu'
+import type Preference from 'main_renderer/preferences'
+import type Keybindings from 'main_renderer/keyboard/shortcutHandler'
+
+const makeAppMenu = () => {
+  const preferences = { getItem: () => 'en' } as unknown as Preference
+  const keybindings = { registerEditorKeyHandlers: vi.fn() } as unknown as Keybindings
+  return new AppMenu(preferences, keybindings, '/tmp/mt-test')
+}
+
+describe('AppMenu.updateKeybindings rebuilds menus after a keybinding change (#3998)', () => {
+  beforeEach(() => {
+    buildFromTemplate.mockClear()
+    setApplicationMenu.mockClear()
+    configureMenu.mockClear()
+    configSettingMenu.mockClear()
+  })
+
+  it('rebuilds the active editor menu and re-applies it as the application menu', () => {
+    const appMenu = makeAppMenu()
+    const editorWin = { id: 1 } as never
+    appMenu.addEditorMenu(editorWin)
+    appMenu.setActiveWindow(1)
+
+    configureMenu.mockClear()
+    setApplicationMenu.mockClear()
+
+    appMenu.updateKeybindings()
+
+    // The editor menu is rebuilt from the current keybindings...
+    expect(configureMenu).toHaveBeenCalled()
+    // ...and pushed to the OS as the active application menu.
+    expect(setApplicationMenu).toHaveBeenCalledTimes(1)
+  })
+
+  it('also rebuilds the settings-window menu so its accelerators refresh', () => {
+    const appMenu = makeAppMenu()
+    const settingWin = { id: 2 } as never
+    appMenu.addSettingMenu(settingWin)
+
+    configSettingMenu.mockClear()
+
+    appMenu.updateKeybindings()
+
+    expect(configSettingMenu).toHaveBeenCalled()
+  })
+})
diff --git a/packages/desktop/test/unit/specs/search-prefill.spec.ts b/packages/desktop/test/unit/specs/search-prefill.spec.ts
new file mode 100644
index 0000000000..ea4e25d160
--- /dev/null
+++ b/packages/desktop/test/unit/specs/search-prefill.spec.ts
@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import { parse, compileScript } from 'vue/compiler-sfc'
+import ts from 'typescript'
+import { ref, computed, watch, nextTick } from 'vue'
+
+// Regression guard for the find-bar prefill race (issue: the input showed a
+// stale single char like "T" instead of the selection). The bug lives entirely
+// in search/index.vue's reactive logic: `watch(searchMatches)` mirrors the
+// editor selection into the input, but when the find bar opens it steals focus
+// and the engine emits a spurious selection-change pointing at the document
+// start, which clobbers the just-prefilled value.
+//
+// The desktop unit runner ships no @vitejs/plugin-vue / @vue/test-utils, so we
+// compile the real <script setup> at runtime, swap its imports for injected
+// stubs (but keep Vue's *real* ref/computed/watch/nextTick), run setup() to grab
+// the live bindings, and drive the actual reactive code. This mirrors the
+// approach in source-code-image-action.spec.ts.
+
+const here = dirname(fileURLToPath(import.meta.url))
+const vuePath = resolve(here, '../../../src/renderer/src/components/search/index.vue')
+
+interface Bindings {
+  searchValue: { value: string }
+  showSearch: { value: boolean }
+  listenFind: () => void
+}
+
+const loadComponent = (deps: Record<string, unknown>) => {
+  const src = readFileSync(vuePath, 'utf8')
+  const { descriptor } = parse(src)
+  const compiled = compileScript(descriptor, { id: 'test' })
+  const noImports = compiled.content
+    .split('\n')
+    .filter((l) => !/^\s*import\s/.test(l))
+    .join('\n')
+  const js = ts.transpileModule(noImports, {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 }
+  }).outputText
+  // eslint-disable-next-line no-new-func
+  const factory = new Function(
+    '__deps',
+    'exports',
+    'module',
+    `const { _defineComponent, ref, computed, watch, onMounted, onBeforeUnmount,
+      nextTick, bus, FindCaseIcon, FindWordIcon, FindRegexIcon, useEditorStore,
+      storeToRefs, useI18n, debounce, ArrowDown, ArrowUp, RefreshRight, Switch } = __deps
+    ${js}
+    return module.exports`
+  ) as (deps: Record<string, unknown>, exports: object, module: object) => {
+    default: { setup: (props: unknown, ctx: { expose: () => void }) => Bindings }
+  }
+  const m = { exports: {} as Record<string, unknown> }
+  return factory(deps, m.exports, m).default
+}
+
+const makeBindings = () => {
+  // currentFile.searchMatches is the channel SELECTION_CHANGE writes the
+  // selected text into; storeToRefs hands the component a ref to it.
+  const currentFile = ref<{ searchMatches: { matches: unknown[]; index: number; value: string } } | null>({
+    searchMatches: { matches: [], index: -1, value: '' }
+  })
+  const deps = {
+    _defineComponent: (o: unknown) => o,
+    ref,
+    computed,
+    watch,
+    nextTick,
+    onMounted: () => {},
+    onBeforeUnmount: () => {},
+    bus: { on: () => {}, off: () => {}, emit: vi.fn() },
+    FindCaseIcon: {},
+    FindWordIcon: {},
+    FindRegexIcon: {},
+    ArrowDown: {},
+    ArrowUp: {},
+    RefreshRight: {},
+    Switch: {},
+    useEditorStore: () => new Proxy({}, { get: () => () => {} }),
+    storeToRefs: () => ({ currentFile }),
+    useI18n: () => ({ t: (k: string) => k }),
+    debounce: (fn: (...a: unknown[]) => unknown) => fn
+  }
+  const comp = loadComponent(deps)
+  const ret = comp.setup({}, { expose: () => {} })
+  const setSelection = (value: string) => {
+    currentFile.value = { searchMatches: { matches: [], index: -1, value } }
+  }
+  return { ret, setSelection }
+}
+
+describe('find-bar prefill from selection', () => {
+  it('prefills the input with the selected text when the bar opens', async() => {
+    const { ret, setSelection } = makeBindings()
+    setSelection('fox')
+    await nextTick()
+    ret.listenFind()
+    await nextTick()
+    expect(ret.searchValue.value).toBe('fox')
+  })
+
+  it('does not let the focus-steal selection-change clobber the prefill', async() => {
+    const { ret, setSelection } = makeBindings()
+    // User selects a word in the editor.
+    setSelection('fox')
+    await nextTick()
+    // Find bar opens (prefills "fox") and steals focus.
+    ret.listenFind()
+    await nextTick()
+    expect(ret.searchValue.value).toBe('fox')
+    // Opening the bar steals editor focus → the engine emits a spurious
+    // selection-change pointing at the document start ("T"). It must NOT
+    // overwrite the prefilled query now that the bar owns it.
+    setSelection('T')
+    await nextTick()
+    expect(ret.showSearch.value).toBe(true)
+    expect(ret.searchValue.value).toBe('fox')
+  })
+})
diff --git a/packages/muya/e2e/tests/ui/code-block-language-selector-orphan-4654.spec.ts b/packages/muya/e2e/tests/ui/code-block-language-selector-orphan-4654.spec.ts
new file mode 100644
index 0000000000..ba953c5152
--- /dev/null
+++ b/packages/muya/e2e/tests/ui/code-block-language-selector-orphan-4654.spec.ts
@@ -0,0 +1,57 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '../fixtures/muya';
+import { slowType } from '../helpers/keyboard';
+import { floats } from '../helpers/selectors';
+
+// Regression for #4654 — selecting a language for a code block whose ancestor
+// has been detached (orphaned `language-input`) must not crash the renderer.
+//
+// The picker stays open while its target block is converted away: a Backspace
+// at offset 0 of the code body (codeBlockContent.backspaceHandler) replaces the
+// <pre> with a paragraph, so the language-input is still wired to its code
+// block but that code block is no longer in the document. Selecting a language
+// then runs `block.text = name`, whose setter re-computes an OT path that walks
+// up through the detached code block — `codeBlock.path` dereferenced a null
+// parent and threw `Cannot destructure property 'path' of 'this.parent'`.
+//
+// The fix bails in `selectItem` when `block.outMostBlock` is null (not attached
+// to the document root). This spec drives the real `CodeBlockLanguageSelector`
+// float in Chromium and asserts no uncaught `pageerror`.
+
+async function focusFirstLanguageInput(page: Page): Promise<void> {
+    await page.evaluate(() => {
+        const codeBlock = window.muya!.editor.scrollPage.firstChild;
+        codeBlock.firstContentInDescendant().setCursor(0, 0, true);
+    });
+    await expect
+        .poll(() => page.evaluate(() => window.muya!.editor.activeContentBlock?.blockName))
+        .toBe('language-input');
+}
+
+test('#4654 selecting a language after the code block is detached does not crash', async ({ page }) => {
+    const errors: string[] = [];
+    page.on('pageerror', err => errors.push(String(err?.message ?? err)));
+
+    // Code block nested in a list item — the #4654 context.
+    await page.evaluate(() => window.muya!.setContent('- \n  ```\n  code\n  ```\n'));
+    await focusFirstLanguageInput(page);
+    await slowType(page, 'pyth');
+    await expect(page.locator(floats.codeBlockLanguageSelector)).toBeVisible();
+
+    // Detach the code block from the document without moving the caret, so the
+    // picker stays up with a now-orphaned language-input target. (A caret move
+    // would trip the selection-change auto-hide; this isolates the selectItem
+    // guard, which is the last-resort net for any detach the auto-hide misses.)
+    await page.evaluate(() => {
+        const langInput = window.muya!.editor.activeContentBlock;
+        langInput.parent.remove();
+    });
+
+    // Click the language item that is still rendered in the open picker.
+    await page
+        .locator(`${floats.codeBlockLanguageSelector} li.item[data-label="python"]`)
+        .click({ force: true });
+    await page.waitForTimeout(200);
+
+    expect(errors, `renderer pageerrors: ${errors.join(' | ')}`).toEqual([]);
+});
diff --git a/packages/muya/e2e/tests/ui/code-block-language-selector.spec.ts b/packages/muya/e2e/tests/ui/code-block-language-selector.spec.ts
index 7350000c7c..36c62663f0 100644
--- a/packages/muya/e2e/tests/ui/code-block-language-selector.spec.ts
+++ b/packages/muya/e2e/tests/ui/code-block-language-selector.spec.ts
@@ -112,6 +112,26 @@ test.describe('code-block language selector', () => {
             .toBe('0');
     });
 
+    test('the picker hides when the caret leaves the language input', async ({ page }) => {
+        await page.evaluate(() => window.muya!.setContent('```\ncode\n```\n'));
+        await focusFirstLanguageInput(page);
+        await slowType(page, 'pyth');
+        await expect(page.locator(floats.codeBlockLanguageSelector)).toBeVisible();
+        // Moving the caret out of the language-input (as Left/Right arrow does)
+        // emits a `selection-change` whose anchorBlock is no longer the picker's
+        // target, so the selector self-hides (#4654).
+        await page.evaluate(() => {
+            const langInput = window.muya!.editor.activeContentBlock;
+            langInput.parent.lastContentInDescendant().setCursor(0, 0, true);
+        });
+        const wrapper = page
+            .locator(floats.codeBlockLanguageSelector)
+            .locator('xpath=ancestor::*[contains(@class,"mu-float-wrapper")]');
+        await expect
+            .poll(() => wrapper.evaluate(el => (el as HTMLElement).style.opacity))
+            .toBe('0');
+    });
+
     test('typing the opening fence in a paragraph opens the picker', async ({ page }) => {
         // The selector also listens on `paragraph.content`: a fence prefix like
         // ```pyth in a plain paragraph is parsed for the language token and
diff --git a/packages/muya/src/assets/styles/blockSyntax.css b/packages/muya/src/assets/styles/blockSyntax.css
index 1502cd4352..a399d943d5 100644
--- a/packages/muya/src/assets/styles/blockSyntax.css
+++ b/packages/muya/src/assets/styles/blockSyntax.css
@@ -375,10 +375,11 @@ span.mu-language-input {
     padding: 0;
 }
 
-/* order list and bullet list */
+/* order list and bullet list — logical `inline-start` so nested-list
+   indentation mirrors correctly under `dir="rtl"` (#4673) */
 ol.mu-order-list,
 ul.mu-bullet-list {
-    padding-left: 30px;
+    padding-inline-start: 30px;
 }
 
 ol.mu-order-list {
@@ -449,7 +450,7 @@ ol.mu-order-list ol.mu-order-list ul.mu-bullet-list {
 
 /* task list */
 ul.mu-task-list {
-    padding-left: 30px;
+    padding-inline-start: 30px;
 }
 
 li.mu-task-list-item {
@@ -462,7 +463,7 @@ li.mu-task-list-item > input[type='checkbox'],
 li.mu-task-list-item > span.mu-task-list-checkbox {
     position: absolute;
     top: 0.3em;
-    left: -23px;
+    inset-inline-start: -23px;
 
     width: 12px;
     height: 12px;
diff --git a/packages/muya/src/block/extra/math/__tests__/mhchem.spec.ts b/packages/muya/src/block/extra/math/__tests__/mhchem.spec.ts
new file mode 100644
index 0000000000..8182bdb10e
--- /dev/null
+++ b/packages/muya/src/block/extra/math/__tests__/mhchem.spec.ts
@@ -0,0 +1,13 @@
+import katex from 'katex';
+import { describe, expect, it } from 'vitest';
+import '../mathPreview';
+
+describe('mhchem (\\ce) extension registration', () => {
+    it('patches the same katex instance the renderers use', () => {
+        expect(() =>
+            katex.renderToString('\\ce{Zn^2+ <=> Zn(OH)2}', {
+                displayMode: true,
+            }),
+        ).not.toThrow();
+    });
+});
diff --git a/packages/muya/src/block/extra/math/mathPreview.ts b/packages/muya/src/block/extra/math/mathPreview.ts
index 443c31f47d..6f081b1da2 100644
--- a/packages/muya/src/block/extra/math/mathPreview.ts
+++ b/packages/muya/src/block/extra/math/mathPreview.ts
@@ -5,7 +5,7 @@ import { fromEvent } from 'rxjs';
 import { CLASS_NAMES } from '../../../config';
 import logger from '../../../utils/logger';
 import Parent from '../../base/parent';
-import 'katex/dist/contrib/mhchem.min.js';
+import 'katex/dist/contrib/mhchem.mjs';
 
 const debug = logger('mathPreview:');
 
diff --git a/packages/muya/src/inlineRenderer/__tests__/linkFollowedByAutolink.spec.ts b/packages/muya/src/inlineRenderer/__tests__/linkFollowedByAutolink.spec.ts
new file mode 100644
index 0000000000..ad14b39436
--- /dev/null
+++ b/packages/muya/src/inlineRenderer/__tests__/linkFollowedByAutolink.spec.ts
@@ -0,0 +1,39 @@
+// @vitest-environment happy-dom
+
+import type { Token } from '../types';
+import { describe, expect, it } from 'vitest';
+import { tokenizer } from '../lexer';
+
+// #4671: a well-formed inline/reference link must not be vetoed just because
+// its destination URL also matches the GFM extended (bare-URL) autolink rule.
+// Extended autolinks are a post-process over plain text and bind LESS tightly
+// than a link, so they must never override `[text](url)`.
+
+function linkTokens(src: string) {
+    return tokenizer(src).filter(t => t.type === 'link') as Array<Token & { href?: string; anchor?: string }>;
+}
+
+describe('inline link followed by trailing punctuation (#4671)', () => {
+    it('recognizes a link whose closing paren is followed by a CJK comma', () => {
+        const links = linkTokens('支持[CommonMark 规范](https://spec.commonmark.org/)、其他');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('https://spec.commonmark.org/');
+        expect(links[0].raw).toBe('[CommonMark 规范](https://spec.commonmark.org/)');
+    });
+
+    it('recognizes the first of two links on one line', () => {
+        const links = linkTokens(
+            '支持[CommonMark 规范](https://spec.commonmark.org/)、 [GitHub Flavored Markdown 规范](https://github.github.com/gfm/)',
+        );
+        expect(links).toHaveLength(2);
+        expect(links[0].href).toBe('https://spec.commonmark.org/');
+        expect(links[1].href).toBe('https://github.github.com/gfm/');
+    });
+
+    it('recognizes a link whose destination URL is immediately followed by text', () => {
+        const links = linkTokens('see [docs](https://example.com/path)next');
+        expect(links).toHaveLength(1);
+        expect(links[0].href).toBe('https://example.com/path');
+        expect(links[0].raw).toBe('[docs](https://example.com/path)');
+    });
+});
diff --git a/packages/muya/src/inlineRenderer/lexer.ts b/packages/muya/src/inlineRenderer/lexer.ts
index 3a9b1c3d43..91b9430ed5 100644
--- a/packages/muya/src/inlineRenderer/lexer.ts
+++ b/packages/muya/src/inlineRenderer/lexer.ts
@@ -6,7 +6,7 @@ import type {
     Token,
 } from './types';
 import { isLengthEven, union } from '../utils';
-import { beginRules, inlineRules, validateRules } from './rules';
+import { beginRules, inlineRules, linkValidateRules, validateRules } from './rules';
 import {
     correctUrl,
     getAttributes,
@@ -361,7 +361,7 @@ function tryLink(state: ILexState): boolean {
             // than links. If a higher-priority inline rule matches a span
             // that extends past the tentative link's range, defer to it.
             // Covers CM 0.29 examples 520 (HTML tag) and 521 (code span).
-            && lowerPriority(state.src, linkTo[0].length, validateRules)
+            && lowerPriority(state.src, linkTo[0].length, linkValidateRules)
         )
     ) {
         return false;
@@ -414,7 +414,7 @@ function tryReferenceLink(state: ILexState): boolean {
             && state.labels.has((rLinkTo[3] || rLinkTo[1]).toLowerCase())
             && isLengthEven(rLinkTo[2])
             && isLengthEven(rLinkTo[4])
-            && lowerPriority(state.src, rLinkTo[0].length, validateRules)
+            && lowerPriority(state.src, rLinkTo[0].length, linkValidateRules)
         )
     ) {
         return false;
diff --git a/packages/muya/src/inlineRenderer/renderer/inlineMath.ts b/packages/muya/src/inlineRenderer/renderer/inlineMath.ts
index 25c9f51d5d..d1dd16b19a 100644
--- a/packages/muya/src/inlineRenderer/renderer/inlineMath.ts
+++ b/packages/muya/src/inlineRenderer/renderer/inlineMath.ts
@@ -3,7 +3,7 @@ import type Renderer from './index';
 import katex from 'katex';
 import { CLASS_NAMES } from '../../config';
 import { htmlToVNode } from '../../utils/snabbdom';
-import 'katex/dist/contrib/mhchem.min.js';
+import 'katex/dist/contrib/mhchem.mjs';
 
 import 'katex/dist/katex.min.css';
 
diff --git a/packages/muya/src/inlineRenderer/rules.ts b/packages/muya/src/inlineRenderer/rules.ts
index 8437b6337a..0a1f6cdbe2 100644
--- a/packages/muya/src/inlineRenderer/rules.ts
+++ b/packages/muya/src/inlineRenderer/rules.ts
@@ -110,3 +110,17 @@ export const validateRules: ValidateRules = (Object.keys(inlineRules) as InlineR
         };
     }
 }, {} as ValidateRules);
+
+// Veto set used when validating a tentative `[text](url)` / reference link.
+// Per CommonMark §6.6 only code spans, raw HTML tags and `<...>` autolinks bind
+// more tightly than a link, so only those may defer a link that overlaps them
+// (CM 0.29 examples 520/521). Using the full `validateRules` here is wrong: a
+// GFM extended (bare-URL) autolink or the link rule's own greedy destination
+// match would extend past the tentative link and veto it, dropping links such
+// as `[t](https://x)、` or `[t](https://x)foo` and the first of two links on a
+// line (#4671).
+export const linkValidateRules: Pick<InlineRules, 'inline_code' | 'html_tag' | 'auto_link'> = {
+    inline_code: inlineRules.inline_code,
+    html_tag: inlineRules.html_tag,
+    auto_link: inlineRules.auto_link,
+};
diff --git a/packages/muya/src/ui/codeBlockLanguageSelector/__tests__/selectItem.spec.ts b/packages/muya/src/ui/codeBlockLanguageSelector/__tests__/selectItem.spec.ts
new file mode 100644
index 0000000000..27a8426e1c
--- /dev/null
+++ b/packages/muya/src/ui/codeBlockLanguageSelector/__tests__/selectItem.spec.ts
@@ -0,0 +1,71 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest';
+import { CodeBlockLanguageSelector } from '../index';
+
+// `selectItem` only touches a small, structurally-typed slice of the selector
+// surface: `this._block` (the language-input content), `this.muya`, and — via
+// `super.selectItem` — `this.cb` and `requestAnimationFrame(this.hide)`. So,
+// like langInputContent/handlers.spec.ts, we drive the prototype method off a
+// fake `this` and avoid the full Muya/DOM bootstrap. happy-dom supplies
+// `requestAnimationFrame` for the inherited hide-on-select tail.
+//
+// NOTE: the real #4654 crash (mutating an orphaned block re-computes an OT
+// path through a detached parent) cannot be reproduced with a structural mock
+// — the mock's `block.text = name` is a plain property set, not the engine's
+// path-computing setter. The end-to-end reproduction lives in
+// e2e/tests/ui/code-block-language-selector-orphan-4654.spec.ts; this spec
+// pins the guard's contract: a detached block (`outMostBlock` null) is left
+// untouched.
+
+function selectLanguage(fakeThis: unknown, name: string) {
+    CodeBlockLanguageSelector.prototype.selectItem.call(
+        fakeThis as CodeBlockLanguageSelector,
+        { name },
+    );
+}
+
+describe('codeBlockLanguageSelector.selectItem', () => {
+    it('applies the language to the parent code block when attached', () => {
+        const lastContent = { setCursor: vi.fn() };
+        const parent = {
+            lang: '',
+            lastContentInDescendant: vi.fn(() => lastContent),
+        };
+        const block = {
+            blockName: 'language-input',
+            text: '',
+            parent,
+            outMostBlock: parent, // truthy => attached to the document
+            update: vi.fn(),
+        };
+        const fakeThis = { _block: block, muya: {}, hide: vi.fn() };
+
+        selectLanguage(fakeThis, 'python');
+
+        expect(block.text).toBe('python');
+        expect(block.update).toHaveBeenCalledTimes(1);
+        expect(parent.lang).toBe('python');
+        expect(lastContent.setCursor).toHaveBeenCalledWith(0, 0);
+    });
+
+    // Regression: #4654 — when the language-input's block is detached from the
+    // document (its code block was converted away while the picker stayed open),
+    // `outMostBlock` is null and selectItem must bail without mutating, instead
+    // of crashing on the orphaned parent chain.
+    it('leaves a detached block untouched (outMostBlock null)', () => {
+        const parent = { lang: '', lastContentInDescendant: vi.fn() };
+        const block = {
+            blockName: 'language-input',
+            text: '',
+            parent, // immediate parent exists, but...
+            outMostBlock: null, // ...an ancestor is detached from the root
+            update: vi.fn(),
+        };
+        const fakeThis = { _block: block, muya: {}, hide: vi.fn() };
+
+        expect(() => selectLanguage(fakeThis, 'javascript')).not.toThrow();
+        expect(block.text).toBe('');
+        expect(block.update).not.toHaveBeenCalled();
+        expect(parent.lang).toBe('');
+    });
+});
diff --git a/packages/muya/src/ui/codeBlockLanguageSelector/index.ts b/packages/muya/src/ui/codeBlockLanguageSelector/index.ts
index 0a19176654..4d5cd37a77 100644
--- a/packages/muya/src/ui/codeBlockLanguageSelector/index.ts
+++ b/packages/muya/src/ui/codeBlockLanguageSelector/index.ts
@@ -93,6 +93,12 @@ export class CodeBlockLanguageSelector extends BaseScrollFloat {
                 this.hide();
             }
         });
+
+        // Self-hide when the caret leaves the picker's target block (#4654).
+        eventCenter.on('selection-change', ({ anchorBlock }) => {
+            if (this.status && anchorBlock !== this._block)
+                this.hide();
+        });
     }
 
     render() {
@@ -170,6 +176,11 @@ export class CodeBlockLanguageSelector extends BaseScrollFloat {
         if (!block)
             return;
 
+        // Bail if the block was detached from the document while the picker
+        // stayed open — mutating an orphaned block crashes on a null parent (#4654).
+        if (!block.outMostBlock)
+            return;
+
         function isParagraphContent(
             b: ParagraphContent | LangInputContent,
         ): b is ParagraphContent {
@@ -190,10 +201,11 @@ export class CodeBlockLanguageSelector extends BaseScrollFloat {
             codeContent?.setCursor(0, 0);
         }
         else {
+            const codeBlock = block.parent!;
             block.text = name;
             block.update();
-            block.parent!.lang = name;
-            block.parent?.lastContentInDescendant()?.setCursor(0, 0);
+            codeBlock.lang = name;
+            codeBlock.lastContentInDescendant()?.setCursor(0, 0);
         }
 
         super.selectItem(item);
diff --git a/packages/muya/src/utils/marked/extensions/math.ts b/packages/muya/src/utils/marked/extensions/math.ts
index af64d7f260..afdeefb68e 100644
--- a/packages/muya/src/utils/marked/extensions/math.ts
+++ b/packages/muya/src/utils/marked/extensions/math.ts
@@ -1,4 +1,5 @@
 import katex from 'katex';
+import 'katex/dist/contrib/mhchem.mjs';
 
 export interface IMathToken {
     type: 'inlineMath' | 'multiplemath';