Merge branch 'main' into feat/browser-reserved-shortcut-warnings

Verifies that Ctrl+A select-all works when event.key is an Arabic
character but event.code is KeyA, proving resolveKeyFromEvent
correctly uses the physical key code.

browser_tests/tests/keybindingBrowserReserved.spec.ts

@@ -0,0 +1,64 @@
+import { expect } from '@playwright/test'
+
+import { comfyPageFixture as test } from '../fixtures/ComfyPage'
+
+test.beforeEach(async ({ comfyPage }) => {
+  await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Disabled')
+})
+
+test.describe(
+  'Keybinding non-Latin keyboard layout support',
+  { tag: '@keyboard' },
+  () => {
+    test('Ctrl+A selects all nodes on a non-Latin keyboard layout', async ({
+      comfyPage
+    }) => {
+      const { page } = comfyPage
+
+      // Baseline: standard US layout Ctrl+A select-all works
+      await comfyPage.workflow.loadWorkflow('default')
+      await expect
+        .poll(() => comfyPage.nodeOps.getGraphNodesCount())
+        .toBeGreaterThan(0)
+
+      await comfyPage.canvas.press('Control+a')
+      await expect
+        .poll(() => comfyPage.nodeOps.getSelectedGraphNodesCount())
+        .toBeGreaterThan(0)
+      await comfyPage.canvas.press('Delete')
+      await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0)
+
+      // Non-Latin layout: dispatch a keydown with Arabic key but US code.
+      // On an Arabic keyboard layout, pressing the physical 'A' key produces
+      // 'ش' as event.key, but event.code remains 'KeyA'.
+      // The fix in resolveKeyFromEvent uses event.code to resolve the
+      // physical key, so Ctrl+A should still trigger select-all.
+      await comfyPage.workflow.loadWorkflow('default')
+      await expect
+        .poll(() => comfyPage.nodeOps.getGraphNodesCount())
+        .toBeGreaterThan(0)
+
+      // Dispatch from the canvas container so composedPath includes it
+      // (the keybinding service checks targetElementId containment).
+      await page.evaluate(() => {
+        const canvas = document.getElementById('graph-canvas-container')
+        canvas?.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ش',
+            code: 'KeyA',
+            ctrlKey: true,
+            bubbles: true,
+            cancelable: true
+          })
+        )
+      })
+
+      await expect
+        .poll(() => comfyPage.nodeOps.getSelectedGraphNodesCount())
+        .toBeGreaterThan(0)
+
+      await comfyPage.canvas.press('Delete')
+      await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0)
+    })
+  }
+)

src/components/dialog/content/setting/keybinding/EditKeybindingContent.vue

@@ -13,8 +13,12 @@
       :placeholder="$t('g.enterYourKeybind')"
       :aria-label="$t('g.enterYourKeybind')"
       autocomplete="off"
+      readonly
       autofocus
       @keydown.stop.prevent="captureKeybinding"
+      @compositionstart.prevent
+      @compositionupdate.prevent
+      @compositionend.prevent
     />
     <div class="min-h-12">
       <p

src/components/dialog/content/setting/keybinding/EditKeybindingFooter.vue

@@ -62,8 +62,6 @@ async function handleSave() {
   const commandId = dialogState.commandId
   if (!combo || !commandId) return
 
-  dialogStore.closeDialog({ key: DIALOG_KEY })
-
   if (dialogState.mode === 'add') {
     keybindingStore.addUserKeybinding(new KeybindingImpl({ commandId, combo }))
   } else if (dialogState.existingBinding) {
@@ -77,5 +75,6 @@ async function handleSave() {
     )
   }
   await keybindingService.persistUserKeybindings()
+  dialogStore.closeDialog({ key: DIALOG_KEY })
 }
 </script>

src/platform/keybindings/defaults.ts

@@ -99,7 +99,7 @@ export const CORE_KEYBINDINGS: Keybinding[] = [
   },
   {
     combo: {
-      key: '+',
+      key: '=',
       alt: true,
       shift: true
     },

src/platform/keybindings/keyCombo.test.ts

@@ -3,6 +3,142 @@ import { describe, expect, it } from 'vitest'
 import { KeyComboImpl } from './keyCombo'
 
 describe('KeyComboImpl', () => {
+  describe('fromEvent resolves physical key from event.code', () => {
+    function mockKeyEvent(overrides: Partial<KeyboardEvent>): KeyboardEvent {
+      return {
+        key: '',
+        code: '',
+        ctrlKey: false,
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        ...overrides
+      } as KeyboardEvent
+    }
+
+    it.each([
+      { key: 'µ', code: 'KeyM', expected: 'm' },
+      { key: 'ß', code: 'KeyS', expected: 's' },
+      { key: 'å', code: 'KeyA', expected: 'a' }
+    ])(
+      'resolves Alt+$code to "$expected" instead of "$key" (macOS)',
+      ({ key, code, expected }) => {
+        const combo = KeyComboImpl.fromEvent(
+          mockKeyEvent({ key, code, altKey: true })
+        )
+        expect(combo.key).toBe(expected)
+        expect(combo.alt).toBe(true)
+      }
+    )
+
+    it.each([
+      { key: '¡', code: 'Digit1', expected: '1' },
+      { key: '€', code: 'Digit2', expected: '2' }
+    ])(
+      'resolves digit Alt+$code to "$expected" instead of "$key" (macOS)',
+      ({ key, code, expected }) => {
+        const combo = KeyComboImpl.fromEvent(
+          mockKeyEvent({ key, code, altKey: true })
+        )
+        expect(combo.key).toBe(expected)
+        expect(combo.alt).toBe(true)
+      }
+    )
+
+    it.each([
+      { key: '≤', code: 'Comma', expected: ',' },
+      { key: '≥', code: 'Period', expected: '.' },
+      { key: '\u2019', code: 'BracketRight', expected: ']' },
+      { key: '`', code: 'Backquote', expected: '`' },
+      { key: '–', code: 'Minus', expected: '-' },
+      { key: '≠', code: 'Equal', expected: '=' }
+    ])(
+      'resolves punctuation Alt+$code to "$expected" instead of "$key" (macOS)',
+      ({ key, code, expected }) => {
+        const combo = KeyComboImpl.fromEvent(
+          mockKeyEvent({ key, code, altKey: true })
+        )
+        expect(combo.key).toBe(expected)
+        expect(combo.alt).toBe(true)
+      }
+    )
+
+    it.each([
+      { key: 'ы', code: 'KeyS', expected: 's', label: 'Ctrl+S Russian' },
+      { key: 'я', code: 'KeyZ', expected: 'z', label: 'Ctrl+Z Russian' },
+      { key: 'с', code: 'KeyC', expected: 'c', label: 'Meta+C Russian' }
+    ])(
+      'resolves $label to "$expected" instead of "$key" (non-English layout)',
+      ({ key, code, expected, label }) => {
+        const useMeta = label.includes('Meta')
+        const combo = KeyComboImpl.fromEvent(
+          mockKeyEvent({
+            key,
+            code,
+            ctrlKey: !useMeta,
+            metaKey: useMeta
+          })
+        )
+        expect(combo.key).toBe(expected)
+        expect(combo.ctrl).toBe(true)
+      }
+    )
+
+    it.each([
+      { key: 'к', code: 'KeyR', expected: 'r', label: 'Russian R' },
+      { key: 'س', code: 'KeyS', expected: 's', label: 'Arabic S' }
+    ])(
+      'resolves no-modifier $label to "$expected" (non-Latin layout)',
+      ({ key, code, expected }) => {
+        const combo = KeyComboImpl.fromEvent(mockKeyEvent({ key, code }))
+        expect(combo.key).toBe(expected)
+      }
+    )
+
+    it('resolves no-modifier punctuation from code', () => {
+      const combo = KeyComboImpl.fromEvent(
+        mockKeyEvent({ key: '.', code: 'Period' })
+      )
+      expect(combo.key).toBe('.')
+    })
+
+    it('resolves Shift+digit from code (Shift+1 → key="1", shift=true)', () => {
+      const combo = KeyComboImpl.fromEvent(
+        mockKeyEvent({ key: '!', code: 'Digit1', shiftKey: true })
+      )
+      expect(combo.key).toBe('1')
+      expect(combo.shift).toBe(true)
+    })
+
+    it('resolves Ctrl+Alt US International accented char from code', () => {
+      const combo = KeyComboImpl.fromEvent(
+        mockKeyEvent({ key: 'á', code: 'KeyA', ctrlKey: true, altKey: true })
+      )
+      expect(combo.key).toBe('a')
+      expect(combo.ctrl).toBe(true)
+      expect(combo.alt).toBe(true)
+    })
+
+    it('falls through to event.key for unmapped codes like Numpad', () => {
+      const combo = KeyComboImpl.fromEvent(
+        mockKeyEvent({ key: '+', code: 'NumpadAdd' })
+      )
+      expect(combo.key).toBe('+')
+    })
+
+    it('falls through to event.key for special keys', () => {
+      const combo = KeyComboImpl.fromEvent(
+        mockKeyEvent({ key: 'Enter', code: 'Enter' })
+      )
+      expect(combo.key).toBe('Enter')
+    })
+
+    it('falls through to event.key when code is empty', () => {
+      const combo = KeyComboImpl.fromEvent(mockKeyEvent({ key: 'a', code: '' }))
+      expect(combo.key).toBe('a')
+    })
+  })
+
   describe('isBrowserReserved', () => {
     it.each([
       { key: 't', ctrl: true, label: 'Ctrl + t' },

src/platform/keybindings/keyCombo.ts

@@ -18,7 +18,7 @@ export class KeyComboImpl implements KeyCombo {
 
   static fromEvent(event: KeyboardEvent) {
     return new KeyComboImpl({
-      key: event.key,
+      key: resolveKeyFromEvent(event),
       ctrl: event.ctrlKey || event.metaKey,
       alt: event.altKey,
       shift: event.shiftKey
@@ -89,6 +89,44 @@ export class KeyComboImpl implements KeyCombo {
   }
 }
 
+const CODE_TO_KEY: Record<string, string> = {
+  Comma: ',',
+  Period: '.',
+  Slash: '/',
+  Backslash: '\\',
+  BracketLeft: '[',
+  BracketRight: ']',
+  Semicolon: ';',
+  Quote: "'",
+  Backquote: '`',
+  Minus: '-',
+  Equal: '='
+}
+
+/**
+ * Always resolve the physical key from event.code when available.
+ *
+ * Like VS Code's FallbackKeyboardMapper, keybindings are bound to physical
+ * key positions (US layout), not the characters they produce. This ensures
+ * shortcuts work on any keyboard layout:
+ * - Non-Latin layouts (Russian, Arabic): physical 'R' fires 'к'/'ق' in
+ *   event.key, but event.code is always 'KeyR' → resolved to 'r'
+ * - macOS Alt produces special chars (Alt+M → µ): resolved from code
+ * - US International Ctrl+Alt combos produce accented chars (Ctrl+Alt+A → á)
+ *
+ * Keys not in the mapping (Enter, Escape, F-keys, arrows, numpad) fall
+ * through to event.key, which is locale-independent for these keys.
+ */
+function resolveKeyFromEvent(event: KeyboardEvent): string {
+  if (event.code) {
+    const { code } = event
+    if (code.startsWith('Key')) return code.slice(3).toLowerCase()
+    if (code.startsWith('Digit')) return code.slice(5)
+    if (code in CODE_TO_KEY) return CODE_TO_KEY[code]
+  }
+  return event.key
+}
+
 function toNormalizedString(combo: KeyComboImpl): string {
   const sequences: string[] = []
   if (combo.ctrl) sequences.push('Ctrl')