@theia/core 1.77.0-next.56 → 1.77.0-next.57

package/lib/browser/keybinding.spec.js

@@ -19,7 +19,12 @@ const tslib_1 = require("tslib");
 const jsdom_1 = require("./test/jsdom");
 let disableJSDOM = (0, jsdom_1.enableJSDOM)();
 const frontend_application_config_provider_1 = require("./frontend-application-config-provider");
-frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
+try {
+    frontend_application_config_provider_1.FrontendApplicationConfigProvider.get();
+}
+catch {
+    frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
+}
 const inversify_1 = require("inversify");
 const contribution_provider_1 = require("../common/contribution-provider");
 const keyboard_layout_provider_1 = require("../common/keyboard/keyboard-layout-provider");
@@ -42,19 +47,63 @@ const markdown_renderer_1 = require("./markdown-rendering/markdown-renderer");
 const status_bar_1 = require("./status-bar");
 disableJSDOM();
 const expect = chai.expect;
+function testKeyboardEvent(input = {}) {
+    let defaultPrevented = false;
+    return {
+        key: input.key,
+        code: input.code,
+        keyCode: input.keyCode,
+        ctrlKey: input.ctrlKey,
+        shiftKey: input.shiftKey,
+        altKey: input.altKey,
+        metaKey: input.metaKey,
+        repeat: input.repeat,
+        isComposing: input.isComposing,
+        location: input.location,
+        timeStamp: input.timeStamp,
+        target: input.target,
+        get defaultPrevented() { return defaultPrevented; },
+        preventDefault() { defaultPrevented = true; },
+        stopPropagation() { }
+    };
+}
 let keybindingRegistry;
 let commandRegistry;
 let testContainer;
 let stub;
+const preferenceChanged = new event_1.Emitter();
+const corePreferences = {
+    'keyboard.dispatch': 'code',
+    onPreferenceChanged: preferenceChanged.event
+};
+const RUSSIAN_LAYOUT = {
+    info: { id: 'ru', lang: 'ru' },
+    mapping: {
+        KeyA: { value: 'ф', withShift: 'Ф', withAltGr: '', withShiftAltGr: '' },
+        KeyC: { value: 'с', withShift: 'С', withAltGr: '', withShiftAltGr: '' },
+        KeyE: { value: 'у', withShift: 'У', withAltGr: '€', withShiftAltGr: '' },
+        KeyV: { value: 'м', withShift: 'М', withAltGr: '', withShiftAltGr: '' },
+        KeyS: { value: 'ы', withShift: 'Ы', withAltGr: '', withShiftAltGr: '' },
+        Digit8: { value: '8', withShift: '*', withAltGr: '', withShiftAltGr: '' },
+        BracketLeft: { value: 'х', withShift: 'Х', withAltGr: '', withShiftAltGr: '' },
+        Comma: { value: 'б', withShift: 'Б', withAltGr: '', withShiftAltGr: '' }
+    }
+};
 before(async () => {
-    disableJSDOM = (0, jsdom_1.enableJSDOM)();
     testContainer = new inversify_1.Container();
     const module = new inversify_1.ContainerModule((bind, unbind, isBound, rebind) => {
         /* Mock logger binding*/
         bind(logger_1.ILogger).to(mock_logger_1.MockLogger);
         bind(keyboard_layout_service_1.KeyboardLayoutService).toSelf().inSingletonScope();
         bind(MockKeyboardLayoutProvider).toSelf().inSingletonScope();
-        bind(keyboard_layout_provider_1.KeyboardLayoutProvider).toService(MockKeyboardLayoutProvider);
+        bind(keyboard_layout_provider_1.KeyboardLayoutProvider).toDynamicValue(ctx => {
+            const provider = ctx.container.get(MockKeyboardLayoutProvider);
+            return new Proxy(provider, {
+                get: (target, property) => property === 'then' ? undefined
+                    : property === 'layoutSource' ? 'navigator.keyboard'
+                        : property in target ? Reflect.get(target, property) : () => undefined
+            });
+        });
         bind(MockKeyboardLayoutChangeNotifier).toSelf().inSingletonScope();
         bind(keyboard_layout_provider_1.KeyboardLayoutChangeNotifier).toService(MockKeyboardLayoutChangeNotifier);
         (0, contribution_provider_1.bindContributionProvider)(bind, keybinding_1.KeybindingContext);
@@ -70,7 +119,10 @@ before(async () => {
                 return true;
             }
         });
-        bind(status_bar_1.StatusBar).toConstantValue({});
+        bind(status_bar_1.StatusBar).toConstantValue({
+            setElement: () => Promise.resolve(),
+            removeElement: () => Promise.resolve()
+        });
         bind(markdown_renderer_1.MarkdownRendererImpl).toSelf().inSingletonScope();
         bind(markdown_renderer_1.MarkdownRenderer).toService(markdown_renderer_1.MarkdownRendererImpl);
         bind(markdown_renderer_1.MarkdownRendererFactory).toFactory(({ container }) => () => container.get(markdown_renderer_1.MarkdownRenderer));
@@ -78,23 +130,28 @@ before(async () => {
         bind(label_parser_1.LabelParser).toSelf().inSingletonScope();
         bind(context_key_service_1.ContextKeyService).to(MockContextKeyService).inSingletonScope();
         bind(frontend_application_state_1.FrontendApplicationStateService).toSelf().inSingletonScope();
-        bind(core_preferences_1.CorePreferences).toConstantValue({});
+        bind(core_preferences_1.CorePreferences).toConstantValue(corePreferences);
         (0, frontend_application_bindings_1.bindPreferenceService)(bind);
     });
     testContainer.load(module);
     commandRegistry = testContainer.get(command_1.CommandRegistry);
     commandRegistry.onStart();
 });
-after(() => {
-    disableJSDOM();
-});
-beforeEach(async () => {
+beforeEach(async function () {
+    if (this.currentTest?.file?.endsWith('keybinding.spec.js')) {
+        disableJSDOM();
+        disableJSDOM = (0, jsdom_1.enableJSDOM)();
+    }
     stub = sinon.stub(os, 'isOSX').value(false);
     keybindingRegistry = testContainer.get(keybinding_1.KeybindingRegistry);
+    corePreferences['keyboard.dispatch'] = 'code';
     await keybindingRegistry.onStart();
 });
-afterEach(() => {
+afterEach(function () {
     stub.restore();
+    if (this.currentTest?.file?.endsWith('keybinding.spec.js')) {
+        disableJSDOM();
+    }
 });
 describe('keybindings', () => {
     it('should register the default keybindings', () => {
@@ -278,7 +335,7 @@ describe('keybindings', () => {
         match = keybindingRegistry.matchKeybinding([keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_B, modifiers: [keys_1.KeyModifier.CtrlCmd] })]);
         expect(match && match.kind).to.be.equal('full');
         match = keybindingRegistry.matchKeybinding([keys_1.KeyCode.createKeyCode({ first: keys_1.Key.KEY_C, modifiers: [keys_1.KeyModifier.CtrlCmd] })]);
-        const keyCode = match && keys_1.KeyCode.parse(match.binding.keybinding);
+        const keyCode = match && keys_1.KeyCode.parse(match.runtime.binding.keybinding);
         expect(keyCode?.key).to.be.equal(validKeyCode.key);
     });
     it('should return partial keybinding matches', () => {
@@ -334,19 +391,19 @@ describe('keybindings', () => {
         keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [userBinding]);
         keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.WORKSPACE, [workspaceBinding]);
         // now WORKSPACE bindings are overriding the other scopes
-        let match = keybindingRegistry.matchKeybinding([keyCode]);
+        let match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(workspaceBinding));
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal(workspaceBinding.command);
+        expect(match?.runtime.binding?.command).to.be.equal(workspaceBinding.command);
         keybindingRegistry.resetKeybindingsForScope(keybinding_1.KeybindingScope.WORKSPACE);
         // now it should find USER bindings
-        match = keybindingRegistry.matchKeybinding([keyCode]);
+        match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(userBinding));
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal(userBinding.command);
+        expect(match?.runtime.binding?.command).to.be.equal(userBinding.command);
         keybindingRegistry.resetKeybindingsForScope(keybinding_1.KeybindingScope.USER);
         // and finally it should fallback to DEFAULT bindings.
-        match = keybindingRegistry.matchKeybinding([keyCode]);
+        match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal(defaultBinding.command);
+        expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
         keybindingRegistry.resetKeybindingsForScope(keybinding_1.KeybindingScope.DEFAULT);
         // now the registry should be empty
         match = keybindingRegistry.matchKeybinding([keyCode]);
@@ -363,16 +420,676 @@ describe('keybindings', () => {
             command: '-test.workspace-command'
         };
         keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.DEFAULT, [defaultBinding]);
-        let match = keybindingRegistry.matchKeybinding([keyCode]);
+        let match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal(defaultBinding.command);
+        expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
         keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [disableDefaultBinding]);
-        match = keybindingRegistry.matchKeybinding([keyCode]);
+        match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
         expect(match).to.be.undefined;
         keybindingRegistry.resetKeybindingsForScope(keybinding_1.KeybindingScope.USER);
-        match = keybindingRegistry.matchKeybinding([keyCode]);
+        match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(defaultBinding));
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal(defaultBinding.command);
+        expect(match?.runtime.binding?.command).to.be.equal(defaultBinding.command);
+    });
+    it('should dispatch already-handled compatibility events to capture listeners', () => {
+        const target = document.createElement('iframe');
+        document.body.appendChild(target);
+        const captured = sinon.spy();
+        document.addEventListener('keydown', captured, true);
+        const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+        keybindingRegistry.dispatchKeyDown({ key: 'a', code: 'KeyA' }, target, true);
+        expect(captured.calledOnce).to.be.true;
+        expect(captured.firstCall.args[0].defaultPrevented).to.be.false;
+        expect(match.called).to.be.false;
+        document.removeEventListener('keydown', captured, true);
+        target.remove();
+    });
+    it('should dispatch normalized keyboard data directly', () => {
+        const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+        keybindingRegistry.dispatchNormalizedKeyDown({
+            key: 'a',
+            code: 'KeyA',
+            keyCode: 65,
+            ctrlKey: true
+        }, new EventTarget());
+        expect(match.calledOnce).to.be.true;
+        expect(match.firstCall.args[0][0].dispatchString()).to.equal('ctrl+a');
+    });
+    it('should dispatch a DOM keydown for dispatched commands without executing them twice', async () => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        const captured = sinon.spy();
+        const run = (event) => keybindingRegistry.run(event);
+        document.addEventListener('keydown', captured, true);
+        document.addEventListener('keydown', run, true);
+        const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND.id, { execute });
+        try {
+            keybindingRegistry.dispatchCommand(TEST_COMMAND.id, target);
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(captured.calledOnce).to.be.true;
+            expect(captured.firstCall.args[0].ctrlKey).to.be.true;
+            expect(execute.calledOnce).to.be.true;
+            expect(match.calledOnce).to.be.true;
+        }
+        finally {
+            handler.dispose();
+            document.removeEventListener('keydown', captured, true);
+            document.removeEventListener('keydown', run, true);
+            target.remove();
+        }
+    });
+    it('should preserve authored modifiers when dispatching commands through normalized Windows layout modifier data', async () => {
+        const windows = sinon.stub(os, 'isWindows').value(true);
+        testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+        const dispatch = sinon.spy(keybindingRegistry, 'dispatchNormalizedKeyDown');
+        const target = document.createElement('div');
+        const cases = [
+            { keybinding: '[', ctrlKey: false, altKey: false },
+            { keybinding: 'ctrl+[', ctrlKey: true, altKey: false, inactive: true },
+            { keybinding: 'alt+[', ctrlKey: false, altKey: true, inactive: true },
+            { keybinding: 'ctrl+alt+[', ctrlKey: true, altKey: true, inactive: true }
+        ];
+        try {
+            for (const testCase of cases) {
+                const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: testCase.keybinding };
+                keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+                const execute = sinon.spy();
+                const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+                dispatch.resetHistory();
+                try {
+                    keybindingRegistry.dispatchCommand(TEST_COMMAND_SHADOW.id, target);
+                    await new Promise(resolve => setTimeout(resolve, 0));
+                    if (testCase.inactive) {
+                        // Windows reports AltGr as Ctrl+Alt, so neither command Ctrl nor Alt can accompany an AltGraph character.
+                        expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.true;
+                        expect(dispatch.called).to.be.false;
+                        expect(execute.called).to.be.false;
+                        continue;
+                    }
+                    expect(dispatch.calledOnce).to.be.true;
+                    expect(dispatch.firstCall.args[0]).to.include({
+                        key: '[',
+                        code: 'Digit8',
+                        keyCode: 56,
+                        ctrlKey: testCase.ctrlKey,
+                        altKey: testCase.altKey,
+                        altGraph: true
+                    });
+                    expect(execute.calledOnce).to.be.true;
+                }
+                finally {
+                    handler.dispose();
+                }
+            }
+        }
+        finally {
+            windows.restore();
+        }
+    });
+    it('should interpret native and transported AltGraph input identically', () => {
+        testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+        const native = keybindingRegistry.getKeyCodeInterpretations({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            ctrlKey: true,
+            getModifierState: modifier => modifier === 'AltGraph'
+        });
+        const transported = keybindingRegistry.getKeyCodeInterpretations({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            ctrlKey: true,
+            altGraph: true
+        });
+        expect(transported.map(code => code.dispatchString())).to.deep.equal(native.map(code => code.dispatchString()));
+    });
+    it('should log normalized keyboard troubleshooting data when enabled', () => {
+        const logger = keybindingRegistry.logger;
+        const info = sinon.spy(logger, 'info');
+        keybindingRegistry.toggleKeyboardShortcutsTroubleshooting();
+        keybindingRegistry.dispatchNormalizedKeyDown({
+            key: '[',
+            code: 'Digit8',
+            keyCode: 56,
+            getModifierState: modifier => modifier === 'AltGraph',
+            timeStamp: 42
+        }, new EventTarget());
+        expect(info.calledTwice).to.be.true;
+        expect(info.secondCall.args[1].input).to.include({
+            key: '[',
+            code: 'Digit8',
+            altGraph: true,
+            timeStamp: 42
+        });
+        expect(info.secondCall.args[1].layout.source).to.equal('navigator.keyboard');
+    });
+    it('should skip composing normalized keyboard data', () => {
+        const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+        keybindingRegistry.dispatchNormalizedKeyDown({
+            key: 'a',
+            code: 'KeyA',
+            keyCode: 65,
+            isComposing: true
+        }, new EventTarget());
+        expect(match.called).to.be.false;
+    });
+    it('should exclude inactive bindings and reactivate them after a layout change', () => {
+        const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire({
+            info: { id: 'missing-bracket', lang: 'en' },
+            mapping: { KeyA: { value: 'a', withShift: 'A', withAltGr: '', withShiftAltGr: '' } }
+        });
+        expect(keybindingRegistry.getKeybindingsForCommand(TEST_COMMAND.id).some(candidate => candidate.keybinding === 'ctrl+[')).to.be.true;
+        expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
+        expect(keybindingRegistry.matchKeybinding(keys_1.KeySequence.parse('ctrl+['))).to.be.undefined;
+        expect(keybindingRegistry.containsKeybindingInScope({ command: TEST_COMMAND2.id, keybinding: 'ctrl+[' })).to.be.false;
+        notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
+        expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
+    });
+    it('should keep default Latin-letter bindings active on a non-Latin layout', async () => {
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+c' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(RUSSIAN_LAYOUT);
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.false;
+            keybindingRegistry.dispatchNormalizedKeyDown({
+                key: 'с', code: 'KeyC', ctrlKey: true
+            }, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+        }
+        finally {
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should dispatch a shifted Latin-letter binding on a non-Latin layout', async () => {
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+a' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(RUSSIAN_LAYOUT);
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            keybindingRegistry.dispatchNormalizedKeyDown({
+                key: 'Ф', code: 'KeyA', ctrlKey: true, shiftKey: true
+            }, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+        }
+        finally {
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should keep punctuation bindings inactive on a non-Latin layout', () => {
+        const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(RUSSIAN_LAYOUT);
+        try {
+            expect(keybindingRegistry.isKeybindingInactive(binding)).to.be.true;
+        }
+        finally {
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should execute an authored Shift command modifier on a non-US logical character', async () => {
+        testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+ü' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            keybindingRegistry.dispatchNormalizedKeyDown({
+                key: 'Ü', code: 'BracketLeft', ctrlKey: true, shiftKey: true
+            }, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+        }
+        finally {
+            handler.dispose();
+        }
+    });
+    it('should mark an unmatchable Shift plus AltGraph character binding inactive', async () => {
+        testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+shift+[char:0x7B]' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
+            keybindingRegistry.dispatchNormalizedKeyDown({
+                key: '{', code: 'Digit7', ctrlKey: true, shiftKey: true, altGraph: true
+            }, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.called).to.be.false;
+        }
+        finally {
+            handler.dispose();
+        }
+    });
+    it('should mark command Alt plus AltGraph character bindings inactive on macOS and Windows', async () => {
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'alt+[' };
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        const windows = sinon.stub(os, 'isWindows').value(false);
+        const dispatch = async (input) => {
+            keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+        };
+        try {
+            stub.value(true);
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-mac.json'));
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
+            expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined, 'physical')).to.deep.equal([]);
+            await dispatch({ key: '[', code: 'Digit5', altKey: true });
+            expect(execute.called).to.be.false;
+            stub.value(false);
+            windows.value(true);
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
+            await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altKey: true });
+            expect(execute.called).to.be.false;
+            windows.value(false);
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
+            await dispatch({ key: '[', code: 'Digit8', altKey: true, altGraph: true });
+            expect(execute.calledOnce).to.be.true;
+        }
+        finally {
+            windows.restore();
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should mark command Ctrl plus AltGraph character bindings inactive on Windows', async () => {
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        const binding = { command: TEST_COMMAND_SHADOW.id, keybinding: 'ctrl+[' };
+        const typed = { command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: '[' };
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        const windows = sinon.stub(os, 'isWindows').value(true);
+        const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+        const dispatch = async (input) => {
+            keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+        };
+        try {
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding, typed]);
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.a('string');
+            expect(keybindingRegistry.acceleratorForCommand(TEST_COMMAND_SHADOW.id, undefined, 'physical')).to.deep.equal([]);
+            // Chromium reports Ctrl+AltGr+8 on Windows exactly like AltGr+8, so the input types `[`.
+            await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph: true });
+            expect(execute.called).to.be.false;
+            const fullMatches = match.returnValues.filter(result => result?.kind === 'full').map(result => result.runtime.binding.keybinding);
+            expect(fullMatches).to.deep.equal(['[']);
+            windows.value(false);
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+            expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
+            await dispatch({ key: '[', code: 'Digit8', ctrlKey: true, altGraph: true });
+            expect(execute.calledOnce).to.be.true;
+        }
+        finally {
+            windows.restore();
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should route Windows Ctrl+Alt candidates through the registry with and without reported AltGraph', () => {
+        const windows = sinon.stub(os, 'isWindows').value(true);
+        try {
+            testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            const match = sinon.spy(keybindingRegistry, 'matchKeybinding');
+            const logicalBinding = {
+                command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
+                keybinding: '[',
+                resolved: [new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, character: '[', layoutModifiers: 'altGraph' })]
+            };
+            for (const altGraph of [true, false]) {
+                const input = { key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph };
+                match.resetHistory();
+                keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [logicalBinding]);
+                keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
+                expect(match.callCount).to.equal(2);
+                expect(match.secondCall.returnValue?.kind).to.equal('full');
+                expect(match.secondCall.returnValue?.runtime.binding.keybinding).to.equal('[');
+                match.resetHistory();
+                keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [
+                    logicalBinding,
+                    { command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+alt+8' }
+                ]);
+                keybindingRegistry.dispatchNormalizedKeyDown(input, new EventTarget());
+                expect(match.callCount).to.equal(2);
+                expect(match.firstCall.returnValue?.runtime.binding.keybinding).to.equal('ctrl+alt+8');
+            }
+        }
+        finally {
+            windows.restore();
+        }
+    });
+    it('should prefer a command chord prefix over a layout modifier full match', () => {
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
+            new keys_1.KeyCode({ key: keys_1.Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' }),
+            new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' })
+        ]);
+        const commandChord = {
+            command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
+            keybinding: 'ctrl+a b'
+        };
+        const layoutFull = {
+            command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
+            keybinding: 'ctrl+['
+        };
+        keybindingRegistry.resolveKeybinding(commandChord).splice(0, 2, ...keys_1.KeySequence.parse('ctrl+a b'));
+        keybindingRegistry.resolveKeybinding(layoutFull).splice(0, 1, new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph' }));
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [commandChord, layoutFull]);
+        const event = testKeyboardEvent({ key: '[', code: 'Digit8' });
+        keybindingRegistry.run(event);
+        expect(event.defaultPrevented).to.be.true;
+        expect(keybindingRegistry.keySequenceCandidates).to.have.length(1);
+        expect(keybindingRegistry.keySequenceCandidates[0][0].interpretation).to.equal('commandModifiers');
+        interpretations.restore();
+    });
+    it('should retain alternative interpretation prefixes across a chord', () => {
+        const commandPrefix = new keys_1.KeyCode({ key: keys_1.Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' });
+        const layoutPrefix = new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' });
+        const layoutSecond = new keys_1.KeyCode({ key: keys_1.Key.KEY_C, interpretation: 'layoutModifiers' });
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations');
+        interpretations.onFirstCall().returns([commandPrefix, layoutPrefix]);
+        interpretations.onSecondCall().returns([
+            new keys_1.KeyCode({ key: keys_1.Key.KEY_X, interpretation: 'commandModifiers' }),
+            layoutSecond
+        ]);
+        const commandBinding = {
+            command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
+            keybinding: 'ctrl+a b'
+        };
+        const layoutBinding = {
+            command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND,
+            keybinding: 'ctrl+[ c'
+        };
+        keybindingRegistry.resolveKeybinding(commandBinding).splice(0, 2, commandPrefix, new keys_1.KeyCode({ key: keys_1.Key.KEY_B }));
+        keybindingRegistry.resolveKeybinding(layoutBinding).splice(0, 2, layoutPrefix, layoutSecond);
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [commandBinding, layoutBinding]);
+        keybindingRegistry.run(testKeyboardEvent({ key: '[', code: 'Digit8' }));
+        expect(keybindingRegistry.keySequenceCandidates).to.have.length(2);
+        const second = testKeyboardEvent({ key: 'c', code: 'KeyC' });
+        keybindingRegistry.run(second);
+        expect(second.defaultPrevented).to.be.false;
+        expect(keybindingRegistry.keySequenceCandidates).to.deep.equal([[]]);
+        interpretations.restore();
+    });
+    it('should decline equal-priority full matches from different interpretations', () => {
+        const first = new keys_1.KeyCode({ key: keys_1.Key.KEY_A, ctrl: true, interpretation: 'commandModifiers' });
+        const second = new keys_1.KeyCode({ key: keys_1.Key.KEY_B, ctrl: true, interpretation: 'commandModifiers' });
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([first, second]);
+        const troubleshooting = sinon.spy(keybindingRegistry, 'logKeyboardTroubleshooting');
+        const logger = keybindingRegistry.logger;
+        const warning = sinon.spy(logger, 'warn');
+        const firstBinding = { command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+a' };
+        const secondBinding = { command: keybinding_1.KeybindingRegistry.PASSTHROUGH_PSEUDO_COMMAND, keybinding: 'ctrl+b' };
+        keybindingRegistry.resolveKeybinding(firstBinding).splice(0, 1, first);
+        keybindingRegistry.resolveKeybinding(secondBinding).splice(0, 1, second);
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [firstBinding, secondBinding]);
+        keybindingRegistry.run(testKeyboardEvent({ key: 'a', code: 'KeyA' }));
+        expect(troubleshooting.lastCall.args[3]).to.equal('ambiguous');
+        expect(troubleshooting.lastCall.args[2]).to.be.undefined;
+        expect(warning.calledOnce).to.be.true;
+        keybindingRegistry.run(testKeyboardEvent({ key: 'a', code: 'KeyA' }));
+        expect(warning.calledOnce).to.be.true;
+        interpretations.restore();
+    });
+    it('should canonicalize layout modifier input for recorder persistence', () => {
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
+            new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, alt: true, interpretation: 'commandModifiers' }),
+            new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph', interpretation: 'layoutModifiers' })
+        ]);
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '[', code: 'Digit8' })?.toString()).to.equal('ctrl+[');
+        interpretations.restore();
+    });
+    it('should record the Latin fallback letter on a non-Latin layout', () => {
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(RUSSIAN_LAYOUT);
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+            key: 'с', code: 'KeyC', ctrlKey: true
+        })?.toAuthoredKeybindingString()).to.equal('ctrl+c');
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+            key: 'С', code: 'KeyC', ctrlKey: true, shiftKey: true
+        })?.toAuthoredKeybindingString()).to.equal('shift+ctrl+c');
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+            key: '€', code: 'KeyE', ctrlKey: true, altGraph: true
+        })?.toAuthoredKeybindingString()).to.equal('ctrl+€');
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+            key: 'у', code: 'KeyE', ctrlKey: true
+        })?.toAuthoredKeybindingString()).to.equal('ctrl+e');
+        notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+            key: 'c', code: 'KeyC', ctrlKey: true
+        })?.toAuthoredKeybindingString()).to.equal('ctrl+c');
+    });
+    it('should record legacy Windows AltGraph input as its logical character', () => {
+        const windows = sinon.stub(os, 'isWindows').value(true);
+        try {
+            testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            for (const altGraph of [true, false]) {
+                expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({
+                    key: '[', code: 'Digit8', ctrlKey: true, altKey: true, altGraph
+                })?.toString()).to.equal('[');
+            }
+        }
+        finally {
+            windows.restore();
+        }
+    });
+    it('should retain command Shift when layout modifier Shift is not the logical binding', () => {
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
+            new keys_1.KeyCode({ key: keys_1.Key.KEY_P, ctrl: true, character: 'P', layoutModifiers: 'shift', interpretation: 'layoutModifiers' })
+        ]);
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: 'P', code: 'KeyP' })?.toString()).to.equal('shift+ctrl+p');
+        interpretations.restore();
+    });
+    it('should persist a parseable logical character produced by Shift', () => {
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([
+            new keys_1.KeyCode({ key: keys_1.Key.DIGIT7, character: '/', layoutModifiers: 'shift', interpretation: 'layoutModifiers' })
+        ]);
+        const resolve = sinon.stub(testContainer.get(keyboard_layout_service_1.KeyboardLayoutService), 'resolveKeyCode').callsFake(code => code.key === keys_1.Key.SLASH
+            ? new keys_1.KeyCode({ key: keys_1.Key.DIGIT7, character: '/', layoutModifiers: 'shift' })
+            : code);
+        expect(keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '/', code: 'Digit7' })?.toString()).to.equal('/');
+        resolve.restore();
+        interpretations.restore();
+    });
+    it('should record newly authorable printable characters logically', () => {
+        const layoutCode = new keys_1.KeyCode({ key: keys_1.Key.SLASH, ctrl: true, character: '?', layoutModifiers: 'shift', interpretation: 'layoutModifiers' });
+        const interpretations = sinon.stub(keybindingRegistry, 'getKeyCodeInterpretations').returns([layoutCode]);
+        const recorded = keybindingRegistry.authoredKeyCodeForKeyboardInput({ key: '?', code: 'Slash' });
+        expect(recorded?.toString()).to.equal('ctrl+?');
+        expect(keybindingRegistry.resolveKeybinding({ command: TEST_COMMAND.id, keybinding: recorded.toString() })[0].dispatchString())
+            .to.equal(layoutCode.dispatchString());
+        interpretations.restore();
+    });
+    it('should record logical characters, physical non-printables, and ignore modifier-only input', () => {
+        const registry = Object.create(keybinding_1.KeybindingRegistry.prototype);
+        registry.authoredKeyCodeForKeyboardInput = input => {
+            if (input.code === 'ControlLeft') {
+                return new keys_1.KeyCode({ ctrl: true });
+            }
+            if (input.code === 'F1') {
+                return new keys_1.KeyCode({ key: keys_1.Key.F1, ctrl: true });
+            }
+            if (input.code === 'Delete') {
+                return new keys_1.KeyCode({ key: keys_1.Key.DELETE, ctrl: true });
+            }
+            if (input.code === 'KeyP') {
+                return new keys_1.KeyCode({ key: keys_1.Key.KEY_P, ctrl: true, shift: true, character: 'P' });
+            }
+            return new keys_1.KeyCode({ key: input.code === 'Equal' ? keys_1.Key.EQUAL : keys_1.Key.BRACKET_LEFT, ctrl: true, character: input.key });
+        };
+        expect(registry.authoredKeybindingStringForKeyboardInput({ key: '[', code: 'Digit8', ctrlKey: true })).to.equal('ctrl+[');
+        expect(registry.authoredKeybindingStringForKeyboardInput({ key: '+', code: 'Equal', ctrlKey: true })).to.equal('ctrl+[char:0x2B]');
+        expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'F1', code: 'F1', ctrlKey: true })).to.equal('ctrl+f1');
+        expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'Delete', code: 'Delete', ctrlKey: true })).to.equal('ctrl+delete');
+        const shifted = registry.authoredKeybindingStringForKeyboardInput({ key: 'P', code: 'KeyP', ctrlKey: true, shiftKey: true });
+        expect(shifted).to.equal('shift+ctrl+p');
+        expect(keys_1.KeyCode.parse(shifted).dispatchString()).to.equal('shift+ctrl+p');
+        expect(registry.authoredKeybindingStringForKeyboardInput({ key: 'Control', code: 'ControlLeft', ctrlKey: true })).to.be.undefined;
+    });
+    it('should record Space and numpad keys by name', () => {
+        expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: ' ', code: 'Space', ctrlKey: true, shiftKey: true }))
+            .to.equal('shift+ctrl+space');
+        expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '+', code: 'NumpadAdd', ctrlKey: true })).to.equal('ctrl+add');
+        expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '-', code: 'NumpadSubtract', ctrlKey: true })).to.equal('ctrl+subtract');
+        expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '.', code: 'NumpadDecimal', ctrlKey: true })).to.equal('ctrl+decimal');
+        expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '1', code: 'Numpad1', ctrlKey: true })).to.equal('ctrl+1');
+    });
+    it('should dispatch and record Option bindings as command modifiers on macOS', async () => {
+        stub.value(true);
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-mac.json'));
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'shift+alt+p' }]);
+            keybindingRegistry.run(testKeyboardEvent({ key: '∏', code: 'KeyP', shiftKey: true, altKey: true }));
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: '∏', code: 'KeyP', shiftKey: true, altKey: true }))
+                .to.equal('shift+alt+p');
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'π', code: 'KeyP', altKey: true })).to.equal('alt+p');
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'P', code: 'KeyP', shiftKey: true })).to.equal('shift+p');
+        }
+        finally {
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should dispatch and record dead Option keys as their base character on macOS', async () => {
+        stub.value(true);
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-mac.json'));
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'alt+e' }]);
+            keybindingRegistry.run(testKeyboardEvent({ key: 'Dead', code: 'KeyE', altKey: true }));
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true })).to.equal('alt+e');
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true, shiftKey: true }))
+                .to.equal('shift+alt+e');
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Dead', code: 'KeyE', altKey: true, metaKey: true }))
+                .to.equal('meta+alt+e');
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'F1', code: 'F1', altKey: true })).to.equal('alt+f1');
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: 'shift+alt+e' }]);
+            keybindingRegistry.run(testKeyboardEvent({ key: 'Dead', code: 'KeyE', altKey: true, shiftKey: true }));
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledTwice).to.be.true;
+        }
+        finally {
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should record Caps Lock input with the layout layer case', async () => {
+        const notifier = testContainer.get(MockKeyboardLayoutChangeNotifier);
+        const execute = sinon.spy();
+        const handler = commandRegistry.registerHandler(TEST_COMMAND_SHADOW.id, { execute });
+        try {
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'p', code: 'KeyP', ctrlKey: true, shiftKey: true }))
+                .to.equal('shift+ctrl+p');
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-pc.json'));
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'ü', code: 'BracketLeft', ctrlKey: true, shiftKey: true }))
+                .to.equal('ctrl+Ü');
+            const recorded = keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Ü', code: 'BracketLeft', ctrlKey: true });
+            expect(recorded).to.equal('ctrl+ü');
+            keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [{ command: TEST_COMMAND_SHADOW.id, keybinding: recorded }]);
+            keybindingRegistry.dispatchNormalizedKeyDown({ key: 'ü', code: 'BracketLeft', ctrlKey: true }, new EventTarget());
+            await new Promise(resolve => setTimeout(resolve, 0));
+            expect(execute.calledOnce).to.be.true;
+            notifier.emitter.fire({
+                info: { id: 'altgraph-letters', lang: 'pl' },
+                mapping: { KeyL: { value: 'l', withShift: 'L', withAltGr: 'ł', withShiftAltGr: 'Ł' } }
+            });
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Ł', code: 'KeyL', ctrlKey: true, altGraph: true }))
+                .to.equal('ctrl+ł');
+            stub.value(true);
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/de-German-mac.json'));
+            expect(keybindingRegistry.authoredKeybindingStringForKeyboardInput({ key: 'Å', code: 'KeyA', altKey: true })).to.equal('alt+a');
+        }
+        finally {
+            handler.dispose();
+            notifier.emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        }
+    });
+    it('should classify interpretation shadowing separately from canonical collisions', () => {
+        const logical = {
+            command: TEST_COMMAND.id,
+            keybinding: 'ctrl+[',
+            resolved: [new keys_1.KeyCode({ key: keys_1.Key.DIGIT8, ctrl: true, character: '[', layoutModifiers: 'altGraph' })]
+        };
+        const command = { command: TEST_COMMAND2.id, keybinding: 'ctrl+alt+8' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [logical, command]);
+        const diagnostics = keybindingRegistry.getKeybindingCollisionDiagnostics(logical);
+        expect(diagnostics.shadowedBy.map(binding => binding.command)).to.include(TEST_COMMAND2.id);
+        expect(diagnostics.authored.full).to.be.empty;
+        expect(diagnostics.layoutDerived.full).to.be.empty;
+        expect(keybindingRegistry.containsKeybindingInScope(logical)).to.be.false;
+    });
+    it('should keep shifted printable bindings symmetric in keyCode dispatch mode', () => {
+        corePreferences['keyboard.dispatch'] = 'keyCode';
+        const commandPalette = { command: TEST_COMMAND.id, keybinding: 'ctrl+shift+p' };
+        const shiftedPrintable = { command: TEST_COMMAND2.id, keybinding: 'shift+/' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [commandPalette, shiftedPrintable]);
+        expect(keybindingRegistry.matchKeybinding(keys_1.KeySequence.parse('ctrl+shift+p'))?.runtime.binding.command).to.equal(TEST_COMMAND.id);
+        expect(keybindingRegistry.matchKeybinding(keys_1.KeySequence.parse('shift+/'))?.runtime.binding.command).to.equal(TEST_COMMAND2.id);
+    });
+    it('should mark character-only bindings inactive in keyCode dispatch mode', () => {
+        corePreferences['keyboard.dispatch'] = 'keyCode';
+        const characterOnly = { command: TEST_COMMAND.id, keybinding: 'ctrl+ü' };
+        const positional = { command: TEST_COMMAND2.id, keybinding: 'ctrl+[' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [characterOnly, positional]);
+        expect(keybindingRegistry.getKeybindingInactiveReason(characterOnly)).to.be.a('string');
+        expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(characterOnly))).to.be.undefined;
+        expect(keybindingRegistry.getKeybindingInactiveReason(positional)).to.be.undefined;
+        expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(positional))?.kind).to.equal('full');
+    });
+    it('should require resolved sequences for logical matching in code dispatch mode', () => {
+        testContainer.get(MockKeyboardLayoutChangeNotifier).emitter.fire(require('../../src/common/keyboard/layouts/en-US-pc.json'));
+        const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+shift+a' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        expect(keys_1.KeySequence.parse('ctrl+shift+a')[0].dispatchString()).to.equal('shift+ctrl+a');
+        expect(keybindingRegistry.resolveKeybinding(binding)[0].dispatchString()).to.equal('ctrl+a@shift');
+        expect(keybindingRegistry.matchKeybinding(keys_1.KeySequence.parse('ctrl+shift+a'))).to.be.undefined;
+        expect(keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(binding))?.kind).to.equal('full');
+    });
+    it('should invalidate resolved bindings when keyboard dispatch changes', () => {
+        const binding = { command: TEST_COMMAND.id, keybinding: 'ctrl+[' };
+        keybindingRegistry.setKeymap(keybinding_1.KeybindingScope.USER, [binding]);
+        expect(keybindingRegistry.getKeybindingInactiveReason(binding)).to.be.undefined;
+        const changed = sinon.spy();
+        keybindingRegistry.onKeybindingsChanged(changed);
+        corePreferences['keyboard.dispatch'] = 'keyCode';
+        preferenceChanged.fire({ preferenceName: 'keyboard.dispatch' });
+        expect(changed.calledOnce).to.be.true;
+        expect(keybindingRegistry.resolveKeybinding(binding)[0].dispatchString()).to.equal('ctrl+[');
+        expect(keybindingRegistry.matchKeybinding(keys_1.KeySequence.parse('ctrl+['))?.kind).to.equal('full');
     });
     it('should prioritize bindings that use local context keys', () => {
         // Ensure JSDOM is enabled for this test since it uses document
@@ -407,10 +1124,10 @@ describe('keybindings', () => {
             shiftKey: true
         });
         Object.defineProperty(mockEvent, 'target', { value: targetElement });
-        const match = keybindingRegistry.matchKeybinding([keyCode], mockEvent);
+        const match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(localBinding), mockEvent);
         // The localBinding should be selected because it uses a local context key
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal('test.local-command');
+        expect(match?.runtime.binding?.command).to.be.equal('test.local-command');
         disable();
     });
     it('should fall back to first binding when no local context keys exist', () => {
@@ -442,10 +1159,10 @@ describe('keybindings', () => {
             shiftKey: true
         });
         Object.defineProperty(mockEvent, 'target', { value: targetElement });
-        const match = keybindingRegistry.matchKeybinding([keyCode], mockEvent);
+        const match = keybindingRegistry.matchKeybinding(keybindingRegistry.resolveKeybinding(secondBinding), mockEvent);
         // Should fall back to first enabled binding in priority order (secondBinding was registered later, so it wins)
         expect(match?.kind).to.be.equal('full');
-        expect(match?.binding?.command).to.be.equal('test.second-command');
+        expect(match?.runtime.binding?.command).to.be.equal('test.second-command');
         disable();
     });
 });
@@ -462,6 +1179,48 @@ describe('acceleratorForKeyCode', () => {
         const accelerator = keybindingRegistry.acceleratorForKeyCode(metaV, '+');
         expect(accelerator).to.equal('⌘V');
     });
+    it('separates logical labels from physical layout modifier realizations', () => {
+        const logicalBracket = new keys_1.KeyCode({
+            key: keys_1.Key.DIGIT8,
+            ctrl: true,
+            character: '[',
+            layoutModifiers: 'altGraph'
+        });
+        const logicalSlash = new keys_1.KeyCode({
+            key: keys_1.Key.DIGIT7,
+            character: '/',
+            layoutModifiers: 'shift'
+        });
+        expect(keybindingRegistry.componentsForKeyCode(logicalBracket)).to.deep.equal(['Ctrl', '[']);
+        expect(keybindingRegistry.componentsForKeyCode(logicalBracket, false, 'physical')).to.deep.equal(['Ctrl', 'AltGr', '8']);
+        expect(keybindingRegistry.acceleratorForKeyCode(logicalBracket, '+', true, 'physical')).to.equal('Ctrl+AltGr+8');
+        expect(keybindingRegistry.componentsForKeyCode(logicalSlash)).to.deep.equal(['/']);
+        expect(keybindingRegistry.componentsForKeyCode(logicalSlash, false, 'physical')).to.deep.equal(['Shift', '7']);
+        expect(keybindingRegistry.acceleratorForKeyCode(logicalSlash, '+', true, 'physical')).to.equal('Shift+7');
+    });
+    it('keeps command Shift in physical realizations', () => {
+        const commandShift = new keys_1.KeyCode({ key: keys_1.Key.TAB, ctrl: true, shift: true });
+        expect(keybindingRegistry.componentsForKeyCode(commandShift, false, 'physical')).to.deep.equal(['Ctrl', 'Shift', 'Tab']);
+        const shiftedLetter = new keys_1.KeyCode({ key: keys_1.Key.KEY_P, ctrl: true, character: 'P', layoutModifiers: 'shift' });
+        expect(keybindingRegistry.componentsForKeyCode(shiftedLetter)).to.deep.equal(['Ctrl', 'Shift', 'P']);
+        const unresolvedCharacter = new keys_1.KeyCode({ ctrl: true, character: '§', supportedByLayout: false });
+        expect(keybindingRegistry.componentsForKeyCode(unresolvedCharacter)).to.deep.equal(['Ctrl', '§']);
+    });
+    it('deduplicates command Alt and layout modifier Option on macOS', () => {
+        stub.value(true);
+        const commandAndLayoutOption = new keys_1.KeyCode({
+            key: keys_1.Key.DIGIT6,
+            meta: true,
+            ctrl: true,
+            alt: true,
+            layoutModifiers: 'altGraph'
+        });
+        const layoutOption = new keys_1.KeyCode({ key: keys_1.Key.DIGIT6, layoutModifiers: 'altGraph' });
+        expect(keybindingRegistry.componentsForKeyCode(commandAndLayoutOption, false, 'physical')).to.deep.equal(['⌘', '⌃', '⌥', '6']);
+        expect(keybindingRegistry.componentsForKeyCode(commandAndLayoutOption, true, 'physical')).to.deep.equal(['Cmd', 'Ctrl', 'Alt', '6']);
+        expect(keybindingRegistry.componentsForKeyCode(layoutOption, false, 'physical')).to.deep.equal(['⌥', '6']);
+        expect(keybindingRegistry.componentsForKeyCode(layoutOption, true, 'physical')).to.deep.equal(['Option', '6']);
+    });
     it('uses ASCII names with the separator on macOS Electron (asciiOnly)', () => {
         stub.value(true);
         const accelerator = keybindingRegistry.acceleratorForKeyCode(metaV, '+', true);
@@ -514,10 +1273,7 @@ MockContextKeyService = tslib_1.__decorate([
 ], MockContextKeyService);
 let MockKeyboardLayoutProvider = class MockKeyboardLayoutProvider {
     getNativeLayout() {
-        return Promise.resolve({
-            info: { id: 'mock', lang: 'en' },
-            mapping: {}
-        });
+        return Promise.resolve(require('../../src/common/keyboard/layouts/en-US-pc.json'));
     }
 };
 MockKeyboardLayoutProvider = tslib_1.__decorate([