ac6502 1.9.3 → 1.11.0

package/dist/tests/IO/Attachments/KeyboardEncoderAttachment.test.js

@@ -5,8 +5,13 @@ describe('KeyboardEncoderAttachment', () => {
     let encoder;
     beforeEach(() => {
         encoder = new KeyboardEncoderAttachment_1.KeyboardEncoderAttachment(5);
+        encoder.activePort = 'both'; // Enable both ports for testing
     });
     describe('Initialization', () => {
+        it('should default to Port B only', () => {
+            const fresh = new KeyboardEncoderAttachment_1.KeyboardEncoderAttachment(5);
+            expect(fresh.activePort).toBe('B');
+        });
         it('should initialize with no data ready', () => {
             expect(encoder.hasDataReadyA()).toBe(false);
             expect(encoder.hasDataReadyB()).toBe(false);
@@ -17,7 +22,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);
         });
@@ -27,45 +32,53 @@ 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);
         });
     });
@@ -80,47 +93,47 @@ 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);
         });
     });
     describe('Interrupt Handling', () => {
         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);
             encoder.clearInterrupts(true, false, false, false);
@@ -129,7 +142,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);
             encoder.clearInterrupts(false, false, true, false);
@@ -138,21 +151,52 @@ 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);
+        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(0x1D, true); // 'z'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7A);
+            // 'Z' (HID 0x1D)
+            encoder.updateKey(0x1D, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x5A);
+        });
+        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(0x10, true); // 'M'
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x4D); // Still uppercase M
+        });
+        it('should map all letters correctly', () => {
+            const letterMap = [
+                [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('Number Key Mapping', () => {
+        beforeEach(() => {
+            encoder.updateControlLines(false, false, false, false);
         });
         it('should map numbers correctly', () => {
             encoder.updateKey(0x1E, true); // '1'
@@ -161,618 +205,334 @@ describe('KeyboardEncoderAttachment', () => {
             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);
-            encoder.clearInterrupts(true, false, true, false);
-            encoder.updateKey(0x2C, true); // Space
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x20);
-        });
-        it('should ignore key releases', () => {
-            encoder.updateKey(0x04, true); // Press 'a'
-            expect(encoder.hasDataReadyA()).toBe(true);
-            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);
+        it('should map all number keys 0-9', () => {
+            const numberMap = [
+                [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('Modifier Keys', () => {
+    describe('Special 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);
-            // Release Shift
-            encoder.clearInterrupts(true, false, true, false);
-            encoder.updateKey(0xE1, false);
-            encoder.updateKey(0x04, true); // 'a'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x61);
-        });
-        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 Enter to CR (0x0D)', () => {
+            encoder.updateKey(0x28, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x0D);
         });
-    });
-    describe('Shift Key Mapping', () => {
-        beforeEach(() => {
-            encoder.updateControlLines(false, false, false, false);
+        it('should map Escape to ESC (0x1B)', () => {
+            encoder.updateKey(0x29, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B);
         });
-        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 Backspace to BS (0x08)', () => {
+            encoder.updateKey(0x2A, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x08);
         });
-        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 Tab to HT (0x09)', () => {
+            encoder.updateKey(0x2B, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x09);
         });
-        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);
-            encoder.clearInterrupts(true, false, true, false);
-            encoder.updateKey(0x2F, true); // '[' -> '{'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7B);
+        it('should map Space to SP (0x20)', () => {
+            encoder.updateKey(0x2C, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x20);
         });
-    });
-    describe('Ctrl Key Mapping', () => {
-        beforeEach(() => {
-            encoder.updateControlLines(false, false, false, false);
+        it('should map Delete to DEL (0x7F)', () => {
+            encoder.updateKey(0x4C, true);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x7F);
         });
-        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);
-            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);
-        });
-        it('should map Ctrl+6 to RS (UP arrow)', () => {
-            encoder.updateKey(0xE0, true); // Press Ctrl
-            encoder.updateKey(0x23, true); // Ctrl+6 -> 0x1E
-            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
+            encoder.updateKey(0x51, true); // Down Arrow
             expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1F);
-        });
-    });
-    describe('MENU 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);
-        });
-    });
-    describe('Function Key Mapping', () => {
-        beforeEach(() => {
-            encoder.updateControlLines(false, false, false, false);
-        });
-        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);
-        });
-    });
-    describe('Alt Key Mapping', () => {
-        beforeEach(() => {
-            encoder.updateControlLines(false, false, false, false);
-        });
-        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 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 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 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);
-        });
-    });
-    describe('Alt+Shift Key Mapping', () => {
-        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 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 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);
-            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);
-        });
-        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 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 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 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
-        });
-    });
-    describe('Sequential Key Presses', () => {
-        beforeEach(() => {
-            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);
+            encoder.updateKey(0x52, true); // Up Arrow
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1E);
         });
-        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
+        it('should map symbol keys correctly', () => {
+            const symbolMap = [
+                [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('Edge Cases', () => {
+    describe('Shift Key Mapping', () => {
         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'
-            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'
-        });
-        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);
+            encoder.updateKey(0xE1, true); // Left Shift down
+        });
+        it('should produce shifted number symbols', () => {
+            const shiftNumberMap = [
+                [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 = [
+                [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('Alt+Shift Symbol Mapping (Extended Character Set)', () => {
+    describe('Ctrl Key Mapping', () => {
         beforeEach(() => {
             encoder.updateControlLines(false, false, false, false);
-            encoder.updateKey(0xE2, true); // Press Alt
-            encoder.updateKey(0xE1, true); // Press Shift
-        });
-        afterEach(() => {
-            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(0xE0, true); // Left Ctrl down
+        });
+        it('should produce control codes for Ctrl+A through Ctrl+Z', () => {
+            const ctrlLetterMap = [
+                [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(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);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x00);
         });
-        it('should map Alt+Shift+6 to Þ (0xDE)', () => {
+        it('should produce Ctrl+6 = RS (0x1E)', () => {
             encoder.updateKey(0x23, true); // '6'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDE);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1E);
         });
-        it('should map Alt+Shift+- to ß (0xDF)', () => {
+        it('should produce Ctrl+- = US (0x1F)', () => {
             encoder.updateKey(0x2D, true); // '-'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDF);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1F);
         });
-        it('should map Alt+Shift+[ to û (0xFB)', () => {
+        it('should produce Ctrl+[ = ESC (0x1B)', () => {
             encoder.updateKey(0x2F, true); // '['
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFB);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1B);
         });
-        it('should map Alt+Shift+\\ to ü (0xFC)', () => {
+        it('should produce Ctrl+\\ = FS (0x1C)', () => {
             encoder.updateKey(0x31, true); // '\\'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFC);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1C);
         });
-        it('should map Alt+Shift+] to ý (0xFD)', () => {
+        it('should produce Ctrl+] = GS (0x1D)', () => {
             encoder.updateKey(0x30, true); // ']'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFD);
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x1D);
         });
-        it('should map Alt+Shift+` to þ (0xFE)', () => {
-            encoder.updateKey(0x35, true); // '`'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xFE);
+        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 Symbol Mapping (Without Shift)', () => {
+    describe('Modifier Key Behavior', () => {
         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 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+; to » (0xBB)', () => {
-            encoder.updateKey(0x33, true); // ';'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBB);
+        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+= to ½ (0xBD)', () => {
-            encoder.updateKey(0x2E, true); // '='
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xBD);
+        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(0x04, false); // 'A' released
+            expect(encoder.hasDataReadyA()).toBe(false); // No new data from release
         });
-        it('should map Alt+[ to Û (0xDB)', () => {
-            encoder.updateKey(0x2F, true); // '['
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDB);
+        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 map Alt+\\ to Ü (0xDC)', () => {
-            encoder.updateKey(0x31, true); // '\\'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDC);
+        it('should ignore Caps Lock key', () => {
+            encoder.updateKey(0x39, true); // Caps Lock - ignored
+            expect(encoder.hasDataReadyA()).toBe(false);
         });
-        it('should map Alt+] to Ý (0xDD)', () => {
-            encoder.updateKey(0x30, true); // ']'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xDD);
+        it('should ignore GUI/MENU keys', () => {
+            encoder.updateKey(0xE3, true); // Left GUI - ignored (no mapping in table)
+            expect(encoder.hasDataReadyA()).toBe(false);
         });
-        it('should map Alt+` to à (0xE0)', () => {
-            encoder.updateKey(0x35, true); // '`'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0xE0);
+        it('should ignore unrecognized keycodes', () => {
+            encoder.updateKey(0x3A, true); // F1 - no mapping
+            expect(encoder.hasDataReadyA()).toBe(false);
         });
     });
-    describe('Ctrl Combinations Coverage', () => {
+    describe('Sequential Key Presses', () => {
         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 overwrite data with new key press', () => {
+            encoder.updateKey(0x04, true); // 'A'
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x41);
+            encoder.updateKey(0x05, true); // 'B' overwrites without clearing
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x42);
         });
-        it('should map Ctrl+p to 0x10', () => {
-            encoder.updateKey(0x13, true); // 'p'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x10);
+        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);
+            expect(encoder.hasDataReadyA()).toBe(false);
+            encoder.updateKey(0x05, true); // 'B'
+            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x42);
+            expect(encoder.hasDataReadyA()).toBe(true);
         });
-        it('should map Ctrl+q to 0x11', () => {
-            encoder.updateKey(0x14, true); // 'q'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x11);
+        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);
+            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);
         });
-        it('should map Ctrl+r to 0x12', () => {
-            encoder.updateKey(0x15, true); // 'r'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x12);
+    });
+    describe('Active Port Selection', () => {
+        beforeEach(() => {
+            encoder.updateControlLines(false, false, false, false);
         });
-        it('should map Ctrl+s to 0x13', () => {
-            encoder.updateKey(0x16, true); // 's'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x13);
+        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 Ctrl+t to 0x14', () => {
-            encoder.updateKey(0x17, true); // 't'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x14);
+        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 Ctrl+u to 0x15', () => {
-            encoder.updateKey(0x18, true); // 'u'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x15);
+        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);
         });
-        it('should map Ctrl+v to 0x16', () => {
-            encoder.updateKey(0x19, true); // 'v'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x16);
+    });
+    describe('Edge Cases', () => {
+        beforeEach(() => {
+            encoder.updateControlLines(false, false, false, false);
         });
-        it('should map Ctrl+w to 0x17', () => {
-            encoder.updateKey(0x1A, true); // 'w'
-            expect(encoder.readPortA(0xFF, 0x00)).toBe(0x17);
+        it('should handle port disable mid-operation', () => {
+            encoder.updateKey(0x04, true); // 'A'
+            expect(encoder.hasCA1Interrupt()).toBe(true);
+            // 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);
         });
     });
 });