ac6502 1.3.0 → 1.4.1

package/src/index.ts

@@ -4,13 +4,15 @@ import figlet from 'figlet'
 import { Machine } from './components/Machine'
 import { Command, Option } from 'commander'
 import { SerialPort } from 'serialport'
-import { VideoCard } from './components/IO/VideoCard'
-import { DevOutputBoard } from './components/IO/DevOutputBoard'
-import { StorageCard } from './components/IO/StorageCard'
-import { SoundCard } from './components/IO/SoundCard'
+import { Video } from './components/IO/Video'
+import { Terminal } from './components/IO/Terminal'
+import { Storage } from './components/IO/Storage'
+import { Sound } from './components/IO/Sound'
 import sdl from '@kmamal/sdl'
+import { readFile, writeFile } from 'fs/promises'
+import { existsSync } from 'fs'
 
-const VERSION = '1.3.0'
+const VERSION = '1.4.1'
 const WIDTH = 320
 const HEIGHT = 240
 
@@ -20,7 +22,7 @@ const AUDIO_CHANNELS = 1
 const AUDIO_FORMAT = 'f32'
 const AUDIO_BUFFERED = 2048
 
-// Joystick button bit masks (matching GPIOJoystickAttachment)
+// Joystick button bit masks (matching JoystickAttachment)
 const BUTTON_UP = 0x01
 const BUTTON_DOWN = 0x02
 const BUTTON_LEFT = 0x04
@@ -92,21 +94,30 @@ class Emulator {
 
   private async loadBinaries(): Promise<void> {
     if (this.options.rom) {
-      await this.machine.loadROM(this.options.rom)
+      const romData = await readFile(this.options.rom)
+      this.machine.loadROM(new Uint8Array(romData))
       console.log(`Loaded ROM: ${this.options.rom}`)
     } else {
       console.log('Loaded ROM: NONE')
     }
 
     if (this.options.cart) {
-      await this.machine.loadCart(this.options.cart)
+      const cartData = await readFile(this.options.cart)
+      this.machine.loadCart(new Uint8Array(cartData))
       console.log(`Loaded Cart: ${this.options.cart}`)
     } else {
       console.log('Loaded Cart: NONE')
     }
 
     if (this.options.storage && this.options.target !== 'kim') {
-      await (this.machine.io4 as StorageCard).loadFromFile(this.options.storage)
+      if (existsSync(this.options.storage)) {
+        const storageData = await readFile(this.options.storage)
+        ;(this.machine.io4 as Storage).loadData(new Uint8Array(storageData))
+      } else {
+        console.log(`Storage file not found: ${this.options.storage}`)
+        console.log('A new storage file will be created on exit.')
+        ;(this.machine.io4 as Storage).loadData(null)
+      }
     }
   }
 
@@ -193,11 +204,11 @@ class Emulator {
         buffered: AUDIO_BUFFERED,
       })
 
-      // Configure SoundCard sample rate to match audio device
-      ;(this.machine.io7 as SoundCard).sampleRate = this.audioDevice.frequency
+      // Configure Sound sample rate to match audio device
+      ;(this.machine.io7 as Sound).sampleRate = this.audioDevice.frequency
 
       // Connect the Machine's audio callback to the SDL audio device
-      this.machine.pushAudioSamples = (samples: Float32Array) => {
+      this.machine.play = (samples: Float32Array) => {
         if (!this.audioDevice || this.audioDevice.closed) return
 
         const { channels, bytesPerSample } = this.audioDevice
@@ -322,13 +333,13 @@ class Emulator {
         this.window.render(renderWidth, renderHeight, renderWidth * 4, 'rgba32', rgbaBuffer)
       }
     } else if (this.options.target === 'cob' || this.options.target === 'vcs') {
-      const videoCard = this.machine.io8 as VideoCard
+      const Video = this.machine.io8 as Video
       this.machine.render = () => {
         if (!this.window) { return }
-        this.window.render(WIDTH, HEIGHT, WIDTH * 4, 'rgba32', videoCard.buffer)
+        this.window.render(WIDTH, HEIGHT, WIDTH * 4, 'rgba32', Video.buffer)
       }
     } else if (this.options.target === 'dev') {
-      const devBoard = this.machine.io8 as DevOutputBoard
+      const devBoard = this.machine.io8 as Terminal
       const rgbaBuffer = Buffer.alloc(WIDTH * HEIGHT * 4)
       this.machine.render = () => {
         if (!this.window) { return }
@@ -516,7 +527,6 @@ class Emulator {
         }
       })
     }
-    this.machine.end()
 
     const uptime = Date.now() - this.machine.startTime
 
@@ -531,9 +541,12 @@ class Emulator {
     
     // Save storage data if path was provided
     if (this.options.storage && this.options.target !== 'kim') {
-      (this.machine.io4 as StorageCard).saveToFile(this.options.storage).then(() => {
+      const storageData = (this.machine.io4 as Storage).getData()
+      writeFile(this.options.storage, storageData).then(() => {
+        console.log(`Storage saved to: ${this.options.storage}`)
         process.exit(0)
-      }).catch(() => {
+      }).catch((error) => {
+        console.error('Error saving storage file:', error)
         process.exit(1)
       })
     } else {
@@ -541,8 +554,8 @@ class Emulator {
     }
   }
 
-  start(): void {
-    this.machine.start()
+  run(): void {
+    this.machine.run()
   }
 }
 
@@ -573,7 +586,7 @@ const options = program.opts()
 async function main() {
   const emulator = new Emulator(options)
   await emulator.initialize()
-  emulator.start()
+  emulator.run()
 }
 
 // Run the main function

package/src/lib.ts

@@ -7,21 +7,21 @@ export { Cart } from './components/Cart'
 export type { IO } from './components/IO'
 
 // IO cards
-export { EmptyCard } from './components/IO/EmptyCard'
-export { GPIOCard } from './components/IO/GPIOCard'
-export { RAMCard } from './components/IO/RAMCard'
-export { RTCCard } from './components/IO/RTCCard'
-export { SerialCard } from './components/IO/SerialCard'
-export { SIDVoice, SoundCard } from './components/IO/SoundCard'
-export { StorageCard } from './components/IO/StorageCard'
-export { VideoCard } from './components/IO/VideoCard'
-export { DevOutputBoard } from './components/IO/DevOutputBoard'
+export { Empty } from './components/IO/Empty'
+export { VIA } from './components/IO/VIA'
+export { RAMBank } from './components/IO/RAMBank'
+export { RTC } from './components/IO/RTC'
+export { ACIA } from './components/IO/ACIA'
+export { SIDVoice, Sound } from './components/IO/Sound'
+export { Storage } from './components/IO/Storage'
+export { Video } from './components/IO/Video'
+export { Terminal } from './components/IO/Terminal'
 
 // GPIO attachments
-export type { GPIOAttachment } from './components/IO/GPIOAttachments/GPIOAttachment'
-export { GPIOAttachmentBase } from './components/IO/GPIOAttachments/GPIOAttachment'
-export { GPIOJoystickAttachment } from './components/IO/GPIOAttachments/GPIOJoystickAttachment'
-export { GPIOKeyboardEncoderAttachment } from './components/IO/GPIOAttachments/GPIOKeyboardEncoderAttachment'
-export { GPIOKeyboardMatrixAttachment } from './components/IO/GPIOAttachments/GPIOKeyboardMatrixAttachment'
-export { GPIOKeypadAttachment } from './components/IO/GPIOAttachments/GPIOKeypadAttachment'
-export { GPIOLCDAttachment } from './components/IO/GPIOAttachments/GPIOLCDAttachment'
+export type { Attachment } from './components/IO/Attachments/Attachment'
+export { AttachmentBase } from './components/IO/Attachments/Attachment'
+export { JoystickAttachment } from './components/IO/Attachments/JoystickAttachment'
+export { KeyboardEncoderAttachment } from './components/IO/Attachments/KeyboardEncoderAttachment'
+export { KeyboardMatrixAttachment } from './components/IO/Attachments/KeyboardMatrixAttachment'
+export { KeypadAttachment } from './components/IO/Attachments/KeypadAttachment'
+export { LCDAttachment } from './components/IO/Attachments/LCDAttachment'

package/src/tests/IO/{SerialCard.test.ts → ACIA.test.ts}

@@ -1,10 +1,10 @@
-import { SerialCard } from '../../components/IO/SerialCard'
+import { ACIA } from '../../components/IO/ACIA'
 
-describe('SerialCard (6551 ACIA)', () => {
-  let serialCard: SerialCard
+describe('ACIA (6551 ACIA)', () => {
+  let serialCard: ACIA
 
   beforeEach(() => {
-    serialCard = new SerialCard()
+    serialCard = new ACIA()
   })
 
   describe('Initialization', () => {
@@ -399,7 +399,7 @@ describe('SerialCard (6551 ACIA)', () => {
       ]
 
       baudRates.forEach(([code, rate]) => {
-        const card = new SerialCard()
+        const card = new ACIA()
         card.write(0x03, code as number) // Control register with baud rate code
         // Baud rate affects tick timing - verify no errors occur
       })

package/src/tests/IO/{GPIOAttachments/GPIOAttachment.test.ts → Attachments/Attachment.test.ts}

@@ -1,9 +1,9 @@
-import { GPIOAttachment, GPIOAttachmentBase } from '../../../components/IO/GPIOAttachments/GPIOAttachment'
+import { Attachment, AttachmentBase } from '../../../components/IO/Attachments/Attachment'
 
 /**
- * Concrete implementation of GPIOAttachmentBase for testing
+ * Concrete implementation of AttachmentBase for testing
  */
-class TestGPIOAttachment extends GPIOAttachmentBase {
+class TestAttachment extends AttachmentBase {
   public portAValue: number = 0xFF
   public portBValue: number = 0xFF
   public tickCount: number = 0
@@ -62,11 +62,11 @@ class TestGPIOAttachment extends GPIOAttachmentBase {
   }
 }
 
-describe('GPIOAttachmentBase', () => {
-  let attachment: TestGPIOAttachment
+describe('AttachmentBase', () => {
+  let attachment: TestAttachment
 
   beforeEach(() => {
-    attachment = new TestGPIOAttachment()
+    attachment = new TestAttachment()
   })
 
   describe('Initialization', () => {
@@ -75,7 +75,7 @@ describe('GPIOAttachmentBase', () => {
     })
 
     it('should initialize with custom priority', () => {
-      const customAttachment = new TestGPIOAttachment(5)
+      const customAttachment = new TestAttachment(5)
       expect(customAttachment.getPriority()).toBe(5)
     })
 
@@ -91,7 +91,7 @@ describe('GPIOAttachmentBase', () => {
     })
 
     it('should initialize with specified interrupt states', () => {
-      const interruptAttachment = new TestGPIOAttachment(0, true, true, true, true)
+      const interruptAttachment = new TestAttachment(0, true, true, true, true)
       expect(interruptAttachment.hasCA1Interrupt()).toBe(true)
       expect(interruptAttachment.hasCA2Interrupt()).toBe(true)
       expect(interruptAttachment.hasCB1Interrupt()).toBe(true)
@@ -121,7 +121,7 @@ describe('GPIOAttachmentBase', () => {
     })
 
     it('should maintain priority after reset', () => {
-      const priorityAttachment = new TestGPIOAttachment(10)
+      const priorityAttachment = new TestAttachment(10)
       priorityAttachment.reset()
       expect(priorityAttachment.getPriority()).toBe(10)
     })
@@ -129,15 +129,15 @@ describe('GPIOAttachmentBase', () => {
 
   describe('Priority', () => {
     it('should return correct priority value', () => {
-      const lowPriority = new TestGPIOAttachment(0)
-      const highPriority = new TestGPIOAttachment(10)
+      const lowPriority = new TestAttachment(0)
+      const highPriority = new TestAttachment(10)
 
       expect(lowPriority.getPriority()).toBe(0)
       expect(highPriority.getPriority()).toBe(10)
     })
 
     it('should support negative priority values', () => {
-      const negativePriority = new TestGPIOAttachment(-5)
+      const negativePriority = new TestAttachment(-5)
       expect(negativePriority.getPriority()).toBe(-5)
     })
   })

package/src/tests/IO/{GPIOAttachments/GPIOJoystickAttachment.test.ts → Attachments/JoystickAttachment.test.ts}

@@ -1,10 +1,10 @@
-import { GPIOJoystickAttachment } from '../../../components/IO/GPIOAttachments/GPIOJoystickAttachment'
+import { JoystickAttachment } from '../../../components/IO/Attachments/JoystickAttachment'
 
-describe('GPIOJoystickAttachment', () => {
-  let joystick: GPIOJoystickAttachment
+describe('JoystickAttachment', () => {
+  let joystick: JoystickAttachment
 
   beforeEach(() => {
-    joystick = new GPIOJoystickAttachment(true, 0)
+    joystick = new JoystickAttachment(true, 0)
   })
 
   describe('constructor and reset', () => {
@@ -26,20 +26,20 @@ describe('GPIOJoystickAttachment', () => {
     })
 
     it('should check if button is pressed', () => {
-      joystick.pressButton(GPIOJoystickAttachment.BUTTON_A)
-      expect(joystick.isButtonPressed(GPIOJoystickAttachment.BUTTON_A)).toBe(true)
-      expect(joystick.isButtonPressed(GPIOJoystickAttachment.BUTTON_B)).toBe(false)
+      joystick.pressButton(JoystickAttachment.BUTTON_A)
+      expect(joystick.isButtonPressed(JoystickAttachment.BUTTON_A)).toBe(true)
+      expect(joystick.isButtonPressed(JoystickAttachment.BUTTON_B)).toBe(false)
     })
 
     it('should press a button', () => {
-      joystick.pressButton(GPIOJoystickAttachment.BUTTON_START)
-      expect(joystick.getButtonState()).toBe(GPIOJoystickAttachment.BUTTON_START)
+      joystick.pressButton(JoystickAttachment.BUTTON_START)
+      expect(joystick.getButtonState()).toBe(JoystickAttachment.BUTTON_START)
     })
 
     it('should release a button', () => {
       joystick.updateJoystick(0xFF)
-      joystick.releaseButton(GPIOJoystickAttachment.BUTTON_A)
-      expect(joystick.getButtonState()).toBe(0xFF & ~GPIOJoystickAttachment.BUTTON_A)
+      joystick.releaseButton(JoystickAttachment.BUTTON_A)
+      expect(joystick.getButtonState()).toBe(0xFF & ~JoystickAttachment.BUTTON_A)
     })
 
     it('should release all buttons', () => {
@@ -51,7 +51,7 @@ describe('GPIOJoystickAttachment', () => {
 
   describe('port reading - Port A', () => {
     beforeEach(() => {
-      joystick = new GPIOJoystickAttachment(true, 0) // Attach to Port A
+      joystick = new JoystickAttachment(true, 0) // Attach to Port A
     })
 
     it('should return inverted button state on Port A when attached', () => {
@@ -70,7 +70,7 @@ describe('GPIOJoystickAttachment', () => {
     })
 
     it('should handle individual button presses correctly', () => {
-      joystick.updateJoystick(GPIOJoystickAttachment.BUTTON_UP)
+      joystick.updateJoystick(JoystickAttachment.BUTTON_UP)
       const result = joystick.readPortA(0x00, 0x00)
       expect(result & 0x01).toBe(0x00) // UP button bit should be low (pressed)
       expect(result & 0xFE).toBe(0xFE) // Other bits should be high (not pressed)
@@ -79,7 +79,7 @@ describe('GPIOJoystickAttachment', () => {
 
   describe('port reading - Port B', () => {
     beforeEach(() => {
-      joystick = new GPIOJoystickAttachment(false, 0) // Attach to Port B
+      joystick = new JoystickAttachment(false, 0) // Attach to Port B
     })
 
     it('should return inverted button state on Port B when attached', () => {
@@ -100,20 +100,20 @@ describe('GPIOJoystickAttachment', () => {
 
   describe('button constants', () => {
     it('should have correct button bit values', () => {
-      expect(GPIOJoystickAttachment.BUTTON_UP).toBe(0x01)
-      expect(GPIOJoystickAttachment.BUTTON_DOWN).toBe(0x02)
-      expect(GPIOJoystickAttachment.BUTTON_LEFT).toBe(0x04)
-      expect(GPIOJoystickAttachment.BUTTON_RIGHT).toBe(0x08)
-      expect(GPIOJoystickAttachment.BUTTON_A).toBe(0x10)
-      expect(GPIOJoystickAttachment.BUTTON_B).toBe(0x20)
-      expect(GPIOJoystickAttachment.BUTTON_SELECT).toBe(0x40)
-      expect(GPIOJoystickAttachment.BUTTON_START).toBe(0x80)
+      expect(JoystickAttachment.BUTTON_UP).toBe(0x01)
+      expect(JoystickAttachment.BUTTON_DOWN).toBe(0x02)
+      expect(JoystickAttachment.BUTTON_LEFT).toBe(0x04)
+      expect(JoystickAttachment.BUTTON_RIGHT).toBe(0x08)
+      expect(JoystickAttachment.BUTTON_A).toBe(0x10)
+      expect(JoystickAttachment.BUTTON_B).toBe(0x20)
+      expect(JoystickAttachment.BUTTON_SELECT).toBe(0x40)
+      expect(JoystickAttachment.BUTTON_START).toBe(0x80)
     })
   })
 
   describe('priority and enabled', () => {
     it('should return correct priority', () => {
-      const j = new GPIOJoystickAttachment(true, 5)
+      const j = new JoystickAttachment(true, 5)
       expect(j.getPriority()).toBe(5)
     })
 

package/src/tests/IO/{GPIOAttachments/GPIOKeyboardEncoderAttachment.test.ts → Attachments/KeyboardEncoderAttachment.test.ts}

@@ -1,10 +1,10 @@
-import { GPIOKeyboardEncoderAttachment } from '../../../components/IO/GPIOAttachments/GPIOKeyboardEncoderAttachment'
+import { KeyboardEncoderAttachment } from '../../../components/IO/Attachments/KeyboardEncoderAttachment'
 
-describe('GPIOKeyboardEncoderAttachment', () => {
-  let encoder: GPIOKeyboardEncoderAttachment
+describe('KeyboardEncoderAttachment', () => {
+  let encoder: KeyboardEncoderAttachment
 
   beforeEach(() => {
-    encoder = new GPIOKeyboardEncoderAttachment(5)
+    encoder = new KeyboardEncoderAttachment(5)
   })
 
   describe('Initialization', () => {

package/src/tests/IO/{GPIOAttachments/GPIOKeyboardMatrixAttachment.test.ts → Attachments/KeyboardMatrixAttachment.test.ts}

@@ -1,10 +1,10 @@
-import { GPIOKeyboardMatrixAttachment } from '../../../components/IO/GPIOAttachments/GPIOKeyboardMatrixAttachment'
+import { KeyboardMatrixAttachment } from '../../../components/IO/Attachments/KeyboardMatrixAttachment'
 
-describe('GPIOKeyboardMatrixAttachment', () => {
-  let keyboard: GPIOKeyboardMatrixAttachment
+describe('KeyboardMatrixAttachment', () => {
+  let keyboard: KeyboardMatrixAttachment
 
   beforeEach(() => {
-    keyboard = new GPIOKeyboardMatrixAttachment(0)
+    keyboard = new KeyboardMatrixAttachment(0)
   })
 
   describe('Initialization', () => {
@@ -22,7 +22,7 @@ describe('GPIOKeyboardMatrixAttachment', () => {
     })
 
     it('should have correct priority', () => {
-      const kb = new GPIOKeyboardMatrixAttachment(5)
+      const kb = new KeyboardMatrixAttachment(5)
       expect(kb.getPriority()).toBe(5)
     })
   })

package/src/tests/IO/{GPIOAttachments/GPIOKeypadAttachment.test.ts → Attachments/KeypadAttachment.test.ts}

@@ -1,12 +1,12 @@
-import { GPIOKeypadAttachment } from '../../../components/IO/GPIOAttachments/GPIOKeypadAttachment'
+import { KeypadAttachment } from '../../../components/IO/Attachments/KeypadAttachment'
 
-describe('GPIOKeypadAttachment', () => {
-  let keypadA: GPIOKeypadAttachment   // attached to Port A
-  let keypadB: GPIOKeypadAttachment   // attached to Port B
+describe('KeypadAttachment', () => {
+  let keypadA: KeypadAttachment   // attached to Port A
+  let keypadB: KeypadAttachment   // attached to Port B
 
   beforeEach(() => {
-    keypadA = new GPIOKeypadAttachment(true, 0)
-    keypadB = new GPIOKeypadAttachment(false, 0)
+    keypadA = new KeypadAttachment(true, 0)
+    keypadB = new KeypadAttachment(false, 0)
   })
 
   // ---------------------------------------------------------------------------
@@ -36,7 +36,7 @@ describe('GPIOKeypadAttachment', () => {
     })
 
     it('should report the correct priority', () => {
-      const kp = new GPIOKeypadAttachment(true, 7)
+      const kp = new KeypadAttachment(true, 7)
       expect(kp.getPriority()).toBe(7)
     })
 
@@ -62,134 +62,134 @@ describe('GPIOKeypadAttachment', () => {
   // ---------------------------------------------------------------------------
   describe('Key press → keypad value mapping', () => {
     // Helpers: assert OE (CA2/CB2 LOW) then press and read
-    const pressAndReadA = (kp: GPIOKeypadAttachment, hid: number) => {
+    const pressAndReadA = (kp: KeypadAttachment, hid: number) => {
       kp.updateControlLines(false, false, false, true)  // CA2 LOW → OE asserted for Port A
       kp.updateKey(hid, true)
       return kp.readPortA(0x00, 0x00)
     }
-    const pressAndReadB = (kp: GPIOKeypadAttachment, hid: number) => {
+    const pressAndReadB = (kp: KeypadAttachment, hid: number) => {
       kp.updateControlLines(false, true, false, false)  // CB2 LOW → OE asserted for Port B
       kp.updateKey(hid, true)
       return kp.readPortB(0x00, 0x00)
     }
 
     it('Left Arrow (0x50) → $00  ◄', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x50)).toBe(0x00)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x50)).toBe(0x00)
     })
 
     it('Backspace is not on this keypad', () => {
-      const kp = new GPIOKeypadAttachment(true)
+      const kp = new KeypadAttachment(true)
       kp.updateControlLines(false, false, false, true)
       kp.updateKey(0x2A, true)  // Backspace – unmapped
       expect(kp.readPortA(0x00, 0x00)).toBe(0xFF)
     })
 
     it('1 (0x1E) → $01', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x1E)).toBe(0x01)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x1E)).toBe(0x01)
     })
 
     it('2 (0x1F) → $02', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x1F)).toBe(0x02)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x1F)).toBe(0x02)
     })
 
     it('3 (0x20) → $03', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x20)).toBe(0x03)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x20)).toBe(0x03)
     })
 
     it('4 (0x21) → $04', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x21)).toBe(0x04)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x21)).toBe(0x04)
     })
 
     it('5 (0x22) → $05', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x22)).toBe(0x05)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x22)).toBe(0x05)
     })
 
     it('6 (0x23) → $06', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x23)).toBe(0x06)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x23)).toBe(0x06)
     })
 
     it('7 (0x24) → $07', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x24)).toBe(0x07)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x24)).toBe(0x07)
     })
 
     it('8 (0x25) → $08', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x25)).toBe(0x08)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x25)).toBe(0x08)
     })
 
     it('9 (0x26) → $09', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x26)).toBe(0x09)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x26)).toBe(0x09)
     })
 
     it('0 (0x27) → $0A', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x27)).toBe(0x0A)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x27)).toBe(0x0A)
     })
 
     it('Right Arrow (0x4F) → $0B  ►', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x4F)).toBe(0x0B)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x4F)).toBe(0x0B)
     })
 
     it('Enter is not mapped to $0B (it maps to $14)', () => {
-      const kp = new GPIOKeypadAttachment(true)
+      const kp = new KeypadAttachment(true)
       kp.updateControlLines(false, false, false, true)
       kp.updateKey(0x28, true)  // Enter → $14
       expect(kp.readPortA(0x00, 0x00)).toBe(0x14)
     })
 
     it('f (0x09) → $0C  F', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x09)).toBe(0x0C)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x09)).toBe(0x0C)
     })
 
     it('e (0x08) → $0D  E', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x08)).toBe(0x0D)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x08)).toBe(0x0D)
     })
 
     it('d (0x07) → $0E  D', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x07)).toBe(0x0E)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x07)).toBe(0x0E)
     })
 
     it('c (0x06) → $0F  C', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x06)).toBe(0x0F)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x06)).toBe(0x0F)
     })
 
     it('Escape (0x29) → $10  ESC', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x29)).toBe(0x10)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x29)).toBe(0x10)
     })
 
     it('Insert (0x49) → $11  INS', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x49)).toBe(0x11)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x49)).toBe(0x11)
     })
 
     it('Page Up (0x4B) → $12  PGUP', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x4B)).toBe(0x12)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x4B)).toBe(0x12)
     })
 
     it('a (0x04) → $13  A', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x04)).toBe(0x13)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x04)).toBe(0x13)
     })
 
     it('Up Arrow (0x52) → $14  ▲', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x52)).toBe(0x14)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x52)).toBe(0x14)
     })
 
     it('Enter (0x28) → $14  ▲', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x28)).toBe(0x14)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x28)).toBe(0x14)
     })
 
     it('Delete (0x4C) → $15  DEL', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x4C)).toBe(0x15)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x4C)).toBe(0x15)
     })
 
     it('Page Down (0x4E) → $16  PGDN', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x4E)).toBe(0x16)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x4E)).toBe(0x16)
     })
 
     it('b (0x05) → $17  B', () => {
-      expect(pressAndReadA(new GPIOKeypadAttachment(true), 0x05)).toBe(0x17)
+      expect(pressAndReadA(new KeypadAttachment(true), 0x05)).toBe(0x17)
     })
 
     it('should also map correctly on Port B', () => {
-      expect(pressAndReadB(new GPIOKeypadAttachment(false), 0x1E)).toBe(0x01)  // '1' → $01
-      expect(pressAndReadB(new GPIOKeypadAttachment(false), 0x05)).toBe(0x17)  // 'b' → $17
+      expect(pressAndReadB(new KeypadAttachment(false), 0x1E)).toBe(0x01)  // '1' → $01
+      expect(pressAndReadB(new KeypadAttachment(false), 0x05)).toBe(0x17)  // 'b' → $17
     })
   })