fix(input): enable Alt→ESC prefix and fix macOS Alt-transformed keys (#18)

Fixes two keyboard issues from upstream coder#109:

1. Shift+Tab now produces the standard backtab sequence (CSI Z / \x1b[Z)
   via the Ghostty encoder with SHIFT modifier on Key.TAB.

2. Alt+letter on macOS: Alt transforms event.key to Unicode (Alt+T → '†').
   The encoder now receives the correct letter by deriving utf8 from
   event.code (KeyT → 't') when altKey is set and event.key is non-ASCII.

3. Enable ALT_ESC_PREFIX (DEC mode 1036) by default so the encoder emits
   ESC+letter for Alt-modified keys, matching xterm metaSendsEscape
   default behavior.

Inspired by: coder#109

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: diegosouzapw

lib/input-handler.test.ts

@@ -587,6 +587,42 @@ describe('InputHandler', () => {
       expect(dataReceived[0]).toBe('\t');
     });
 
+    // https://github.com/coder/ghostty-web/issues/109
+    test('Shift+Tab produces backtab sequence (CSI Z)', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => {
+          bellCalled = true;
+        }
+      );
+
+      simulateKey(container, createKeyEvent('Tab', 'Tab', { shift: true }));
+
+      expect(dataReceived.length).toBe(1);
+      expect(dataReceived[0]).toBe('\x1b[Z');
+    });
+
+    // https://github.com/coder/ghostty-web/issues/109
+    test('Alt+letter uses physical key (event.code) not transformed macOS character', () => {
+      const handler = new InputHandler(
+        ghostty,
+        container as any,
+        (data) => dataReceived.push(data),
+        () => {
+          bellCalled = true;
+        }
+      );
+
+      // On macOS, Alt+T produces '†' in event.key; we should encode Alt+T (ESC t) instead
+      simulateKey(container, createKeyEvent('KeyT', '†', { alt: true }));
+
+      expect(dataReceived.length).toBe(1);
+      // Alt+T should produce ESC + t, NOT the raw macOS Unicode character
+      expect(dataReceived[0]).toBe('\x1bt');
+    });
+
     test('encodes Escape', () => {
       const handler = new InputHandler(
         ghostty,

lib/input-handler.ts

@@ -244,6 +244,8 @@ export class InputHandler {
     mouseConfig?: MouseTrackingConfig
   ) {
     this.encoder = ghostty.createKeyEncoder();
+    // Enable Alt → ESC+letter by default (xterm metaSendsEscape / DEC mode 1036).
+    this.encoder.setOption(KeyEncoderOption.ALT_ESC_PREFIX, true);
     this.container = container;
     this.inputElement = inputElement;
     this.onDataCallback = onData;
@@ -452,11 +454,25 @@ export class InputHandler {
     // Case is preserved intentionally: the encoder uses the utf8 byte to
     // pick the C0 sequence for Ctrl+letter, and needs the actual shifted
     // character for the text-output path.
+    //
+    // macOS transforms Alt+letter to a Unicode char (e.g. Alt+T → '†').
+    // When that happens event.key is non-ASCII, so we fall back to
+    // deriving the utf8 from event.code (KeyT → 't') so the encoder can
+    // produce the correct ESC+letter sequence. See issue #109.
     let utf8: string | undefined;
     if (event.key.length > 0 && event.key !== 'Dead' && event.key !== 'Unidentified') {
       const cp = event.key.codePointAt(0);
       const scalarLen = cp !== undefined && cp > 0xffff ? 2 : 1;
-      if (event.key.length === scalarLen) utf8 = event.key;
+      if (event.key.length === scalarLen) {
+        if (event.altKey && cp !== undefined && cp > 127) {
+          // macOS Alt-transformed character — derive from physical key code
+          if (event.code.startsWith('Key') && event.code.length === 4) {
+            utf8 = event.code[3].toLowerCase();
+          }
+        } else {
+          utf8 = event.key;
+        }
+      }
     }
 
     // Sync encoder options with terminal mode state before every encode.