From 8e1dccff21f5c8e26387530b579a40126295b01a Mon Sep 17 00:00:00 2001
From: NSO <108399823+NSO73@users.noreply.github.com>
Date: Wed, 24 Jun 2026 13:37:17 +0200
Subject: [PATCH 1/6] fix(renderer): keep find-bar prefill from being clobbered
 on open (#4646)

Selecting a word and opening the find bar is meant to prefill the find input
with the selection. The prefill is driven reactively by `watch(searchMatches)`,
which mirrors the editor's current selection into the input. But opening the
bar steals focus from the editor, and the engine emits a spurious
selection-change for the reset selection. Because the watch is async, that
change coalesces with the intended one and can cancel it, leaving a stale value
in the input (the regression guard observes a single leading character, e.g.
"T").

Fix in two parts:
- Seed the input synchronously from the current selection when the bar opens
  (`prefillFromSelection`), so the prefill can't lose the race with the
  focus-steal selection-change.
- Once open, the bar owns the query: ignore editor selection-changes in the
  `searchMatches` watch while `showSearch` is true, so the focus-steal change
  can't clobber the prefilled/typed value.

Covered by test/e2e/search-prefill-from-selection.spec.ts (the race reproduces
under the Linux/xvfb CI environment).
---
 .../renderer/src/components/search/index.vue  |  17 +++
 .../test/unit/specs/search-prefill.spec.ts    | 121 ++++++++++++++++++
 2 files changed, 138 insertions(+)
 create mode 100644 packages/desktop/test/unit/specs/search-prefill.spec.ts

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/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')
+  })
+})

From f4998a90f55cd4614552f7aa59c46ca0158ce436 Mon Sep 17 00:00:00 2001
From: Ran Luo <luoran1988@126.com>
Date: Wed, 24 Jun 2026 19:52:11 +0800
Subject: [PATCH 2/6] fix(muya): preserve nested-list indentation in RTL mode
 (#4676)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(muya): preserve nested-list indentation in RTL mode (#4673)

List containers used physical `padding-left` and the task-list checkbox
used physical `left`, neither of which follows `dir="rtl"`. In RTL the
padding stayed on the left while markers flipped to the right, so every
nesting level collapsed onto the same right-hand axis.

Switch to the logical `padding-inline-start` / `inset-inline-start`
equivalents. These are identical to the physical properties under LTR
(no visual change) and mirror to the right under RTL, restoring the
visual hierarchy of nested ordered, bullet, and task lists.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(desktop): stop down-compiling CSS logical properties to LTR physical

`postcssPresetEnv({ stage: 0 })` enabled the `logical-properties-and-values`
transform (postcss-logical), which rewrites `padding-inline-start` /
`inset-inline-start` to hard-coded LTR `padding-left` / `left` at build
time. That silently defeated the list-indentation logical properties under
`dir="rtl"` — the served CSS always resolved to the left regardless of text
direction.

Electron ships Chromium, which supports logical properties natively, so the
down-compile is unnecessary. Disable just that feature; everything else in
preset-env is unchanged. Verified in the Electron 42 Chromium: nested lists
now resolve `padding-right: 30px` per level under RTL, stepping the hierarchy
in from the right edge (#4673).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/desktop/electron.vite.config.ts        | 9 ++++++++-
 packages/muya/src/assets/styles/blockSyntax.css | 9 +++++----
 2 files changed, 13 insertions(+), 5 deletions(-)

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/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;

From d0a053444a7f30ade92bc4221e6fd656d065895d Mon Sep 17 00:00:00 2001
From: Ran Luo <luoran1988@126.com>
Date: Wed, 24 Jun 2026 19:53:15 +0800
Subject: [PATCH 3/6] fix(muya): load mhchem onto the same katex instance so
 \ce renders (#4670) (#4674)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The math renderers imported the chemistry extension via
`katex/dist/contrib/mhchem.min.js`. That deep path falls through the
katex exports map to the UMD bundle, whose internal `require("katex")`
resolves to the CommonJS build (`dist/katex.js`) — a different module
instance from the ESM `import katex from 'katex'` (`dist/katex.mjs`) the
renderers actually call. mhchem patched the CJS instance while rendering
used the ESM one, so `\ce{...}` stayed an undefined control sequence and
fell back to "Invalid Mathematical Formula".

Import the ESM build `katex/dist/contrib/mhchem.mjs` instead, which
extends the same deduped instance. Also add the import to the HTML-export
render path in marked/extensions/math.ts, which was missing it entirely.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../src/block/extra/math/__tests__/mhchem.spec.ts   | 13 +++++++++++++
 packages/muya/src/block/extra/math/mathPreview.ts   |  2 +-
 .../muya/src/inlineRenderer/renderer/inlineMath.ts  |  2 +-
 packages/muya/src/utils/marked/extensions/math.ts   |  1 +
 4 files changed, 16 insertions(+), 2 deletions(-)
 create mode 100644 packages/muya/src/block/extra/math/__tests__/mhchem.spec.ts

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/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/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';

From 93418bbb3163e405e06c14b965c744b622eb963c Mon Sep 17 00:00:00 2001
From: Ran Luo <luoran1988@126.com>
Date: Wed, 24 Jun 2026 22:40:29 +0800
Subject: [PATCH 4/6] fix(muya): keep inline links that are followed by a bare
 URL or text (#4671) (#4672)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A well-formed `[text](url)` (or reference) link was dropped whenever its
destination URL also matched the GFM extended (bare-URL) autolink rule and
was immediately followed by more content — e.g. a CJK comma `[t](https://x)、`,
trailing text `[t](https://x)foo`, or simply the first of two links on one
line. The rendered output showed the raw markdown with the link styling
bleeding into the following text.

Root cause: `tryLink`/`tryReferenceLink` validated the tentative link with
`lowerPriority(..., validateRules)`, the full inline-rule set. Two of those
rules can match a span that runs past the link and falsely veto it:

  - `auto_link_extension` matches the bare destination URL plus any trailing
    punctuation/text, so it extends beyond the link's closing paren.
  - `link`/`image` themselves use a greedy `.*` destination and (before
    `correctUrl` runs) match across to a later link on the same line.

Per CommonMark §6.6 only code spans, raw HTML tags and `<...>` autolinks bind
more tightly than a link, so only those may defer it (the documented CM 0.29
examples 520/521). Introduce `linkValidateRules` containing exactly those three
and use it for both link validators. Extended autolinks and angle autolinks in
plain text, and the code-span/HTML-tag precedence cases, all still behave.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../__tests__/linkFollowedByAutolink.spec.ts  | 39 +++++++++++++++++++
 packages/muya/src/inlineRenderer/lexer.ts     |  6 +--
 packages/muya/src/inlineRenderer/rules.ts     | 14 +++++++
 3 files changed, 56 insertions(+), 3 deletions(-)
 create mode 100644 packages/muya/src/inlineRenderer/__tests__/linkFollowedByAutolink.spec.ts

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/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,
+};

From d313298348ffe9bea429030b00f389a216f2e116 Mon Sep 17 00:00:00 2001
From: Ran Luo <luoran1988@126.com>
Date: Wed, 24 Jun 2026 22:49:28 +0800
Subject: [PATCH 5/6] fix(keybinding): sync menu bar and command palette when
 keybindings change (#4681)

* feat(menu): add AppMenu.updateKeybindings to rebuild menus from current bindings

Rebuild every window menu (editor + macOS settings) so accelerators are
re-read from the live keybinding map, re-applying the active window's menu.
Editor menus preserve their runtime toggle state. This is the capability the
keybinding-save flow needs to refresh the menu bar without a restart (#3998).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(keybinding): sync menu bar and command palette on keybinding save

After persisting user keybindings, rebuild the application menu via
AppMenu.updateKeybindings() and push the refreshed accelerator map to editor
windows so the command palette updates too. Previously the new bindings only
took effect after an app restart, so the menu bar and command palette kept
showing the old shortcuts (#3998).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/desktop/src/main/app/index.ts        | 12 ++-
 packages/desktop/src/main/menu/index.ts       | 36 +++++++
 .../specs/keybinding-menu-rebuild.spec.ts     | 93 +++++++++++++++++++
 3 files changed, 139 insertions(+), 2 deletions(-)
 create mode 100644 packages/desktop/test/unit/specs/keybinding-menu-rebuild.spec.ts

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/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()
+  })
+})

From 09c40460b22441800604cc6c03c29076b4467053 Mon Sep 17 00:00:00 2001
From: Ran Luo <luoran1988@126.com>
Date: Wed, 24 Jun 2026 23:08:01 +0800
Subject: [PATCH 6/6] fix(muya): guard detached code block in language selector
 (#4654) (#4677)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(muya): guard detached block in code language selector (#4654)

Selecting a language from the code-block language picker crashed the
renderer when the picker's target block had been detached from the
document while the picker stayed open (e.g. the code block was converted
back to a paragraph via Backspace at offset 0 of the code body, orphaning
its language-input child).

`selectItem`'s `block.text = name` runs the Content text setter, which
re-computes an OT path for the edit operation. For a language-input that
path walks up to its code block, whose `path` getter dereferences its own
(now null) parent — throwing `Cannot destructure property 'path' of
'this.parent'`. The retired muyajs engine hit the same class at
`ContentState.updateCodeLanguage` (`reading 'functionType'` of null).

Bail out of `selectItem` when `block.outMostBlock` is null — the block
(or any ancestor) is no longer connected to the document root — before
mutating its text/lang. `outMostBlock` walks the full parent chain, so it
catches the detached-grandparent case a shallow `block.parent` check misses.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(muya-e2e): cover #4654 language selection on a detached code block

Drives the real CodeBlockLanguageSelector float in Chromium: opens the
picker on a code block nested in a list, detaches the block, then clicks a
language item and asserts no uncaught renderer pageerror. Fails on the
pre-fix engine with `Cannot destructure property 'path' of 'this.parent'`.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(muya): auto-hide code language picker when caret leaves its block

The language picker only hid on a non-matching query or a document click,
so moving the caret out of the language input (e.g. Left/Right arrow) left
it open over a stale target. Subscribe to `selection-change` and hide the
picker when the caret's anchorBlock is no longer its target block — the
same self-perceiving pattern InlineFormatToolbar uses. This also closes the
window that let the target block be detached from under the picker (#4654);
the selectItem outMostBlock guard remains as defense in depth.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...lock-language-selector-orphan-4654.spec.ts | 57 +++++++++++++++
 .../ui/code-block-language-selector.spec.ts   | 20 ++++++
 .../__tests__/selectItem.spec.ts              | 71 +++++++++++++++++++
 .../src/ui/codeBlockLanguageSelector/index.ts | 16 ++++-
 4 files changed, 162 insertions(+), 2 deletions(-)
 create mode 100644 packages/muya/e2e/tests/ui/code-block-language-selector-orphan-4654.spec.ts
 create mode 100644 packages/muya/src/ui/codeBlockLanguageSelector/__tests__/selectItem.spec.ts

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/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);