diff --git a/packages/desktop/package.json b/packages/desktop/package.json
index 32271a0ae2..35b982fd13 100644
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -55,6 +55,7 @@
   "dependencies": {
     "@electron-toolkit/preload": "^3.0.2",
     "@electron-toolkit/utils": "^4.0.0",
+    "@intlify/core-base": "^11.4.6",
     "@element-plus/icons-vue": "^2.3.2",
     "@hfelix/electron-localshortcut": "^4.0.1",
     "@marktext/file-icons": "^1.0.6",
diff --git a/packages/desktop/src/main/filesystem/encoding.ts b/packages/desktop/src/main/filesystem/encoding.ts
index 6058adf3d2..cebee99838 100644
--- a/packages/desktop/src/main/filesystem/encoding.ts
+++ b/packages/desktop/src/main/filesystem/encoding.ts
@@ -33,6 +33,22 @@ const checkSequence = (buffer: Buffer, sequence: number[]): boolean => {
   return sequence.every((v, i) => v === buffer[i])
 }
 
+// `ced` occasionally misdetects a valid UTF-8 file as a legacy double-byte
+// encoding (notably GBK), mojibaking multi-byte text — e.g. Greek µ/κ/α become
+// CJK 碌/魏/伪 (#3151). A NUL byte signals binary / BOM-less UTF-16, not a UTF-8
+// text file.
+const isLikelyUtf8 = (buffer: Buffer): boolean => {
+  if (buffer.includes(0)) {
+    return false
+  }
+  try {
+    new TextDecoder('utf-8', { fatal: true }).decode(buffer)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * Guess the encoding from the buffer.
  */
@@ -49,6 +65,11 @@ export const guessEncoding = (buffer: Buffer, autoGuessEncoding: boolean): Encod
 
   // Auto guess encoding, otherwise use UTF-8.
   if (autoGuessEncoding) {
+    // A file that is already valid UTF-8 must be decoded as UTF-8, regardless
+    // of what `ced` heuristically guesses (#3151).
+    if (isLikelyUtf8(buffer)) {
+      return { encoding: 'utf8', isBom }
+    }
     encoding = ced(buffer)
     if (CED_ICONV_ENCODINGS[encoding]) {
       encoding = CED_ICONV_ENCODINGS[encoding]
diff --git a/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue b/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue
index 8d2d8ca244..7a0ad03e49 100644
--- a/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue
+++ b/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue
@@ -1044,12 +1044,20 @@ const replaceMisspelling = (payload: unknown) => {
 }
 
 const handleUndo = () => {
+  if (sourceCode.value) {
+    return
+  }
+
   if (editor.value) {
     editor.value.undo()
   }
 }
 
 const handleRedo = () => {
+  if (sourceCode.value) {
+    return
+  }
+
   if (editor.value) {
     editor.value.redo()
   }
@@ -1912,6 +1920,10 @@ onMounted(() => {
         // editableHeight is the lowest cursor position(till to top) that editor allowed.
         const editableHeight = container.clientHeight - 100
         animatedScrollTo(container, container.scrollTop + (y - editableHeight), 0)
+      } else if (y < 100) {
+        // Symmetric to #628: scroll up when the cursor rises above the top edge
+        // (e.g. Arrow-Up), otherwise the caret leaves the viewport (#3329).
+        animatedScrollTo(container, container.scrollTop + (y - 100), 0)
       }
     }
 
diff --git a/packages/desktop/src/renderer/src/components/editorWithTabs/sourceCode.vue b/packages/desktop/src/renderer/src/components/editorWithTabs/sourceCode.vue
index beef2d43e4..c685c33969 100644
--- a/packages/desktop/src/renderer/src/components/editorWithTabs/sourceCode.vue
+++ b/packages/desktop/src/renderer/src/components/editorWithTabs/sourceCode.vue
@@ -205,6 +205,26 @@ const handleSelectAll = () => {
   }
 }
 
+const handleUndo = () => {
+  if (!sourceCode.value) {
+    return
+  }
+
+  if (editor.value) {
+    editor.value.execCommand('undo')
+  }
+}
+
+const handleRedo = () => {
+  if (!sourceCode.value) {
+    return
+  }
+
+  if (editor.value) {
+    editor.value.execCommand('redo')
+  }
+}
+
 interface ImageActionPayload {
   id: string
   result: string
@@ -340,6 +360,8 @@ onMounted(() => {
   bus.on('invalidate-image-cache', handleInvalidateImageCache)
   bus.on('file-changed', handleFileChange)
   bus.on('selectAll', handleSelectAll)
+  bus.on('undo', handleUndo)
+  bus.on('redo', handleRedo)
   bus.on('image-action', handleImageAction)
   bus.on('scroll-to-header', handleScrollToHeader)
 
@@ -378,6 +400,8 @@ onBeforeUnmount(() => {
   bus.off('invalidate-image-cache', handleInvalidateImageCache)
   bus.off('file-changed', handleFileChange)
   bus.off('selectAll', handleSelectAll)
+  bus.off('undo', handleUndo)
+  bus.off('redo', handleRedo)
   bus.off('image-action', handleImageAction)
   bus.off('scroll-to-header', handleScrollToHeader)
 
diff --git a/packages/desktop/src/renderer/src/components/editorWithTabs/tabs.vue b/packages/desktop/src/renderer/src/components/editorWithTabs/tabs.vue
index af48d832dd..787daceedf 100644
--- a/packages/desktop/src/renderer/src/components/editorWithTabs/tabs.vue
+++ b/packages/desktop/src/renderer/src/components/editorWithTabs/tabs.vue
@@ -42,7 +42,7 @@
 </template>
 
 <script setup lang="ts">
-import { ref, onMounted, onBeforeUnmount } from 'vue'
+import { ref, watch, nextTick, onMounted, onBeforeUnmount } from 'vue'
 import { useEditorStore } from '@/store/editor'
 import { useLayoutStore } from '@/store/layout'
 import { storeToRefs } from 'pinia'
@@ -91,6 +91,25 @@ const newFile = () => {
   editorStore.NEW_UNTITLED_TAB({})
 }
 
+// Keep the active tab visible when the selection changes by something other
+// than a direct click on a visible tab (keyboard cycle, switch-by-index, open
+// from the sidebar): the strip has `overflow: hidden` and only scrolls on the
+// wheel, so an off-screen tab would otherwise stay hidden (#3958).
+const scrollActiveTabIntoView = () => {
+  const container = tabContainer.value
+  if (!container) return
+  const activeTab = container.querySelector<HTMLElement>('li.active')
+  if (!activeTab) return
+
+  const containerRect = container.getBoundingClientRect()
+  const tabRect = activeTab.getBoundingClientRect()
+  if (tabRect.left < containerRect.left) {
+    container.scrollLeft -= containerRect.left - tabRect.left
+  } else if (tabRect.right > containerRect.right) {
+    container.scrollLeft += tabRect.right - containerRect.right
+  }
+}
+
 const handleTabScroll = (event: WheelEvent) => {
   // Use mouse wheel value first but prioritize X value more (e.g. touchpad input).
   let delta = event.deltaY
@@ -157,6 +176,13 @@ const handleContextMenu = (event: MouseEvent, tab: IFileState) => {
   }
 }
 
+watch(
+  () => currentFile.value?.id,
+  () => {
+    nextTick(scrollActiveTabIntoView)
+  }
+)
+
 onMounted(() => {
   bus.on('TABS::close-this', closeTab)
   bus.on('TABS::close-others', closeOthers)
diff --git a/packages/desktop/src/renderer/src/components/sideBar/tree.vue b/packages/desktop/src/renderer/src/components/sideBar/tree.vue
index 17d4519ac4..fa7de93ef6 100644
--- a/packages/desktop/src/renderer/src/components/sideBar/tree.vue
+++ b/packages/desktop/src/renderer/src/components/sideBar/tree.vue
@@ -65,7 +65,10 @@
       v-if="projectTree"
       class="project-tree"
     >
-      <div class="title">
+      <div
+        class="title"
+        @contextmenu.prevent="handleRootContextMenu"
+      >
         <el-icon
           class="icon-arrow"
           :class="{ fold: !showDirectories }"
@@ -155,6 +158,7 @@ import Folder from './treeFolder.vue'
 import File from './treeFile.vue'
 import OpenedFile from './treeOpenedTab.vue'
 import bus from '../../bus'
+import { showContextMenu } from '../../contextMenu/sideBar'
 import { useI18n } from 'vue-i18n'
 import { ArrowRight } from '@element-plus/icons-vue'
 import type { TreeNode, TabDescriptor } from './types'
@@ -183,6 +187,7 @@ const preferencesStore = usePreferencesStore()
 
 // Computed properties
 const { createCache } = storeToRefs(projectStore)
+const { clipboard } = storeToRefs(projectStore)
 const { openedFilesInSidebar } = storeToRefs(preferencesStore)
 
 // The createCache state is `{ dirname, type }` while an input is shown, and
@@ -207,6 +212,11 @@ const createFile = (): void => {
   bus.emit('SIDEBAR::new', 'file')
 }
 
+const handleRootContextMenu = (event: MouseEvent): void => {
+  projectStore.CHANGE_ACTIVE_ITEM(props.projectTree)
+  showContextMenu(event, !!clipboard.value)
+}
+
 const toggleOpenedFiles = (): void => {
   showOpenedFiles.value = !showOpenedFiles.value
 }
diff --git a/packages/desktop/src/renderer/src/i18n/index.ts b/packages/desktop/src/renderer/src/i18n/index.ts
index 83af3d0f33..721141b372 100644
--- a/packages/desktop/src/renderer/src/i18n/index.ts
+++ b/packages/desktop/src/renderer/src/i18n/index.ts
@@ -1,9 +1,28 @@
 import { createI18n } from 'vue-i18n'
+import { compile, type MessageCompiler } from '@intlify/core-base'
 import bus from '../bus'
-
 // Directly import translation files
 import enTranslations from '../../../../static/locales/en.json'
 
+// vue-i18n compiles each translation lazily on first use, and its compiler
+// throws a SyntaxError on any value it can't parse — e.g. a literal `{{x}}`
+// (nested placeholder) or stray linked-message syntax. A single malformed
+// translation then crashed the renderer; during HTML/PDF export this surfaced
+// as an "Unexpected renderer process error" even though the export itself
+// succeeded (issue #4046). Reuse vue-i18n's own compiler so well-formed
+// messages keep their `{name}` interpolation, plurals and linked references,
+// and fall back to the raw text when compilation fails.
+const safeMessageCompiler: MessageCompiler = (message, context) => {
+  try {
+    return compile(message, context)
+  } catch (err) {
+    if (typeof message === 'string') {
+      return () => message
+    }
+    throw err
+  }
+}
+
 // vue-i18n's options type intersection between Composition + Legacy modes is
 // notoriously difficult to satisfy with mixed shapes; we cast the options once
 // at the call site rather than spreading `any` further.
@@ -18,17 +37,8 @@ const i18n = createI18n({
   },
   // Disable plural parsing
   pluralRules: {},
-  // Custom message compiler to handle '|' characters
-  messageCompiler: {
-    compile: (message: unknown) => {
-      // If the message contains '|', return the raw string without plural parsing
-      if (typeof message === 'string' && message.includes('|')) {
-        return () => message
-      }
-      // For other messages, use the default compiler
-      return null
-    }
-  }
+  // Degrade malformed translations to raw text instead of crashing the renderer.
+  messageCompiler: safeMessageCompiler
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 } as any)
 
diff --git a/packages/desktop/test/e2e/issue-781-source-undo.spec.ts b/packages/desktop/test/e2e/issue-781-source-undo.spec.ts
new file mode 100644
index 0000000000..f6b3518777
--- /dev/null
+++ b/packages/desktop/test/e2e/issue-781-source-undo.spec.ts
@@ -0,0 +1,71 @@
+import { expect, test } from '@playwright/test'
+import type { Page } from 'playwright'
+import {
+  launchWithMarkdown,
+  waitForMenuReady,
+  enterSourceMode,
+  sendIpcToRenderer
+} from './helpers'
+
+// Issue #781 — Undo/redo while in Source Code mode must act on the CodeMirror
+// editor, not the hidden WYSIWYG (muya) engine. The Edit › Undo menu item and
+// Cmd/Ctrl+Z both route through `mt::editor-edit-action` → bus `undo`. Before the
+// fix only editor.vue subscribed and called muya.undo() (invisible in source
+// mode), so undo did nothing. sourceCode.vue now also subscribes and runs
+// CodeMirror's `undo`/`redo` command, and editor.vue's handler bails out while
+// source mode is active.
+
+const cmValue = (page: Page): Promise<string> =>
+  page.evaluate(() => {
+    const cm = (
+      document.querySelector('.source-code .CodeMirror') as Element & {
+        CodeMirror: { getValue(): string }
+      }
+    ).CodeMirror
+    return cm.getValue()
+  })
+
+const typeInCm = (page: Page, text: string): Promise<void> =>
+  page.evaluate((t) => {
+    const cm = (
+      document.querySelector('.source-code .CodeMirror') as Element & {
+        CodeMirror: {
+          focus(): void
+          setCursor(p: { line: number; ch: number }): void
+          replaceSelection(text: string): void
+        }
+      }
+    ).CodeMirror
+    cm.focus()
+    cm.setCursor({ line: 0, ch: 'saved baseline'.length })
+    cm.replaceSelection(t)
+  }, text)
+
+const undo = (app: Parameters<typeof sendIpcToRenderer>[0]): Promise<void> =>
+  sendIpcToRenderer(app, 'mt::editor-edit-action', 'undo')
+const redo = (app: Parameters<typeof sendIpcToRenderer>[0]): Promise<void> =>
+  sendIpcToRenderer(app, 'mt::editor-edit-action', 'redo')
+
+test.describe('Issue #781 — undo/redo in source code mode', () => {
+  test('undo reverts a source-mode edit; redo re-applies it', async() => {
+    const { app, page } = await launchWithMarkdown('saved baseline\n')
+    await waitForMenuReady(app)
+
+    await enterSourceMode(page, app)
+    const baseline = await cmValue(page)
+
+    // A single CodeMirror edit (one undo step).
+    await typeInCm(page, ' SRCKEY')
+    expect(await cmValue(page)).toContain('saved baseline SRCKEY')
+
+    // Undo through the same IPC the Edit › Undo menu uses — must hit CodeMirror.
+    await undo(app)
+    await expect.poll(() => cmValue(page)).toBe(baseline)
+
+    // Redo restores the edit.
+    await redo(app)
+    await expect.poll(() => cmValue(page)).toContain('saved baseline SRCKEY')
+
+    await app.close()
+  })
+})
diff --git a/packages/desktop/test/e2e/scroll-up-arrow.spec.ts b/packages/desktop/test/e2e/scroll-up-arrow.spec.ts
new file mode 100644
index 0000000000..57d2c21197
--- /dev/null
+++ b/packages/desktop/test/e2e/scroll-up-arrow.spec.ts
@@ -0,0 +1,46 @@
+import { expect, test } from '@playwright/test'
+import type { ElectronApplication, Page } from 'playwright'
+import { focusEditor, launchWithMarkdown } from './helpers'
+
+// #3329 — moving the caret DOWN auto-scrolls the view (the #628 handler), but
+// moving it UP did not, so the caret slid above the viewport. The fix adds the
+// symmetric upward scroll.
+test.describe('Arrow-up scrolls the document (#3329)', () => {
+  let app: ElectronApplication
+  let page: Page
+
+  test.beforeAll(async() => {
+    const md = `${Array.from({ length: 120 }, (_, i) => `Paragraph ${i + 1}`).join('\n\n')}\n`
+    const launched = await launchWithMarkdown(md)
+    app = launched.app
+    page = launched.page
+    await focusEditor(page)
+  })
+
+  test.afterAll(async() => {
+    if (app) await app.close()
+  })
+
+  const scrollTop = () =>
+    page.evaluate(() => (document.querySelector('.editor-component') as HTMLElement)?.scrollTop ?? -1)
+
+  const pressMany = async(key: string, times: number) => {
+    for (let i = 0; i < times; i++) {
+      await page.keyboard.press(key)
+      await page.waitForTimeout(6)
+    }
+    await page.waitForTimeout(120)
+  }
+
+  test('moving the caret up brings the view back up', async() => {
+    // Caret to the bottom — the #628 handler scrolls the view down.
+    await pressMany('ArrowDown', 80)
+    const bottom = await scrollTop()
+    expect(bottom).toBeGreaterThan(200)
+
+    // Caret back up — the view must follow it upward.
+    await pressMany('ArrowUp', 80)
+    const top = await scrollTop()
+    expect(top).toBeLessThan(bottom - 200)
+  })
+})
diff --git a/packages/desktop/test/e2e/tabs.spec.ts b/packages/desktop/test/e2e/tabs.spec.ts
index 6e6f68cfaf..9f19701791 100644
--- a/packages/desktop/test/e2e/tabs.spec.ts
+++ b/packages/desktop/test/e2e/tabs.spec.ts
@@ -299,6 +299,71 @@ test.describe('Tab management', () => {
     }
   })
 
+  // Issue #3958 — switching to a tab that has overflowed off the right edge of
+  // the tab bar must scroll it back into the visible viewport. Before the fix
+  // the active tab is highlighted but invisible (the strip never scrolls), so
+  // the user can't see which tab they're on. Runs in its own app because it
+  // opens many tabs to force horizontal overflow.
+  test('Switching to an overflowed tab scrolls it into view', async() => {
+    const launch = await launchWithMarkdown('# overflow base\n')
+    const sApp = launch.app
+    const sPage = launch.page
+    try {
+      // Open enough untitled tabs to overflow the tab strip horizontally,
+      // regardless of the test window width.
+      const TAB_COUNT = 25
+      for (let i = 0; i < TAB_COUNT; i++) {
+        const before = await sPage.locator(tabSelector).count()
+        await sendIpcToRenderer(sApp, 'mt::new-untitled-tab', true, `overflow body ${i}\n`)
+        await sPage.waitForFunction(
+          ({ selector, prev }) => document.querySelectorAll(selector).length > prev,
+          { selector: tabSelector, prev: before },
+          { timeout: 5000 }
+        )
+      }
+
+      // The strip must genuinely overflow, otherwise the assertions below are
+      // vacuously true.
+      await expect
+        .poll(
+          () =>
+            sPage.evaluate(() => {
+              const c = document.querySelector('.scrollable-tabs') as HTMLElement | null
+              return !!c && c.scrollWidth > c.clientWidth + 4
+            }),
+          { timeout: 5000 }
+        )
+        .toBe(true)
+
+      // The active tab's box must sit fully inside the scroll viewport.
+      const activeTabVisible = () =>
+        sPage.evaluate(() => {
+          const container = document.querySelector('.scrollable-tabs')
+          const tab = document.querySelector('.tabs-container > li.active')
+          if (!container || !tab) return false
+          const c = container.getBoundingClientRect()
+          const t = tab.getBoundingClientRect()
+          return t.width > 0 && t.left >= c.left - 1 && t.right <= c.right + 1
+        })
+
+      // Far-left tab: must be brought into view.
+      await sendIpcToRenderer(sApp, 'mt::switch-tab-by-index', 0)
+      await expect.poll(activeTabVisible, { timeout: 5000 }).toBe(true)
+
+      // Far-right (last) tab: at scrollLeft 0 it is off the right edge — the
+      // regression. Switching to it must scroll the strip so it's visible.
+      const ids = await readTabIds(sPage)
+      await sendIpcToRenderer(sApp, 'mt::switch-tab-by-index', ids.length - 1)
+      await expect.poll(activeTabVisible, { timeout: 5000 }).toBe(true)
+
+      // Back to the first tab: must scroll left again.
+      await sendIpcToRenderer(sApp, 'mt::switch-tab-by-index', 0)
+      await expect.poll(activeTabVisible, { timeout: 5000 }).toBe(true)
+    } finally {
+      await sApp.close()
+    }
+  })
+
   // Item 267 — the tab context-menu "close others / close saved / close all"
   // survivor sets. Driven through the live `editor` store actions (the bus
   // events delegate verbatim to these; the native context menu / mitt bus are
diff --git a/packages/desktop/test/unit/specs/encoding.spec.ts b/packages/desktop/test/unit/specs/encoding.spec.ts
new file mode 100644
index 0000000000..613f0bd506
--- /dev/null
+++ b/packages/desktop/test/unit/specs/encoding.spec.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// `ced` (compact_enc_det) occasionally misdetects a valid UTF-8 file as a legacy
+// double-byte encoding, mojibaking multi-byte text — e.g. Greek µ/κ/α become CJK
+// 碌/魏/伪 (#3151). Simulate that by forcing `ced` to always answer GBK; the fix
+// must override it whenever the bytes are valid UTF-8.
+vi.mock('ced', () => ({ default: vi.fn(() => 'GB') }))
+
+const { guessEncoding } = await import('main_renderer/filesystem/encoding')
+
+describe('guessEncoding — prefer UTF-8 over a ced misdetection (#3151)', () => {
+  it('returns utf8 for a valid UTF-8 buffer even when ced guesses GBK', () => {
+    const buffer = Buffer.from('# Notes\n\nµ = 0.5, κ, α — Greek letters.\n', 'utf8')
+    expect(guessEncoding(buffer, true).encoding).toBe('utf8')
+  })
+
+  it('still falls back to ced for a genuinely non-UTF-8 buffer', () => {
+    // `0xC2` is a UTF-8 lead byte; the following space is not a continuation
+    // byte, so the buffer is not valid UTF-8 and ced's guess stands.
+    const buffer = Buffer.from([0x68, 0x69, 0xc2, 0x20, 0x6f, 0x6b])
+    expect(guessEncoding(buffer, true).encoding).toBe('gb2312')
+  })
+
+  it('does not force utf8 for a buffer containing NUL (binary / BOM-less UTF-16)', () => {
+    const buffer = Buffer.from([0x68, 0x00, 0x65, 0x00, 0x6c, 0x00])
+    expect(guessEncoding(buffer, true).encoding).not.toBe('utf8')
+  })
+
+  it('honours a UTF-8 BOM and never reaches ced', () => {
+    const buffer = Buffer.from([0xef, 0xbb, 0xbf, 0x68, 0x69])
+    const result = guessEncoding(buffer, true)
+    expect(result.encoding).toBe('utf8')
+    expect(result.isBom).toBe(true)
+  })
+})
diff --git a/packages/desktop/test/unit/specs/i18n.spec.ts b/packages/desktop/test/unit/specs/i18n.spec.ts
index dec7f53ccf..1b0b916274 100644
--- a/packages/desktop/test/unit/specs/i18n.spec.ts
+++ b/packages/desktop/test/unit/specs/i18n.spec.ts
@@ -46,3 +46,46 @@ describe('renderer i18n language loading', () => {
     expect(win.i18nUtils!.loadTranslations).toHaveBeenCalledWith('zh-CN')
   })
 })
+
+// Issue #4046: exporting HTML/PDF surfaced an "Unexpected renderer process
+// error" — a vue-i18n message-compiler SyntaxError (code 9,
+// NOT_ALLOW_NEST_PLACEHOLDER) thrown while lazily compiling a translation whose
+// value contained a nested placeholder (e.g. literal `{{type}}`). A single
+// malformed translation must degrade to raw text, never crash the renderer.
+describe('renderer i18n malformed-message resilience (issue #4046)', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    win.i18nUtils = { loadTranslations: vi.fn() }
+  })
+
+  afterEach(() => {
+    delete win.i18nUtils
+  })
+
+  interface TestComposer {
+    setLocaleMessage: (locale: string, message: Record<string, unknown>) => void
+    locale: { value: string }
+    t: (key: string, named?: Record<string, unknown>) => string
+  }
+
+  it('does not throw when a registered message contains a nested placeholder', async() => {
+    const { i18n } = await import('../../../src/renderer/src/i18n')
+    const composer = i18n.global as unknown as TestComposer
+
+    composer.setLocaleMessage('xx', { export: { failed: 'Failed {{type}} export' } })
+    composer.locale.value = 'xx'
+
+    expect(() => composer.t('export.failed', { type: 'PDF' })).not.toThrow()
+    expect(composer.t('export.failed', { type: 'PDF' })).toBe('Failed {{type}} export')
+  })
+
+  it('still interpolates well-formed messages', async() => {
+    const { i18n } = await import('../../../src/renderer/src/i18n')
+    const composer = i18n.global as unknown as TestComposer
+
+    composer.setLocaleMessage('xx', { greeting: 'Hello {name}' })
+    composer.locale.value = 'xx'
+
+    expect(composer.t('greeting', { name: 'World' })).toBe('Hello World')
+  })
+})
diff --git a/packages/muya/src/assets/styles/blockSyntax.css b/packages/muya/src/assets/styles/blockSyntax.css
index 83a0b392b5..7291952a57 100644
--- a/packages/muya/src/assets/styles/blockSyntax.css
+++ b/packages/muya/src/assets/styles/blockSyntax.css
@@ -490,23 +490,31 @@ li.mu-task-list-item {
 li.mu-task-list-item > input[type='checkbox'],
 li.mu-task-list-item > span.mu-task-list-checkbox {
     position: absolute;
-    top: 0.3em;
-    inset-inline-start: -23px;
+
+    /* Center the 18px circle (drawn by ::before at top:-2px, so its center sits
+       7px below this box's top) on the first text line, whose vertical midpoint
+       is `0.5 * line-height * font-size`. The editor font is read from
+       `--mu-font-size` rather than `em` on purpose: on Chromium the checkbox is
+       a real <input>, which keeps the UA form-control font size and ignores
+       `font-size: inherit`, so `em` here would be frozen and the marker would
+       stop tracking the editor font. Custom properties still inherit into the
+       input, so this stays aligned at every font size. */
+    top: calc(var(--mu-line-height, 1.6) * 0.5 * var(--mu-font-size, 16px) - 7px);
 
     width: 12px;
     height: 12px;
 
+    /* Drop the UA <input> margin (3px top), which otherwise pushes the
+       absolutely-positioned marker below the computed `top`. */
+    margin: 0;
+
     transform-origin: center;
     cursor: pointer;
 
     transition: all 0.2s ease;
 
     appearance: none;
-}
-
-ul.mu-tight-list > li.mu-task-list-item > input[type='checkbox'],
-ul.mu-tight-list > li.mu-task-list-item > span.mu-task-list-checkbox {
-    top: 0.3em;
+    inset-inline-start: -23px;
 }
 
 li.mu-task-list-item > input.mu-checkbox-checked ~ *,
@@ -721,6 +729,14 @@ figure.mu-diagram-block .mu-diagram-preview {
 figure.mu-math-block .mu-math-preview .katex-display {
     margin: 0;
     padding: 1em 0;
+
+    overflow: auto hidden;
+}
+
+figure.mu-math-block .mu-math-preview .katex-display::-webkit-scrollbar {
+    display: block;
+    width: 3px;
+    height: 6px;
 }
 
 /* to prevent plantuml img overflow */
diff --git a/packages/muya/src/block/base/__tests__/imeTabComposition.spec.ts b/packages/muya/src/block/base/__tests__/imeTabComposition.spec.ts
new file mode 100644
index 0000000000..9d8469e299
--- /dev/null
+++ b/packages/muya/src/block/base/__tests__/imeTabComposition.spec.ts
@@ -0,0 +1,80 @@
+// @vitest-environment happy-dom
+
+import type Format from '../format';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Muya } from '../../../muya';
+
+// #1250 — pressing Tab while an IME composition is active (e.g. cycling
+// Japanese candidates) must reach the IME, not run the editor's tabHandler.
+// keydownHandler already guards Enter and the arrow keys with `!isComposed`;
+// Tab was missing the same guard and inserted indentation mid-composition.
+
+const bootedHosts: HTMLElement[] = [];
+let originalVersion: string | undefined;
+let hadVersion = false;
+
+beforeEach(() => {
+    hadVersion = 'MUYA_VERSION' in window;
+    originalVersion = window.MUYA_VERSION;
+    window.MUYA_VERSION = 'test';
+});
+
+afterEach(() => {
+    while (bootedHosts.length) {
+        const host = bootedHosts.pop()!;
+        host.remove();
+    }
+    document.getSelection()?.removeAllRanges();
+    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 Muya(host, { markdown } as ConstructorParameters<typeof Muya>[1]);
+    muya.init();
+    bootedHosts.push(muya.domNode);
+    return muya;
+}
+
+function firstBlock(muya: Muya): Format {
+    const content = muya.editor.scrollPage!.firstContentInDescendant() as unknown as Format;
+    muya.editor.activeContentBlock = content as never;
+    return content;
+}
+
+function pressTab(content: Format): KeyboardEvent {
+    const event = new KeyboardEvent('keydown', { key: 'Tab', bubbles: true, cancelable: true });
+    content.keydownHandler(event);
+    return event;
+}
+
+describe('tab during IME composition (#1250)', () => {
+    it('does not run tabHandler while composing — Tab is left to the IME', () => {
+        const muya = bootMuya('hello\n');
+        const content = firstBlock(muya);
+        content.setCursor(0, 5);
+        content.composeHandler(new Event('compositionstart'));
+        const tabHandler = vi.spyOn(content, 'tabHandler');
+
+        const event = pressTab(content);
+
+        expect(tabHandler).not.toHaveBeenCalled();
+        expect(event.defaultPrevented).toBe(false);
+        expect(content.text).toBe('hello');
+    });
+
+    it('runs tabHandler normally when not composing', () => {
+        const muya = bootMuya('hello\n');
+        const content = firstBlock(muya);
+        content.setCursor(0, 5);
+        const tabHandler = vi.spyOn(content, 'tabHandler');
+
+        pressTab(content);
+
+        expect(tabHandler).toHaveBeenCalled();
+    });
+});
diff --git a/packages/muya/src/block/base/content.ts b/packages/muya/src/block/base/content.ts
index 2892eaa01d..593ff19188 100644
--- a/packages/muya/src/block/base/content.ts
+++ b/packages/muya/src/block/base/content.ts
@@ -746,7 +746,9 @@ class Content extends TreeNode {
                 break;
 
             case EVENT_KEYS.Tab:
-                this.tabHandler(event);
+                if (!this.isComposed)
+                    this.tabHandler(event);
+
                 break;
             default:
                 break;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 97c2ed677f..51b617fcde 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -66,6 +66,9 @@ importers:
       '@hfelix/electron-localshortcut':
         specifier: ^4.0.1
         version: 4.0.1
+      '@intlify/core-base':
+        specifier: ^11.4.6
+        version: 11.4.6
       '@marktext/file-icons':
         specifier: ^1.0.6
         version: 1.0.6