Guard shortcuts during text composition

src/components/ui/SqlEditorWrapper.tsx

@@ -15,6 +15,7 @@ import {
   type Statement,
 } from "../../utils/sqlSplitter";
 import { formatSql } from "../../utils/sqlFormat";
+import { isTextCompositionKeyEvent } from "../../utils/keyboardEvents";
 import type { SqlDialect } from "../../utils/sql";
 import type { RunContext } from "../../utils/runTarget";
 import {
@@ -403,6 +404,8 @@ const SqlEditorInternal = ({
       // Monaco binds Ctrl+Shift+A to block comments on Linux. Handle the
       // user-configurable palette shortcut before Monaco consumes it.
       editor.onKeyDown((e) => {
+        if (isTextCompositionKeyEvent(e.browserEvent)) return;
+
         const togglePalette = togglePaletteRef.current;
         if (
           togglePalette &&

src/hooks/useGlobalShortcuts.ts

@@ -3,6 +3,7 @@ import { useNavigate } from "react-router-dom";
 import { useCommandPaletteDispatch } from "./useCommandPalette";
 import { useConnectionManager } from "./useConnectionManager";
 import { useKeybindings } from "./useKeybindings";
+import { isTextCompositionKeyEvent } from "../utils/keyboardEvents";
 
 /** Shortcuts that must still fire while the user is typing in a field. */
 const TYPING_SAFE_SHORTCUTS = [
@@ -24,6 +25,8 @@ export function useGlobalShortcuts() {
 
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
+      if (isTextCompositionKeyEvent(e)) return;
+
       const target = e.target as HTMLElement;
       const isTypingTarget =
         target.tagName === "INPUT" ||

src/utils/keyboardEvents.ts

@@ -0,0 +1,9 @@
+export function isTextCompositionKeyEvent(event: KeyboardEvent): boolean {
+  return (
+    event.isComposing ||
+    event.key === "Dead" ||
+    event.key === "Process" ||
+    event.key === "Unidentified" ||
+    event.keyCode === 229
+  );
+}

tests/components/ui/SqlEditorWrapper.test.tsx

@@ -390,6 +390,38 @@ describe('SqlEditorWrapper', () => {
     expect(trigger).not.toHaveBeenCalled();
   });
 
+  it('does not intercept composing editor key events as palette shortcuts', () => {
+    matchesShortcutMock.mockImplementation(
+      (_event, id) => id === 'command_palette_actions',
+    );
+    render(
+      <SqlEditorWrapper
+        initialValue=""
+        onChange={mockOnChange}
+        onRun={mockOnRun}
+        editorKey="palette-composition"
+      />,
+      { wrapper }
+    );
+    const { keyDownHandlers } = mountCapturedEditor();
+    const event = {
+      browserEvent: new KeyboardEvent('keydown', {
+        key: 'a',
+        ctrlKey: true,
+        shiftKey: true,
+        isComposing: true,
+      }),
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+    };
+
+    keyDownHandlers[0](event);
+
+    expect(event.preventDefault).not.toHaveBeenCalled();
+    expect(event.stopPropagation).not.toHaveBeenCalled();
+    expect(togglePaletteMock).not.toHaveBeenCalled();
+  });
+
   it('renders without a command palette provider and leaves its shortcut to Monaco', () => {
     matchesShortcutMock.mockImplementation(
       (_event, id) => id === 'command_palette_actions',

tests/hooks/useGlobalShortcuts.test.ts

@@ -58,6 +58,39 @@ describe("useGlobalShortcuts", () => {
     input.remove();
   });
 
+  it("ignores composing key events while focus is inside an input", () => {
+    renderHook(() => useGlobalShortcuts());
+    const input = document.createElement("input");
+    document.body.appendChild(input);
+    input.focus();
+
+    fireEvent.keyDown(input, {
+      key: "a",
+      metaKey: true,
+      shiftKey: true,
+      isComposing: true,
+    });
+
+    expect(togglePaletteMock).not.toHaveBeenCalled();
+    input.remove();
+  });
+
+  it("ignores dead-key events while focus is inside an input", () => {
+    renderHook(() => useGlobalShortcuts());
+    const input = document.createElement("input");
+    document.body.appendChild(input);
+    input.focus();
+
+    fireEvent.keyDown(input, {
+      key: "Dead",
+      metaKey: true,
+      shiftKey: true,
+    });
+
+    expect(togglePaletteMock).not.toHaveBeenCalled();
+    input.remove();
+  });
+
   it("should open object search through the shared palette controller", () => {
     activeShortcutId = "quick_navigator";
     renderHook(() => useGlobalShortcuts());

tests/utils/keyboardEvents.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { isTextCompositionKeyEvent } from "../../src/utils/keyboardEvents";
+
+describe("keyboardEvents", () => {
+  describe("isTextCompositionKeyEvent", () => {
+    it("detects active IME composition", () => {
+      const event = new KeyboardEvent("keydown", { key: "a", isComposing: true });
+      expect(isTextCompositionKeyEvent(event)).toBe(true);
+    });
+
+    it("detects dead keys", () => {
+      const event = new KeyboardEvent("keydown", { key: "Dead" });
+      expect(isTextCompositionKeyEvent(event)).toBe(true);
+    });
+
+    it("detects IME process keys", () => {
+      const event = new KeyboardEvent("keydown", { key: "Process" });
+      expect(isTextCompositionKeyEvent(event)).toBe(true);
+    });
+
+    it("detects unidentified keys", () => {
+      const event = new KeyboardEvent("keydown", { key: "Unidentified" });
+      expect(isTextCompositionKeyEvent(event)).toBe(true);
+    });
+
+    it("detects legacy IME keyCode 229", () => {
+      const event = new KeyboardEvent("keydown", { key: "a", keyCode: 229 } as KeyboardEventInit);
+      expect(isTextCompositionKeyEvent(event)).toBe(true);
+    });
+
+    it("lets ordinary shortcut key events through", () => {
+      const event = new KeyboardEvent("keydown", {
+        key: "p",
+        ctrlKey: true,
+        shiftKey: true,
+      });
+      expect(isTextCompositionKeyEvent(event)).toBe(false);
+    });
+  });
+});