ac6502 1.9.2 → 1.10.0

package/src/tests/IO/Attachments/KeyboardEncoderAttachment.test.ts

@@ -20,7 +20,7 @@ describe('KeyboardEncoderAttachment', () => {
 
     it('should be disabled by default (CA2/CB2 high)', () => {
       encoder.updateControlLines(false, true, false, true)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(false)
       expect(encoder.hasCB1Interrupt()).toBe(false)
     })
@@ -32,51 +32,60 @@ describe('KeyboardEncoderAttachment', () => {
 
   describe('Reset', () => {
     it('should clear all data and states', () => {
-      // Enable and generate some data
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasDataReadyA()).toBe(true)
 
-      // Reset
       encoder.reset()
       expect(encoder.hasDataReadyA()).toBe(false)
       expect(encoder.hasDataReadyB()).toBe(false)
       expect(encoder.hasCA1Interrupt()).toBe(false)
       expect(encoder.hasCB1Interrupt()).toBe(false)
     })
+
+    it('should clear modifier states on reset', () => {
+      encoder.updateControlLines(false, false, false, false)
+      // Press Shift, then reset
+      encoder.updateKey(0xE1, true)  // Left Shift down
+      encoder.reset()
+      encoder.updateControlLines(false, false, false, false)
+      // After reset, Shift should be released - numbers produce numbers, not symbols
+      encoder.updateKey(0x1E, true)  // '1'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x31)  // '1', not '!'
+    })
   })
 
   describe('Enable/Disable Control', () => {
     it('should enable Port A when CA2 is LOW', () => {
       encoder.updateControlLines(false, false, false, true)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(true)
       expect(encoder.hasCB1Interrupt()).toBe(false)
     })
 
     it('should enable Port B when CB2 is LOW', () => {
       encoder.updateControlLines(false, true, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(false)
       expect(encoder.hasCB1Interrupt()).toBe(true)
     })
 
     it('should enable both ports when both CA2 and CB2 are LOW', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(true)
       expect(encoder.hasCB1Interrupt()).toBe(true)
     })
 
     it('should disable Port A when CA2 is HIGH', () => {
       encoder.updateControlLines(false, true, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(false)
     })
 
     it('should disable Port B when CB2 is HIGH', () => {
       encoder.updateControlLines(false, false, false, true)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCB1Interrupt()).toBe(false)
     })
   })
@@ -94,32 +103,32 @@ describe('KeyboardEncoderAttachment', () => {
 
     it('should return ASCII data when data ready on Port A', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a' = 0x61
+      encoder.updateKey(0x04, true)  // 'A' = 0x41
       const value = encoder.readPortA(0xFF, 0x00)
-      expect(value).toBe(0x61)
+      expect(value).toBe(0x41)
     })
 
     it('should return ASCII data when data ready on Port B', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a' = 0x61
+      encoder.updateKey(0x04, true)  // 'A' = 0x41
       const value = encoder.readPortB(0xFF, 0x00)
-      expect(value).toBe(0x61)
+      expect(value).toBe(0x41)
     })
 
     it('should return 0xFF on disabled port even with data ready', () => {
       encoder.updateControlLines(false, true, false, true)  // Both disabled
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFF)
       expect(encoder.readPortB(0xFF, 0x00)).toBe(0xFF)
     })
 
     it('should provide same data on both ports', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       const valueA = encoder.readPortA(0xFF, 0x00)
       const valueB = encoder.readPortB(0xFF, 0x00)
       expect(valueA).toBe(valueB)
-      expect(valueA).toBe(0x61)
+      expect(valueA).toBe(0x41)
     })
   })
 
@@ -127,20 +136,20 @@ describe('KeyboardEncoderAttachment', () => {
     it('should trigger CA1 interrupt when Port A enabled and key pressed', () => {
       encoder.updateControlLines(false, false, false, true)
       expect(encoder.hasCA1Interrupt()).toBe(false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(true)
     })
 
     it('should trigger CB1 interrupt when Port B enabled and key pressed', () => {
       encoder.updateControlLines(false, true, false, false)
       expect(encoder.hasCB1Interrupt()).toBe(false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCB1Interrupt()).toBe(true)
     })
 
     it('should clear CA1 interrupt and data ready when cleared', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(true)
       expect(encoder.hasDataReadyA()).toBe(true)
 
@@ -151,7 +160,7 @@ describe('KeyboardEncoderAttachment', () => {
 
     it('should clear CB1 interrupt and data ready when cleared', () => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCB1Interrupt()).toBe(true)
       expect(encoder.hasDataReadyB()).toBe(true)
 
@@ -162,380 +171,356 @@ describe('KeyboardEncoderAttachment', () => {
 
     it('should not trigger interrupt when port is disabled', () => {
       encoder.updateControlLines(false, true, false, true)  // Both disabled
-      encoder.updateKey(0x04, true)  // 'a'
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.hasCA1Interrupt()).toBe(false)
       expect(encoder.hasCB1Interrupt()).toBe(false)
     })
   })
 
-  describe('Basic Key Mapping', () => {
+  describe('Letter Key Mapping', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
     })
 
-    it('should map lowercase letters correctly', () => {
-      encoder.updateKey(0x04, true)  // 'a'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x1D, true)  // 'z'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7A)
-    })
-
-    it('should map numbers correctly', () => {
-      encoder.updateKey(0x1E, true)  // '1'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x31)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x27, true)  // '0'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x30)
-    })
-
-    it('should map special keys correctly', () => {
-      encoder.updateKey(0x28, true)  // Enter
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0D)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x29, true)  // Escape
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B)
+    it('should output uppercase letters A-Z', () => {
+      // 'A' (HID 0x04)
+      encoder.updateKey(0x04, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
 
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x2C, true)  // Space
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x20)
+      // 'Z' (HID 0x1D)
+      encoder.updateKey(0x1D, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x5A)
     })
 
-    it('should ignore key releases', () => {
-      encoder.updateKey(0x04, true)   // Press 'a'
-      expect(encoder.hasDataReadyA()).toBe(true)
+    it('should output uppercase letters even with Shift held', () => {
+      encoder.updateKey(0xE1, true)  // Left Shift down
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)  // Still uppercase A
 
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x04, false)  // Release 'a'
-      expect(encoder.hasDataReadyA()).toBe(false)  // No new data
-    })
-
-    it('should ignore unknown keycodes', () => {
-      encoder.updateKey(0xFF, true)  // Invalid keycode
-      expect(encoder.hasDataReadyA()).toBe(false)
+      encoder.updateKey(0x10, true)  // 'M'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x4D)  // Still uppercase M
+    })
+
+    it('should map all letters correctly', () => {
+      const letterMap: [number, number][] = [
+        [0x04, 0x41], [0x05, 0x42], [0x06, 0x43], [0x07, 0x44],
+        [0x08, 0x45], [0x09, 0x46], [0x0A, 0x47], [0x0B, 0x48],
+        [0x0C, 0x49], [0x0D, 0x4A], [0x0E, 0x4B], [0x0F, 0x4C],
+        [0x10, 0x4D], [0x11, 0x4E], [0x12, 0x4F], [0x13, 0x50],
+        [0x14, 0x51], [0x15, 0x52], [0x16, 0x53], [0x17, 0x54],
+        [0x18, 0x55], [0x19, 0x56], [0x1A, 0x57], [0x1B, 0x58],
+        [0x1C, 0x59], [0x1D, 0x5A],
+      ]
+      for (const [hid, ascii] of letterMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
     })
   })
 
-  describe('Modifier Keys', () => {
+  describe('Number Key Mapping', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
     })
 
-    it('should not generate output for modifier keys alone', () => {
-      encoder.updateKey(0xE0, true)  // Left Ctrl
-      expect(encoder.hasDataReadyA()).toBe(false)
-
-      encoder.updateKey(0xE1, true)  // Left Shift
-      expect(encoder.hasDataReadyA()).toBe(false)
-
-      encoder.updateKey(0xE2, true)  // Left Alt
-      expect(encoder.hasDataReadyA()).toBe(false)
-    })
-
-    it('should track modifier key state across presses', () => {
-      // Press Shift
-      encoder.updateKey(0xE1, true)
-      encoder.updateKey(0x04, true)  // 'a' -> 'A'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
+    it('should map numbers correctly', () => {
+      encoder.updateKey(0x1E, true)  // '1'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x31)
 
-      // Release Shift
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0xE1, false)
-      encoder.updateKey(0x04, true)  // 'a'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)
+      encoder.updateKey(0x27, true)  // '0'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x30)
     })
 
-    it('should handle both left and right modifiers', () => {
-      // Left Ctrl
-      encoder.updateKey(0xE0, true)
-      encoder.updateKey(0x04, true)  // Ctrl+a
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x01)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0xE0, false)
-
-      // Right Ctrl
-      encoder.updateKey(0xE4, true)
-      encoder.updateKey(0x04, true)  // Ctrl+a
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x01)
+    it('should map all number keys 0-9', () => {
+      const numberMap: [number, number][] = [
+        [0x1E, 0x31], [0x1F, 0x32], [0x20, 0x33], [0x21, 0x34],
+        [0x22, 0x35], [0x23, 0x36], [0x24, 0x37], [0x25, 0x38],
+        [0x26, 0x39], [0x27, 0x30],
+      ]
+      for (const [hid, ascii] of numberMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
     })
   })
 
-  describe('Shift Key Mapping', () => {
+  describe('Special Key Mapping', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
     })
 
-    it('should map Shift+letter to uppercase', () => {
-      encoder.updateKey(0xE1, true)  // Press Shift
-      encoder.updateKey(0x04, true)  // 'a' -> 'A'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
+    it('should map Enter to CR (0x0D)', () => {
+      encoder.updateKey(0x28, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0D)
     })
 
-    it('should map Shift+number to symbols', () => {
-      encoder.updateKey(0xE1, true)  // Press Shift
-      encoder.updateKey(0x1E, true)  // '1' -> '!'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x21)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x25, true)  // '8' -> '*'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x2A)
+    it('should map Escape to ESC (0x1B)', () => {
+      encoder.updateKey(0x29, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B)
     })
 
-    it('should map Shift+special keys to shifted symbols', () => {
-      encoder.updateKey(0xE1, true)  // Press Shift
-
-      encoder.updateKey(0x2D, true)  // '-' -> '_'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x5F)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x2E, true)  // '=' -> '+'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x2B)
+    it('should map Backspace to BS (0x08)', () => {
+      encoder.updateKey(0x2A, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x08)
+    })
 
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x2F, true)  // '[' -> '{'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7B)
+    it('should map Tab to HT (0x09)', () => {
+      encoder.updateKey(0x2B, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x09)
     })
-  })
 
-  describe('Ctrl Key Mapping', () => {
-    beforeEach(() => {
-      encoder.updateControlLines(false, false, false, false)
+    it('should map Space to SP (0x20)', () => {
+      encoder.updateKey(0x2C, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x20)
     })
 
-    it('should map Ctrl+letter to control codes', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0x04, true)  // Ctrl+a -> 0x01
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x01)
+    it('should map Delete to DEL (0x7F)', () => {
+      encoder.updateKey(0x4C, true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7F)
+    })
 
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x1D, true)  // Ctrl+z -> 0x1A
+    it('should map Insert to SUB (0x1A)', () => {
+      encoder.updateKey(0x49, true)
       expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1A)
     })
 
-    it('should map Ctrl+special keys to control codes', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-
-      encoder.updateKey(0x2F, true)  // Ctrl+[ -> ESC (0x1B)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B)
+    it('should map arrow keys correctly', () => {
+      encoder.updateKey(0x4F, true)  // Right Arrow
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1D)
 
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x31, true)  // Ctrl+\ -> FS (0x1C)
+      encoder.updateKey(0x50, true)  // Left Arrow
       expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1C)
 
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x30, true)  // Ctrl+] -> GS (0x1D)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1D)
-    })
-
-    it('should map Ctrl+2 to NUL', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0x1F, true)  // Ctrl+2 -> 0x00
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x00)
-    })
+      encoder.updateKey(0x51, true)  // Down Arrow
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1F)
 
-    it('should map Ctrl+6 to RS (UP arrow)', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0x23, true)  // Ctrl+6 -> 0x1E
+      encoder.clearInterrupts(true, false, true, false)
+      encoder.updateKey(0x52, true)  // Up Arrow
       expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1E)
     })
 
-    it('should map Ctrl+- to US (DOWN arrow)', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0x2D, true)  // Ctrl+- -> 0x1F
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1F)
+    it('should map symbol keys correctly', () => {
+      const symbolMap: [number, number][] = [
+        [0x2D, 0x2D], // -
+        [0x2E, 0x3D], // =
+        [0x2F, 0x5B], // [
+        [0x30, 0x5D], // ]
+        [0x31, 0x5C], // backslash
+        [0x33, 0x3B], // ;
+        [0x34, 0x27], // '
+        [0x35, 0x60], // `
+        [0x36, 0x2C], // ,
+        [0x37, 0x2E], // .
+        [0x38, 0x2F], // /
+      ]
+      for (const [hid, ascii] of symbolMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
     })
   })
 
-  describe('MENU Key Mapping', () => {
+  describe('Shift Key Mapping', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
-    })
-
-    it('should map MENU key to 0x80', () => {
-      encoder.updateKey(0xE3, true)  // Left GUI (MENU)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x80)
-    })
-
-    it('should map Alt+MENU to 0x90', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE3, true)  // MENU
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x90)
-    })
-
-    it('should handle Right GUI as MENU', () => {
-      encoder.updateKey(0xE7, true)  // Right GUI (MENU)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x80)
+      encoder.updateKey(0xE1, true)  // Left Shift down
+    })
+
+    it('should produce shifted number symbols', () => {
+      const shiftNumberMap: [number, number][] = [
+        [0x1E, 0x21], // '1' -> '!'
+        [0x1F, 0x40], // '2' -> '@'
+        [0x20, 0x23], // '3' -> '#'
+        [0x21, 0x24], // '4' -> '$'
+        [0x22, 0x25], // '5' -> '%'
+        [0x23, 0x5E], // '6' -> '^'
+        [0x24, 0x26], // '7' -> '&'
+        [0x25, 0x2A], // '8' -> '*'
+        [0x26, 0x28], // '9' -> '('
+        [0x27, 0x29], // '0' -> ')'
+      ]
+      for (const [hid, ascii] of shiftNumberMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
+    })
+
+    it('should produce shifted symbol keys', () => {
+      const shiftSymbolMap: [number, number][] = [
+        [0x2D, 0x5F], // '-' -> '_'
+        [0x2E, 0x2B], // '=' -> '+'
+        [0x2F, 0x7B], // '[' -> '{'
+        [0x30, 0x7D], // ']' -> '}'
+        [0x31, 0x7C], // '\\' -> '|'
+        [0x33, 0x3A], // ';' -> ':'
+        [0x34, 0x22], // '\'' -> '"'
+        [0x36, 0x3C], // ',' -> '<'
+        [0x37, 0x3E], // '.' -> '>'
+        [0x38, 0x3F], // '/' -> '?'
+        [0x35, 0x7E], // '`' -> '~'
+      ]
+      for (const [hid, ascii] of shiftSymbolMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
+    })
+
+    it('should not change letter output when Shift is held (already uppercase)', () => {
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)  // Still 'A'
+    })
+
+    it('should track right Shift the same as left Shift', () => {
+      encoder.updateKey(0xE1, false)  // Release left Shift
+      encoder.updateKey(0xE5, true)   // Right Shift down
+      encoder.updateKey(0x1E, true)   // '1'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x21)  // '!'
     })
   })
 
-  describe('Function Key Mapping', () => {
+  describe('Ctrl Key Mapping', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
+      encoder.updateKey(0xE0, true)  // Left Ctrl down
+    })
+
+    it('should produce control codes for Ctrl+A through Ctrl+Z', () => {
+      const ctrlLetterMap: [number, number][] = [
+        [0x04, 0x01], // Ctrl+A
+        [0x05, 0x02], // Ctrl+B
+        [0x06, 0x03], // Ctrl+C
+        [0x07, 0x04], // Ctrl+D
+        [0x08, 0x05], // Ctrl+E
+        [0x09, 0x06], // Ctrl+F
+        [0x0A, 0x07], // Ctrl+G
+        [0x0B, 0x08], // Ctrl+H
+        [0x0C, 0x09], // Ctrl+I
+        [0x0D, 0x0A], // Ctrl+J
+        [0x0E, 0x0B], // Ctrl+K
+        [0x0F, 0x0C], // Ctrl+L
+        [0x10, 0x0D], // Ctrl+M
+        [0x11, 0x0E], // Ctrl+N
+        [0x12, 0x0F], // Ctrl+O
+        [0x13, 0x10], // Ctrl+P
+        [0x14, 0x11], // Ctrl+Q
+        [0x15, 0x12], // Ctrl+R
+        [0x16, 0x13], // Ctrl+S
+        [0x17, 0x14], // Ctrl+T
+        [0x18, 0x15], // Ctrl+U
+        [0x19, 0x16], // Ctrl+V
+        [0x1A, 0x17], // Ctrl+W
+        [0x1B, 0x18], // Ctrl+X
+        [0x1C, 0x19], // Ctrl+Y
+        [0x1D, 0x1A], // Ctrl+Z
+      ]
+      for (const [hid, ascii] of ctrlLetterMap) {
+        encoder.clearInterrupts(true, false, true, false)
+        encoder.updateKey(hid, true)
+        expect(encoder.readPortA(0xFF, 0x00)).toBe(ascii)
+      }
+    })
+
+    it('should produce Ctrl+C = 0x03 (BASIC break)', () => {
+      encoder.updateKey(0x06, true)  // 'C'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x03)
+    })
+
+    it('should produce Ctrl+2 = NUL (0x00)', () => {
+      encoder.updateKey(0x1F, true)  // '2'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x00)
     })
 
-    it('should map F1-F12 to 0x81-0x8C', () => {
-      encoder.updateKey(0x3A, true)  // F1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x81)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x3B, true)  // F2
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x82)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x45, true)  // F12
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x8C)
-    })
-
-    it('should map F13-F15 to 0x8D-0x8F', () => {
-      encoder.updateKey(0x68, true)  // F13
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x8D)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x6A, true)  // F15
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x8F)
-    })
-
-    it('should map Alt+F1-F12 to 0x91-0x9C', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-
-      encoder.updateKey(0x3A, true)  // Alt+F1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x91)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x45, true)  // Alt+F12
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x9C)
-    })
-
-    it('should map Alt+F13-F15 to 0x9D-0x9F', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-
-      encoder.updateKey(0x68, true)  // Alt+F13
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x9D)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x6A, true)  // Alt+F15
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x9F)
+    it('should produce Ctrl+6 = RS (0x1E)', () => {
+      encoder.updateKey(0x23, true)  // '6'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1E)
     })
-  })
 
-  describe('Alt Key Mapping', () => {
-    beforeEach(() => {
-      encoder.updateControlLines(false, false, false, false)
+    it('should produce Ctrl+- = US (0x1F)', () => {
+      encoder.updateKey(0x2D, true)  // '-'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1F)
     })
 
-    it('should map Alt+letter to extended character set', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-
-      encoder.updateKey(0x04, true)  // Alt+a -> 0xE1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xE1)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x1D, true)  // Alt+z -> 0xFA
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFA)
+    it('should produce Ctrl+[ = ESC (0x1B)', () => {
+      encoder.updateKey(0x2F, true)  // '['
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B)
     })
 
-    it('should map Alt+number to extended character set', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-
-      encoder.updateKey(0x1E, true)  // Alt+1 -> 0xB1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xB1)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x27, true)  // Alt+0 -> 0xB0
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xB0)
+    it('should produce Ctrl+\\ = FS (0x1C)', () => {
+      encoder.updateKey(0x31, true)  // '\\'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1C)
     })
 
-    it('should map Alt+Space to 0xA0', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0x2C, true)  // Alt+Space -> 0xA0
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA0)
+    it('should produce Ctrl+] = GS (0x1D)', () => {
+      encoder.updateKey(0x30, true)  // ']'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1D)
     })
 
-    it('should map Alt+DEL to 0xFF', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0x4C, true)  // Alt+DEL -> 0xFF
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFF)
+    it('should track right Ctrl the same as left Ctrl', () => {
+      encoder.updateKey(0xE0, false)  // Release left Ctrl
+      encoder.updateKey(0xE4, true)   // Right Ctrl down
+      encoder.updateKey(0x04, true)   // 'A'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x01)  // Ctrl+A
     })
   })
 
-  describe('Alt+Shift Key Mapping', () => {
+  describe('Modifier Key Behavior', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
     })
 
-    it('should map Alt+Shift+letter to extended character set', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE1, true)  // Press Shift
-
-      encoder.updateKey(0x04, true)  // Alt+Shift+a -> 0xC1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC1)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x1D, true)  // Alt+Shift+z -> 0xDA
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDA)
+    it('should not generate output for Ctrl press/release alone', () => {
+      encoder.updateKey(0xE0, true)   // Left Ctrl down
+      expect(encoder.hasDataReadyA()).toBe(false)
+      encoder.updateKey(0xE0, false)  // Left Ctrl up
+      expect(encoder.hasDataReadyA()).toBe(false)
     })
 
-    it('should map Alt+Shift+number to extended character set', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE1, true)  // Press Shift
-
-      encoder.updateKey(0x1E, true)  // Alt+Shift+1 -> 0xA1
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA1)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x1F, true)  // Alt+Shift+2 -> 0xC0
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC0)
+    it('should not generate output for Shift press/release alone', () => {
+      encoder.updateKey(0xE1, true)   // Left Shift down
+      expect(encoder.hasDataReadyA()).toBe(false)
+      encoder.updateKey(0xE1, false)  // Left Shift up
+      expect(encoder.hasDataReadyA()).toBe(false)
     })
 
-    it('should map Alt+Shift+symbols to extended character set', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE1, true)  // Press Shift
-
-      encoder.updateKey(0x2D, true)  // Alt+Shift+- -> 0xDF
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDF)
-
+    it('should not generate output for key release events', () => {
+      encoder.updateKey(0x04, true)   // 'A' pressed
+      expect(encoder.hasDataReadyA()).toBe(true)
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x2F, true)  // Alt+Shift+[ -> 0xFB
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFB)
-    })
-  })
 
-  describe('Complex Key Combinations', () => {
-    beforeEach(() => {
-      encoder.updateControlLines(false, false, false, false)
+      encoder.updateKey(0x04, false)  // 'A' released
+      expect(encoder.hasDataReadyA()).toBe(false)  // No new data from release
     })
 
-    it('should handle Ctrl+C combination', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0x06, true)  // c
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x03)  // ETX
+    it('should ignore Alt key (no output, no modifier effect)', () => {
+      encoder.updateKey(0xE2, true)   // Left Alt down - ignored
+      expect(encoder.hasDataReadyA()).toBe(false)
+      encoder.updateKey(0x04, true)   // 'A'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)  // Normal 'A', no alt mapping
     })
 
-    it('should prioritize Ctrl over Shift', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0xE1, true)  // Press Shift
-      encoder.updateKey(0x04, true)  // a
-      // When both Ctrl and Shift are pressed, shift is ignored for Ctrl combinations
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x01)  // Ctrl+a
+    it('should ignore Caps Lock key', () => {
+      encoder.updateKey(0x39, true)   // Caps Lock - ignored
+      expect(encoder.hasDataReadyA()).toBe(false)
     })
 
-    it('should prioritize Alt+Shift over Alt alone', () => {
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE1, true)  // Press Shift
-      encoder.updateKey(0x04, true)  // a
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC1)  // Alt+Shift+a, not Alt+a (0xE1)
+    it('should ignore GUI/MENU keys', () => {
+      encoder.updateKey(0xE3, true)   // Left GUI - ignored (no mapping in table)
+      expect(encoder.hasDataReadyA()).toBe(false)
     })
 
-    it('should apply Alt when both Ctrl and Alt are active', () => {
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0x04, true)  // a
-      // Alt takes effect when both Ctrl and Alt are pressed (per C++ implementation)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xE1)  // Alt+a
+    it('should ignore unrecognized keycodes', () => {
+      encoder.updateKey(0x3A, true)   // F1 - no mapping
+      expect(encoder.hasDataReadyA()).toBe(false)
     })
   })
 
@@ -544,418 +529,93 @@ describe('KeyboardEncoderAttachment', () => {
       encoder.updateControlLines(false, false, false, false)
     })
 
-    it('should handle multiple sequential key presses', () => {
-      encoder.updateKey(0x04, true)  // 'a'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x05, true)  // 'b'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x62)
-
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0x06, true)  // 'c'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x63)
-    })
-
-    it('should overwrite previous data with new key press', () => {
-      encoder.updateKey(0x04, true)  // 'a'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)
-
-      // New key press without clearing interrupts
-      encoder.updateKey(0x05, true)  // 'b'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x62)  // Overwritten
-    })
-  })
-
-  describe('Edge Cases', () => {
-    beforeEach(() => {
-      encoder.updateControlLines(false, false, false, false)
-    })
-
-    it('should handle rapid modifier changes', () => {
-      encoder.updateKey(0xE1, true)   // Press Shift
-      encoder.updateKey(0xE1, false)  // Release Shift
-      encoder.updateKey(0xE1, true)   // Press Shift again
-      encoder.updateKey(0x04, true)   // 'a' -> 'A'
+    it('should overwrite data with new key press', () => {
+      encoder.updateKey(0x04, true)  // 'A'
       expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
-    })
 
-    it('should handle all modifiers released', () => {
-      encoder.updateKey(0xE0, true)   // Press Ctrl
-      encoder.updateKey(0xE1, true)   // Press Shift
-      encoder.updateKey(0xE2, true)   // Press Alt
-      encoder.updateKey(0xE0, false)  // Release Ctrl
-      encoder.updateKey(0xE1, false)  // Release Shift
-      encoder.updateKey(0xE2, false)  // Release Alt
-      encoder.updateKey(0x04, true)   // 'a'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)  // Plain 'a'
+      encoder.updateKey(0x05, true)  // 'B' overwrites without clearing
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x42)
     })
 
-    it('should handle port disabled mid-operation', () => {
-      encoder.updateKey(0x04, true)  // 'a'
-      expect(encoder.hasCA1Interrupt()).toBe(true)
-
-      // Disable port
-      encoder.updateControlLines(false, true, false, true)
-      expect(encoder.hasCA1Interrupt()).toBe(false)  // Interrupt not visible when disabled
-    })
-
-    it('should handle re-enabling port with data still present', () => {
-      encoder.updateKey(0x04, true)  // 'a'
-      encoder.updateControlLines(false, true, false, true)  // Disable
-
-      // Re-enable
-      encoder.updateControlLines(false, false, false, false)
-      // Data should still be there
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61)
-    })
-  })
-
-  describe('Alt+Shift Symbol Mapping (Extended Character Set)', () => {
-    beforeEach(() => {
-      encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0xE2, true)  // Press Alt
-      encoder.updateKey(0xE1, true)  // Press Shift
-    })
-
-    afterEach(() => {
+    it('should handle read-clear-press cycle', () => {
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
       encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0xE2, false)  // Release Alt
-      encoder.updateKey(0xE1, false)  // Release Shift
-    })
-
-    it('should map Alt+Shift+1 to ¡ (0xA1)', () => {
-      encoder.updateKey(0x1E, true)  // '1'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA1)
-    })
-
-    it('should map Alt+Shift+\' to ¢ (0xA2)', () => {
-      encoder.updateKey(0x34, true)  // '\'' (apostrophe, USB HID 0x34)
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA2)
-    })
-
-    it('should map Alt+Shift+3 to £ (0xA3)', () => {
-      encoder.updateKey(0x20, true)  // '3'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA3)
-    })
-
-    it('should map Alt+Shift+4 to ¤ (0xA4)', () => {
-      encoder.updateKey(0x21, true)  // '4'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA4)
-    })
-
-    it('should map Alt+Shift+5 to ¥ (0xA5)', () => {
-      encoder.updateKey(0x22, true)  // '5'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA5)
-    })
-
-    it('should map Alt+Shift+7 to ¦ (0xA6)', () => {
-      encoder.updateKey(0x24, true)  // '7'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA6)
-    })
-
-    it('should map Alt+Shift+9 to ¨ (0xA8)', () => {
-      encoder.updateKey(0x26, true)  // '9'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA8)
-    })
-
-    it('should map Alt+Shift+0 to © (0xA9)', () => {
-      encoder.updateKey(0x27, true)  // '0'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA9)
-    })
-
-    it('should map Alt+Shift+8 to ª (0xAA)', () => {
-      encoder.updateKey(0x25, true)  // '8'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAA)
-    })
-
-    it('should map Alt+Shift+= to « (0xAB)', () => {
-      encoder.updateKey(0x2E, true)  // '='
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAB)
-    })
-
-    it('should map Alt+Shift+; to º (0xBA)', () => {
-      encoder.updateKey(0x33, true)  // ';'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBA)
-    })
-
-    it('should map Alt+Shift+, to ¼ (0xBC)', () => {
-      encoder.updateKey(0x36, true)  // ','
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBC)
-    })
-
-    it('should map Alt+Shift+. to ¾ (0xBE)', () => {
-      encoder.updateKey(0x37, true)  // '.'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBE)
-    })
-
-    it('should map Alt+Shift+/ to ¿ (0xBF)', () => {
-      encoder.updateKey(0x38, true)  // '/'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBF)
-    })
-
-    it('should map Alt+Shift+2 to À (0xC0)', () => {
-      encoder.updateKey(0x1F, true)  // '2'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC0)
-    })
-
-    it('should map Alt+Shift+b to  (0xC2)', () => {
-      encoder.updateKey(0x05, true)  // 'b'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC2)
-    })
-
-    it('should map Alt+Shift+c to à (0xC3)', () => {
-      encoder.updateKey(0x06, true)  // 'c'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC3)
-    })
-
-    it('should map Alt+Shift+d to Ä (0xC4)', () => {
-      encoder.updateKey(0x07, true)  // 'd'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC4)
-    })
-
-    it('should map Alt+Shift+e to Å (0xC5)', () => {
-      encoder.updateKey(0x08, true)  // 'e'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC5)
-    })
-
-    it('should map Alt+Shift+f to Æ (0xC6)', () => {
-      encoder.updateKey(0x09, true)  // 'f'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC6)
-    })
-
-    it('should map Alt+Shift+g to Ç (0xC7)', () => {
-      encoder.updateKey(0x0A, true)  // 'g'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC7)
-    })
-
-    it('should map Alt+Shift+h to È (0xC8)', () => {
-      encoder.updateKey(0x0B, true)  // 'h'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xC8)
-    })
-
-    it('should map Alt+Shift+6 to Þ (0xDE)', () => {
-      encoder.updateKey(0x23, true)  // '6'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDE)
-    })
-
-    it('should map Alt+Shift+- to ß (0xDF)', () => {
-      encoder.updateKey(0x2D, true)  // '-'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDF)
-    })
-
-    it('should map Alt+Shift+[ to û (0xFB)', () => {
-      encoder.updateKey(0x2F, true)  // '['
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFB)
-    })
+      expect(encoder.hasDataReadyA()).toBe(false)
 
-    it('should map Alt+Shift+\\ to ü (0xFC)', () => {
-      encoder.updateKey(0x31, true)  // '\\'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFC)
+      encoder.updateKey(0x05, true)  // 'B'
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x42)
+      expect(encoder.hasDataReadyA()).toBe(true)
     })
 
-    it('should map Alt+Shift+] to ý (0xFD)', () => {
-      encoder.updateKey(0x30, true)  // ']'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFD)
-    })
+    it('should handle modifier press then key press', () => {
+      encoder.updateKey(0xE0, true)  // Ctrl down
+      encoder.updateKey(0x06, true)  // 'C' -> Ctrl+C = 0x03
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x03)
 
-    it('should map Alt+Shift+` to þ (0xFE)', () => {
-      encoder.updateKey(0x35, true)  // '`'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFE)
+      encoder.clearInterrupts(true, false, true, false)
+      encoder.updateKey(0xE0, false)  // Ctrl up
+      encoder.updateKey(0x06, true)   // 'C' -> normal 'C' = 0x43
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x43)
     })
   })
 
-  describe('Alt Symbol Mapping (Without Shift)', () => {
+  describe('Active Port Selection', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0xE2, true)  // Press Alt
-    })
-
-    afterEach(() => {
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0xE2, false)  // Release Alt
-    })
-
-    it('should map Alt+\' to § (0xA7)', () => {
-      encoder.updateKey(0x34, true)  // '\''
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xA7)
-    })
-
-    it('should map Alt+, to ¬ (0xAC)', () => {
-      encoder.updateKey(0x36, true)  // ','
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAC)
-    })
-
-    it('should map Alt+- to soft hyphen (0xAD)', () => {
-      encoder.updateKey(0x2D, true)  // '-'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAD)
-    })
-
-    it('should map Alt+. to ® (0xAE)', () => {
-      encoder.updateKey(0x37, true)  // '.'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAE)
     })
 
-    it('should map Alt+/ to ¯ (0xAF)', () => {
-      encoder.updateKey(0x38, true)  // '/'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xAF)
-    })
-
-    it('should map Alt+; to » (0xBB)', () => {
-      encoder.updateKey(0x33, true)  // ';'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBB)
-    })
-
-    it('should map Alt+= to ½ (0xBD)', () => {
-      encoder.updateKey(0x2E, true)  // '='
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBD)
-    })
-
-    it('should map Alt+[ to Û (0xDB)', () => {
-      encoder.updateKey(0x2F, true)  // '['
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDB)
-    })
-
-    it('should map Alt+\\ to Ü (0xDC)', () => {
-      encoder.updateKey(0x31, true)  // '\\'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDC)
+    it('should default to both ports active', () => {
+      expect(encoder.activePort).toBe('both')
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.hasDataReadyA()).toBe(true)
+      expect(encoder.hasDataReadyB()).toBe(true)
     })
 
-    it('should map Alt+] to Ý (0xDD)', () => {
-      encoder.updateKey(0x30, true)  // ']'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDD)
+    it('should only update Port A when activePort is A', () => {
+      encoder.activePort = 'A'
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.hasDataReadyA()).toBe(true)
+      expect(encoder.hasDataReadyB()).toBe(false)
     })
 
-    it('should map Alt+` to à (0xE0)', () => {
-      encoder.updateKey(0x35, true)  // '`'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xE0)
+    it('should only update Port B when activePort is B', () => {
+      encoder.activePort = 'B'
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.hasDataReadyA()).toBe(false)
+      expect(encoder.hasDataReadyB()).toBe(true)
     })
   })
 
-  describe('Ctrl Combinations Coverage', () => {
+  describe('Edge Cases', () => {
     beforeEach(() => {
       encoder.updateControlLines(false, false, false, false)
-      encoder.updateKey(0xE0, true)  // Press Ctrl
-    })
-
-    afterEach(() => {
-      encoder.clearInterrupts(true, false, true, false)
-      encoder.updateKey(0xE0, false)  // Release Ctrl
-    })
-
-    it('should map Ctrl+b to 0x02', () => {
-      encoder.updateKey(0x05, true)  // 'b'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x02)
-    })
-
-    it('should map Ctrl+d to 0x04', () => {
-      encoder.updateKey(0x07, true)  // 'd'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x04)
-    })
-
-    it('should map Ctrl+e to 0x05', () => {
-      encoder.updateKey(0x08, true)  // 'e'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x05)
-    })
-
-    it('should map Ctrl+f to 0x06', () => {
-      encoder.updateKey(0x09, true)  // 'f'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x06)
-    })
-
-    it('should map Ctrl+g to 0x07', () => {
-      encoder.updateKey(0x0A, true)  // 'g'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x07)
-    })
-
-    it('should map Ctrl+h to 0x08', () => {
-      encoder.updateKey(0x0B, true)  // 'h'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x08)
-    })
-
-    it('should map Ctrl+i to 0x09', () => {
-      encoder.updateKey(0x0C, true)  // 'i'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x09)
-    })
-
-    it('should map Ctrl+j to 0x0A', () => {
-      encoder.updateKey(0x0D, true)  // 'j'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0A)
-    })
-
-    it('should map Ctrl+k to 0x0B', () => {
-      encoder.updateKey(0x0E, true)  // 'k'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0B)
-    })
-
-    it('should map Ctrl+l to 0x0C', () => {
-      encoder.updateKey(0x0F, true)  // 'l'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0C)
-    })
-
-    it('should map Ctrl+m to 0x0D', () => {
-      encoder.updateKey(0x10, true)  // 'm'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0D)
-    })
-
-    it('should map Ctrl+n to 0x0E', () => {
-      encoder.updateKey(0x11, true)  // 'n'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0E)
-    })
-
-    it('should map Ctrl+o to 0x0F', () => {
-      encoder.updateKey(0x12, true)  // 'o'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0F)
     })
 
-    it('should map Ctrl+p to 0x10', () => {
-      encoder.updateKey(0x13, true)  // 'p'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x10)
-    })
-
-    it('should map Ctrl+q to 0x11', () => {
-      encoder.updateKey(0x14, true)  // 'q'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x11)
-    })
-
-    it('should map Ctrl+r to 0x12', () => {
-      encoder.updateKey(0x15, true)  // 'r'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x12)
-    })
-
-    it('should map Ctrl+s to 0x13', () => {
-      encoder.updateKey(0x16, true)  // 's'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x13)
-    })
-
-    it('should map Ctrl+t to 0x14', () => {
-      encoder.updateKey(0x17, true)  // 't'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x14)
-    })
-
-    it('should map Ctrl+u to 0x15', () => {
-      encoder.updateKey(0x18, true)  // 'u'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x15)
-    })
-
-    it('should map Ctrl+v to 0x16', () => {
-      encoder.updateKey(0x19, true)  // 'v'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x16)
-    })
+    it('should handle port disable mid-operation', () => {
+      encoder.updateKey(0x04, true)  // 'A'
+      expect(encoder.hasCA1Interrupt()).toBe(true)
 
-    it('should map Ctrl+w to 0x17', () => {
-      encoder.updateKey(0x1A, true)  // 'w'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x17)
+      // Disable Port A
+      encoder.updateControlLines(false, true, false, false)
+      expect(encoder.hasCA1Interrupt()).toBe(false)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFF)  // Disabled, returns 0xFF
     })
 
-    it('should map Ctrl+x to 0x18', () => {
-      encoder.updateKey(0x1B, true)  // 'x'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x18)
+    it('should allow re-enabling port and reading existing data', () => {
+      encoder.updateKey(0x04, true)  // 'A'
+      encoder.updateControlLines(false, true, false, true)  // Disable both
+      encoder.updateControlLines(false, false, false, false)  // Re-enable both
+      // Data should still be readable (dataReady is still true, just interrupt was gated)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41)
     })
 
-    it('should map Ctrl+y to 0x19', () => {
-      encoder.updateKey(0x1C, true)  // 'y'
-      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x19)
+    it('should handle Ctrl+2 producing NUL (0x00) correctly', () => {
+      encoder.updateKey(0xE0, true)  // Ctrl down
+      encoder.updateKey(0x1F, true)  // '2'
+      // Should produce 0x00 and data should be ready
+      expect(encoder.hasDataReadyA()).toBe(true)
+      expect(encoder.readPortA(0xFF, 0x00)).toBe(0x00)
     })
   })
 })