Implement win32-input-mode

Fixes #2357

demo/client/components/window/optionsWindow.ts

@@ -125,7 +125,8 @@ export class OptionsWindow extends BaseWindow implements IControlWindow {
     ];
     const nestedBooleanOptions: { label: string, parent: string, prop: string }[] = [
       { label: 'vtExtensions.kittyKeyboard', parent: 'vtExtensions', prop: 'kittyKeyboard' },
-      { label: 'vtExtensions.kittySgrBoldFaintControl', parent: 'vtExtensions', prop: 'kittySgrBoldFaintControl' }
+      { label: 'vtExtensions.kittySgrBoldFaintControl', parent: 'vtExtensions', prop: 'kittySgrBoldFaintControl' },
+      { label: 'vtExtensions.win32InputMode', parent: 'vtExtensions', prop: 'win32InputMode' }
     ];
     const stringOptions: { [key: string]: string[] | null } = {
       cursorStyle: ['block', 'underline', 'bar'],

src/browser/public/Terminal.ts

@@ -125,6 +125,7 @@ export class Terminal extends Disposable implements ITerminalApi {
       sendFocusMode: m.sendFocus,
       showCursor: !this._core.coreService.isCursorHidden,
       synchronizedOutputMode: m.synchronizedOutput,
+      win32InputMode: m.win32InputMode,
       wraparoundMode: m.wraparound
     };
   }

src/browser/services/KeyboardService.ts

@@ -6,6 +6,7 @@
 import { IKeyboardService } from 'browser/services/Services';
 import { evaluateKeyboardEvent } from 'common/input/Keyboard';
 import { evaluateKeyboardEventKitty, KittyKeyboardEventType, KittyKeyboardFlags, shouldUseKittyProtocol } from 'common/input/KittyKeyboard';
+import { evaluateKeyboardEventWin32 } from 'common/input/Win32InputMode';
 import { isMac } from 'common/Platform';
 import { ICoreService, IOptionsService } from 'common/services/Services';
 import { IKeyboardResult } from 'common/Types';
@@ -20,6 +21,10 @@ export class KeyboardService implements IKeyboardService {
   }
 
   public evaluateKeyDown(event: KeyboardEvent): IKeyboardResult {
+    // Win32 input mode takes priority (most raw)
+    if (this.useWin32) {
+      return evaluateKeyboardEventWin32(event, true);
+    }
     const kittyFlags = this._coreService.kittyKeyboard.flags;
     return this.useKitty
       ? evaluateKeyboardEventKitty(event, kittyFlags, event.repeat ? KittyKeyboardEventType.REPEAT : KittyKeyboardEventType.PRESS)
@@ -27,6 +32,10 @@ export class KeyboardService implements IKeyboardService {
   }
 
   public evaluateKeyUp(event: KeyboardEvent): IKeyboardResult | undefined {
+    // Win32 input mode sends key up events
+    if (this.useWin32) {
+      return evaluateKeyboardEventWin32(event, false);
+    }
     const kittyFlags = this._coreService.kittyKeyboard.flags;
     if (this.useKitty && (kittyFlags & KittyKeyboardFlags.REPORT_EVENT_TYPES)) {
       return evaluateKeyboardEventKitty(event, kittyFlags, KittyKeyboardEventType.RELEASE);
@@ -38,4 +47,8 @@ export class KeyboardService implements IKeyboardService {
     const kittyFlags = this._coreService.kittyKeyboard.flags;
     return !!(this._optionsService.rawOptions.vtExtensions?.kittyKeyboard && shouldUseKittyProtocol(kittyFlags));
   }
+
+  public get useWin32(): boolean {
+    return !!(this._optionsService.rawOptions.vtExtensions?.win32InputMode && this._coreService.decPrivateModes.win32InputMode);
+  }
 }

src/common/InputHandler.ts

@@ -2026,6 +2026,11 @@ export class InputHandler extends Disposable implements IInputHandler {
         case 2026: // synchronized output (https://github.com/contour-terminal/vt-extensions/blob/master/synchronized-output.md)
           this._coreService.decPrivateModes.synchronizedOutput = true;
           break;
+        case 9001: // win32-input-mode (https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md)
+          if (this._optionsService.rawOptions.vtExtensions?.win32InputMode) {
+            this._coreService.decPrivateModes.win32InputMode = true;
+          }
+          break;
       }
     }
     return true;
@@ -2266,6 +2271,11 @@ export class InputHandler extends Disposable implements IInputHandler {
           this._coreService.decPrivateModes.synchronizedOutput = false;
           this._onRequestRefreshRows.fire(undefined);
           break;
+        case 9001: // win32-input-mode
+          if (this._optionsService.rawOptions.vtExtensions?.win32InputMode) {
+            this._coreService.decPrivateModes.win32InputMode = false;
+          }
+          break;
       }
     }
     return true;
@@ -2361,6 +2371,7 @@ export class InputHandler extends Disposable implements IInputHandler {
     if (p === 47 || p === 1047 || p === 1049) return f(p, b2v(active === alt));
     if (p === 2004) return f(p, b2v(dm.bracketedPasteMode));
     if (p === 2026) return f(p, b2v(dm.synchronizedOutput));
+    if (p === 9001) return this._optionsService.rawOptions.vtExtensions?.win32InputMode ? f(p, b2v(dm.win32InputMode)) : f(p, V.NOT_RECOGNIZED);
     return f(p, V.NOT_RECOGNIZED);
   }
 

src/common/TestUtils.test.ts

@@ -112,6 +112,7 @@ export class MockCoreService implements ICoreService {
     reverseWraparound: false,
     sendFocus: false,
     synchronizedOutput: false,
+    win32InputMode: false,
     wraparound: true
   };
   public kittyKeyboard = {

src/common/Types.ts

@@ -274,6 +274,7 @@ export interface IDecPrivateModes {
   reverseWraparound: boolean;
   sendFocus: boolean;
   synchronizedOutput: boolean;
+  win32InputMode: boolean;
   wraparound: boolean; // defaults: xterm - true, vt100 - false
 }
 

src/common/input/Win32InputMode.test.ts

@@ -0,0 +1,290 @@
+
+import { assert } from 'chai';
+import { evaluateKeyboardEventWin32, Win32ControlKeyState } from 'common/input/Win32InputMode';
+import { IKeyboardEvent, KeyboardResultType } from 'common/Types';
+
+function createEvent(partialEvent: Partial<IKeyboardEvent> = {}): IKeyboardEvent {
+  return {
+    altKey: partialEvent.altKey || false,
+    ctrlKey: partialEvent.ctrlKey || false,
+    shiftKey: partialEvent.shiftKey || false,
+    metaKey: partialEvent.metaKey || false,
+    keyCode: partialEvent.keyCode !== undefined ? partialEvent.keyCode : 0,
+    code: partialEvent.code || '',
+    key: partialEvent.key || '',
+    type: partialEvent.type || 'keydown'
+  };
+}
+
+function parseWin32Sequence(seq: string): { vk: number, sc: number, uc: number, kd: number, cs: number, rc: number } | null {
+  const match = seq.match(/^\x1b\[(\d+);(\d+);(\d+);(\d+);(\d+);(\d+)_$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    vk: parseInt(match[1], 10),
+    sc: parseInt(match[2], 10),
+    uc: parseInt(match[3], 10),
+    kd: parseInt(match[4], 10),
+    cs: parseInt(match[5], 10),
+    rc: parseInt(match[6], 10)
+  };
+}
+
+describe('Win32InputMode', () => {
+  describe('evaluateKeyboardEventWin32', () => {
+    describe('basic key encoding', () => {
+      it('should encode letter key press', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'KeyA', key: 'a', keyCode: 65 }), true);
+        assert.strictEqual(result.type, KeyboardResultType.SEND_KEY);
+        assert.strictEqual(result.cancel, true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x41);
+        assert.strictEqual(parsed.uc, 97);
+        assert.strictEqual(parsed.kd, 1);
+        assert.strictEqual(parsed.rc, 1);
+      });
+
+      it('should encode letter key release', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'KeyA', key: 'a', keyCode: 65 }), false);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.kd, 0);
+      });
+
+      it('should encode digit key', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Digit1', key: '1', keyCode: 49 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x31);
+        assert.strictEqual(parsed.uc, 49);
+      });
+
+      it('should encode Enter key', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Enter', key: 'Enter', keyCode: 13 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x0D);
+        assert.strictEqual(parsed.uc, 0);
+      });
+
+      it('should encode Escape key', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Escape', key: 'Escape', keyCode: 27 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x1B);
+      });
+
+      it('should encode Space key', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Space', key: ' ', keyCode: 32 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x20);
+        assert.strictEqual(parsed.uc, 32);
+      });
+    });
+
+    describe('modifier encoding', () => {
+      it('should encode shift modifier', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'KeyA',
+          key: 'A',
+          keyCode: 65,
+          shiftKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.SHIFT_PRESSED);
+      });
+
+      it('should encode ctrl modifier (left)', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'KeyA',
+          key: 'a',
+          keyCode: 65,
+          ctrlKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.LEFT_CTRL_PRESSED);
+      });
+
+      it('should encode ctrl modifier (right)', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'ControlRight',
+          key: 'Control',
+          keyCode: 17,
+          ctrlKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.RIGHT_CTRL_PRESSED);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+
+      it('should encode alt modifier (left)', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'KeyA',
+          key: 'a',
+          keyCode: 65,
+          altKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.LEFT_ALT_PRESSED);
+      });
+
+      it('should encode alt modifier (right)', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'AltRight',
+          key: 'Alt',
+          keyCode: 18,
+          altKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.RIGHT_ALT_PRESSED);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+
+      it('should encode multiple modifiers', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'KeyA',
+          key: 'A',
+          keyCode: 65,
+          shiftKey: true,
+          ctrlKey: true,
+          altKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.ok(parsed.cs & Win32ControlKeyState.SHIFT_PRESSED);
+        assert.ok(parsed.cs & Win32ControlKeyState.LEFT_CTRL_PRESSED);
+        assert.ok(parsed.cs & Win32ControlKeyState.LEFT_ALT_PRESSED);
+      });
+    });
+
+    describe('function keys', () => {
+      it('should encode F1', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'F1', key: 'F1', keyCode: 112 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x70);
+      });
+
+      it('should encode F12', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'F12', key: 'F12', keyCode: 123 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x7B);
+      });
+    });
+
+    describe('navigation keys', () => {
+      it('should encode arrow up with ENHANCED_KEY flag', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'ArrowUp', key: 'ArrowUp', keyCode: 38 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x26);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+
+      it('should encode Home with ENHANCED_KEY flag', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Home', key: 'Home', keyCode: 36 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x24);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+
+      it('should encode Insert with ENHANCED_KEY flag', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Insert', key: 'Insert', keyCode: 45 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x2D);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+
+      it('should encode Delete with ENHANCED_KEY flag', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Delete', key: 'Delete', keyCode: 46 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x2E);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+    });
+
+    describe('numpad keys', () => {
+      it('should encode Numpad0', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Numpad0', key: '0', keyCode: 96 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x60);
+      });
+
+      it('should encode NumpadEnter with ENHANCED_KEY', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'NumpadEnter', key: 'Enter', keyCode: 13 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.vk, 0x0D);
+        assert.ok(parsed.cs & Win32ControlKeyState.ENHANCED_KEY);
+      });
+    });
+
+    describe('unicode character', () => {
+      it('should include unicode codepoint for printable characters', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'KeyA', key: 'a', keyCode: 65 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.uc, 97);
+      });
+
+      it('should include unicode codepoint for shifted characters', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({
+          code: 'KeyA',
+          key: 'A',
+          keyCode: 65,
+          shiftKey: true
+        }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.uc, 65);
+      });
+
+      it('should set unicode to 0 for non-printable keys', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'ArrowUp', key: 'ArrowUp', keyCode: 38 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.uc, 0);
+      });
+    });
+
+    describe('scan codes', () => {
+      it('should include approximate scan code for letter', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'KeyA', key: 'a', keyCode: 65 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.sc, 0x1E);
+      });
+
+      it('should include approximate scan code for Escape', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'Escape', key: 'Escape', keyCode: 27 }), true);
+        const parsed = parseWin32Sequence(result.key!);
+        assert.ok(parsed);
+        assert.strictEqual(parsed.sc, 0x01);
+      });
+    });
+
+    describe('sequence format', () => {
+      it('should produce valid CSI sequence format', () => {
+        const result = evaluateKeyboardEventWin32(createEvent({ code: 'KeyA', key: 'a', keyCode: 65 }), true);
+        assert.ok(result.key);
+        assert.ok(result.key.startsWith('\x1b['));
+        assert.ok(result.key.endsWith('_'));
+        const parts = result.key.slice(2, -1).split(';');
+        assert.strictEqual(parts.length, 6);
+      });
+    });
+  });
+});

src/common/input/Win32InputMode.ts

@@ -0,0 +1,264 @@
+/**
+ * Copyright (c) 2026 The xterm.js authors. All rights reserved.
+ * @license MIT
+ *
+ * Win32 input mode implementation.
+ * @see https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md
+ *
+ * Format: CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _
+ *   Vk: Virtual key code (decimal)
+ *   Sc: Scan code (decimal)
+ *   Uc: Unicode character (decimal codepoint, 0 if none)
+ *   Kd: Key down (1) or up (0)
+ *   Cs: Control key state (modifier flags)
+ *   Rc: Repeat count (usually 1)
+ */
+
+import { IKeyboardEvent, IKeyboardResult, KeyboardResultType } from 'common/Types';
+import { C0 } from 'common/data/EscapeSequences';
+
+/**
+ * Win32 control key state flags (from Windows API).
+ */
+export const enum Win32ControlKeyState {
+  RIGHT_ALT_PRESSED   = 0x0001,
+  LEFT_ALT_PRESSED    = 0x0002,
+  RIGHT_CTRL_PRESSED  = 0x0004,
+  LEFT_CTRL_PRESSED   = 0x0008,
+  SHIFT_PRESSED       = 0x0010,
+  NUMLOCK_ON          = 0x0020,
+  SCROLLLOCK_ON       = 0x0040,
+  CAPSLOCK_ON         = 0x0080,
+  ENHANCED_KEY        = 0x0100,
+}
+
+/**
+ * Mapping from browser KeyboardEvent.code to Win32 virtual key codes.
+ * Based on https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+ */
+const CODE_TO_VK: { [code: string]: number } = {
+  // Letters
+  'KeyA': 0x41, 'KeyB': 0x42, 'KeyC': 0x43, 'KeyD': 0x44, 'KeyE': 0x45,
+  'KeyF': 0x46, 'KeyG': 0x47, 'KeyH': 0x48, 'KeyI': 0x49, 'KeyJ': 0x4A,
+  'KeyK': 0x4B, 'KeyL': 0x4C, 'KeyM': 0x4D, 'KeyN': 0x4E, 'KeyO': 0x4F,
+  'KeyP': 0x50, 'KeyQ': 0x51, 'KeyR': 0x52, 'KeyS': 0x53, 'KeyT': 0x54,
+  'KeyU': 0x55, 'KeyV': 0x56, 'KeyW': 0x57, 'KeyX': 0x58, 'KeyY': 0x59,
+  'KeyZ': 0x5A,
+
+  // Digits
+  'Digit0': 0x30, 'Digit1': 0x31, 'Digit2': 0x32, 'Digit3': 0x33, 'Digit4': 0x34,
+  'Digit5': 0x35, 'Digit6': 0x36, 'Digit7': 0x37, 'Digit8': 0x38, 'Digit9': 0x39,
+
+  // Function keys
+  'F1': 0x70, 'F2': 0x71, 'F3': 0x72, 'F4': 0x73, 'F5': 0x74, 'F6': 0x75,
+  'F7': 0x76, 'F8': 0x77, 'F9': 0x78, 'F10': 0x79, 'F11': 0x7A, 'F12': 0x7B,
+  'F13': 0x7C, 'F14': 0x7D, 'F15': 0x7E, 'F16': 0x7F, 'F17': 0x80, 'F18': 0x81,
+  'F19': 0x82, 'F20': 0x83, 'F21': 0x84, 'F22': 0x85, 'F23': 0x86, 'F24': 0x87,
+
+  // Numpad
+  'Numpad0': 0x60, 'Numpad1': 0x61, 'Numpad2': 0x62, 'Numpad3': 0x63, 'Numpad4': 0x64,
+  'Numpad5': 0x65, 'Numpad6': 0x66, 'Numpad7': 0x67, 'Numpad8': 0x68, 'Numpad9': 0x69,
+  'NumpadMultiply': 0x6A, 'NumpadAdd': 0x6B, 'NumpadSeparator': 0x6C,
+  'NumpadSubtract': 0x6D, 'NumpadDecimal': 0x6E, 'NumpadDivide': 0x6F,
+  'NumpadEnter': 0x0D, // Same as Enter but with ENHANCED_KEY flag
+  'NumLock': 0x90,
+
+  // Navigation
+  'ArrowUp': 0x26, 'ArrowDown': 0x28, 'ArrowLeft': 0x25, 'ArrowRight': 0x27,
+  'Home': 0x24, 'End': 0x23, 'PageUp': 0x21, 'PageDown': 0x22,
+  'Insert': 0x2D, 'Delete': 0x2E,
+
+  // Modifiers
+  'ShiftLeft': 0x10, 'ShiftRight': 0x10,
+  'ControlLeft': 0x11, 'ControlRight': 0x11,
+  'AltLeft': 0x12, 'AltRight': 0x12,
+  'MetaLeft': 0x5B, 'MetaRight': 0x5C,
+  'CapsLock': 0x14, 'ScrollLock': 0x91,
+
+  // Special keys
+  'Escape': 0x1B, 'Enter': 0x0D, 'Tab': 0x09, 'Space': 0x20,
+  'Backspace': 0x08, 'Pause': 0x13, 'ContextMenu': 0x5D, 'PrintScreen': 0x2C,
+
+  // OEM keys (US keyboard layout)
+  'Semicolon': 0xBA,      // ;:
+  'Equal': 0xBB,          // =+
+  'Comma': 0xBC,          // ,<
+  'Minus': 0xBD,          // -_
+  'Period': 0xBE,         // .>
+  'Slash': 0xBF,          // /?
+  'Backquote': 0xC0,      // `~
+  'BracketLeft': 0xDB,    // [{
+  'Backslash': 0xDC,      // \|
+  'BracketRight': 0xDD,   // ]}
+  'Quote': 0xDE,          // '"
+  'IntlBackslash': 0xE2,  // Non-US backslash
+};
+
+/**
+ * Mapping from browser KeyboardEvent.code to approximate Win32 scan codes.
+ * Note: Scan codes can vary by keyboard layout. These are approximations
+ * based on standard US keyboard layout.
+ */
+const CODE_TO_SCANCODE: { [code: string]: number } = {
+  // Letters (row by row)
+  'KeyQ': 0x10, 'KeyW': 0x11, 'KeyE': 0x12, 'KeyR': 0x13, 'KeyT': 0x14,
+  'KeyY': 0x15, 'KeyU': 0x16, 'KeyI': 0x17, 'KeyO': 0x18, 'KeyP': 0x19,
+  'KeyA': 0x1E, 'KeyS': 0x1F, 'KeyD': 0x20, 'KeyF': 0x21, 'KeyG': 0x22,
+  'KeyH': 0x23, 'KeyJ': 0x24, 'KeyK': 0x25, 'KeyL': 0x26,
+  'KeyZ': 0x2C, 'KeyX': 0x2D, 'KeyC': 0x2E, 'KeyV': 0x2F, 'KeyB': 0x30,
+  'KeyN': 0x31, 'KeyM': 0x32,
+
+  // Digits
+  'Digit1': 0x02, 'Digit2': 0x03, 'Digit3': 0x04, 'Digit4': 0x05, 'Digit5': 0x06,
+  'Digit6': 0x07, 'Digit7': 0x08, 'Digit8': 0x09, 'Digit9': 0x0A, 'Digit0': 0x0B,
+
+  // Function keys
+  'F1': 0x3B, 'F2': 0x3C, 'F3': 0x3D, 'F4': 0x3E, 'F5': 0x3F, 'F6': 0x40,
+  'F7': 0x41, 'F8': 0x42, 'F9': 0x43, 'F10': 0x44, 'F11': 0x57, 'F12': 0x58,
+
+  // Numpad
+  'Numpad0': 0x52, 'Numpad1': 0x4F, 'Numpad2': 0x50, 'Numpad3': 0x51, 'Numpad4': 0x4B,
+  'Numpad5': 0x4C, 'Numpad6': 0x4D, 'Numpad7': 0x47, 'Numpad8': 0x48, 'Numpad9': 0x49,
+  'NumpadMultiply': 0x37, 'NumpadAdd': 0x4E, 'NumpadSubtract': 0x4A,
+  'NumpadDecimal': 0x53, 'NumpadDivide': 0x35, 'NumpadEnter': 0x1C,
+  'NumLock': 0x45,
+
+  // Navigation (extended keys)
+  'ArrowUp': 0x48, 'ArrowDown': 0x50, 'ArrowLeft': 0x4B, 'ArrowRight': 0x4D,
+  'Home': 0x47, 'End': 0x4F, 'PageUp': 0x49, 'PageDown': 0x51,
+  'Insert': 0x52, 'Delete': 0x53,
+
+  // Modifiers
+  'ShiftLeft': 0x2A, 'ShiftRight': 0x36,
+  'ControlLeft': 0x1D, 'ControlRight': 0x1D,
+  'AltLeft': 0x38, 'AltRight': 0x38,
+  'CapsLock': 0x3A, 'ScrollLock': 0x46,
+
+  // Special keys
+  'Escape': 0x01, 'Enter': 0x1C, 'Tab': 0x0F, 'Space': 0x39,
+  'Backspace': 0x0E, 'Pause': 0x45,
+
+  // OEM keys
+  'Semicolon': 0x27, 'Equal': 0x0D, 'Comma': 0x33, 'Minus': 0x0C,
+  'Period': 0x34, 'Slash': 0x35, 'Backquote': 0x29,
+  'BracketLeft': 0x1A, 'Backslash': 0x2B, 'BracketRight': 0x1B, 'Quote': 0x28,
+};
+
+/**
+ * Codes that represent enhanced keys (extended keyboard keys).
+ */
+const ENHANCED_KEY_CODES = new Set([
+  'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight',
+  'Home', 'End', 'PageUp', 'PageDown', 'Insert', 'Delete',
+  'NumpadEnter', 'NumpadDivide',
+  'ControlRight', 'AltRight',
+  'PrintScreen', 'Pause', 'ContextMenu',
+  'MetaLeft', 'MetaRight',
+]);
+
+/**
+ * Get the Win32 virtual key code for a keyboard event.
+ */
+function getVirtualKeyCode(ev: IKeyboardEvent): number {
+  // Try code-based lookup first
+  const vk = CODE_TO_VK[ev.code];
+  if (vk !== undefined) {
+    return vk;
+  }
+
+  // Fall back to keyCode for unmapped keys
+  // Note: keyCode is deprecated but provides reasonable fallback
+  return ev.keyCode || 0;
+}
+
+/**
+ * Get the Win32 scan code for a keyboard event.
+ * Returns 0 if unknown (scan codes vary by hardware).
+ */
+function getScanCode(ev: IKeyboardEvent): number {
+  return CODE_TO_SCANCODE[ev.code] || 0;
+}
+
+/**
+ * Get the unicode character for a keyboard event.
+ * Returns 0 for non-character keys.
+ */
+function getUnicodeChar(ev: IKeyboardEvent): number {
+  // Only single-character keys produce unicode output
+  if (ev.key.length === 1) {
+    return ev.key.codePointAt(0) || 0;
+  }
+  return 0;
+}
+
+/**
+ * Get the Win32 control key state flags.
+ */
+function getControlKeyState(ev: IKeyboardEvent): number {
+  let state = 0;
+
+  if (ev.shiftKey) {
+    state |= Win32ControlKeyState.SHIFT_PRESSED;
+  }
+
+  // Note: We can't distinguish left/right for ctrl/alt in standard browser events,
+  // so we use the generic pressed flags. The right-side flags are used when
+  // we can detect them (e.g., via code property).
+  if (ev.ctrlKey) {
+    if (ev.code === 'ControlRight') {
+      state |= Win32ControlKeyState.RIGHT_CTRL_PRESSED;
+    } else {
+      state |= Win32ControlKeyState.LEFT_CTRL_PRESSED;
+    }
+  }
+
+  if (ev.altKey) {
+    if (ev.code === 'AltRight') {
+      state |= Win32ControlKeyState.RIGHT_ALT_PRESSED;
+    } else {
+      state |= Win32ControlKeyState.LEFT_ALT_PRESSED;
+    }
+  }
+
+  // Check for enhanced key
+  if (ENHANCED_KEY_CODES.has(ev.code)) {
+    state |= Win32ControlKeyState.ENHANCED_KEY;
+  }
+
+  // Note: CapsLock, NumLock, ScrollLock states are not reliably available
+  // in standard browser keyboard events. We could potentially detect them
+  // via getModifierState() but this may not be available in all environments.
+
+  return state;
+}
+
+/**
+ * Evaluate a keyboard event using Win32 input mode.
+ *
+ * @param ev The keyboard event.
+ * @param isKeyDown Whether this is a keydown (true) or keyup (false) event.
+ * @returns The keyboard result with the encoded key sequence.
+ */
+export function evaluateKeyboardEventWin32(
+  ev: IKeyboardEvent,
+  isKeyDown: boolean
+): IKeyboardResult {
+  const result: IKeyboardResult = {
+    type: KeyboardResultType.SEND_KEY,
+    cancel: false,
+    key: undefined
+  };
+
+  const vk = getVirtualKeyCode(ev);
+  const sc = getScanCode(ev);
+  const uc = getUnicodeChar(ev);
+  const kd = isKeyDown ? 1 : 0;
+  const cs = getControlKeyState(ev);
+  const rc = 1; // Repeat count, always 1 for now
+
+  // Format: CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _
+  result.key = `${C0.ESC}[${vk};${sc};${uc};${kd};${cs};${rc}_`;
+  result.cancel = true;
+
+  return result;
+}

src/common/services/CoreService.ts

@@ -23,6 +23,7 @@ const DEFAULT_DEC_PRIVATE_MODES: IDecPrivateModes = Object.freeze({
   reverseWraparound: false,
   sendFocus: false,
   synchronizedOutput: false,
+  win32InputMode: false,
   wraparound: true // defaults: xterm - true, vt100 - false
 });
 

src/common/services/Services.ts

@@ -311,6 +311,7 @@ export interface ITerminalQuirks {
 export interface IVtExtensions {
   kittyKeyboard?: boolean;
   kittySgrBoldFaintControl?: boolean;
+  win32InputMode?: boolean;
 }
 
 export const IOscLinkService = createDecorator<IOscLinkService>('OscLinkService');

src/headless/public/Terminal.ts

@@ -124,6 +124,7 @@ export class Terminal extends Disposable implements ITerminalApi {
       sendFocusMode: m.sendFocus,
       showCursor: !this._core.coreService.isCursorHidden,
       synchronizedOutputMode: m.synchronizedOutput,
+      win32InputMode: m.win32InputMode,
       wraparoundMode: m.wraparound
     };
   }

typings/xterm-headless.d.ts

@@ -340,6 +340,15 @@ declare module '@xterm/headless' {
      * [0]: https://sw.kovidgoyal.net/kitty/misc-protocol/
      */
     kittySgrBoldFaintControl?: boolean;
+
+    /**
+     * Whether [win32-input-mode][0] (`DECSET 9001`) is enabled. When enabled,
+     * the terminal will allow programs to enable win32 INPUT_RECORD  keyboard
+     * reporting via `CSI ? 9001 h`. The default is false.
+     *
+     * [0]: https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md
+     */
+    win32InputMode?: boolean;
   }
 
   /**
@@ -1387,6 +1396,13 @@ declare module '@xterm/headless' {
      * disabled, allowing for atomic screen updates without tearing.
      */
     readonly synchronizedOutputMode: boolean;
+    /**
+     * Win32 Input Mode: `CSI ? 9 0 0 1 h`
+     *
+     * When enabled, keyboard input is sent as Win32 INPUT_RECORD format:
+     * `CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _`
+     */
+    readonly win32InputMode: boolean;
     /**
      * Auto-Wrap Mode (DECAWM): `CSI ? 7 h`
      */

typings/xterm.d.ts

@@ -457,6 +457,15 @@ declare module '@xterm/xterm' {
      * [0]: https://sw.kovidgoyal.net/kitty/misc-protocol/
      */
     kittySgrBoldFaintControl?: boolean;
+
+    /**
+     * Whether [win32-input-mode][0] (`DECSET 9001`) is enabled. When enabled,
+     * the terminal will allow programs to enable win32 INPUT_RECORD  keyboard
+     * reporting via `CSI ? 9001 h`. The default is false.
+     *
+     * [0]: https://github.com/microsoft/terminal/blob/main/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md
+     */
+    win32InputMode?: boolean;
   }
 
   /**
@@ -2007,6 +2016,13 @@ declare module '@xterm/xterm' {
      * disabled, allowing for atomic screen updates without tearing.
      */
     readonly synchronizedOutputMode: boolean;
+    /**
+     * Win32 Input Mode: `CSI ? 9 0 0 1 h`
+     *
+     * When enabled, keyboard input is sent as Win32 INPUT_RECORD format:
+     * `CSI Vk ; Sc ; Uc ; Kd ; Cs ; Rc _`
+     */
+    readonly win32InputMode: boolean;
     /**
      * Auto-Wrap Mode (DECAWM): `CSI ? 7 h`
      */