ac6502 1.2.0 → 1.4.0

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
     })
   })
 

package/src/tests/IO/{GPIOAttachments/GPIOLCDAttachment.test.ts → Attachments/LCDAttachment.test.ts}

@@ -1,5 +1,5 @@
 import {
-  GPIOLCDAttachment,
+  LCDAttachment,
   LCD_CMD_CLEAR,
   LCD_CMD_HOME,
   LCD_CMD_ENTRY_MODE,
@@ -16,36 +16,36 @@ import {
   LCD_CMD_FUNCTION_LCD_2LINE,
   LCD_CMD_SET_CGRAM_ADDR,
   LCD_CMD_SET_DRAM_ADDR,
-} from '../../../components/IO/GPIOAttachments/GPIOLCDAttachment'
+} from '../../../components/IO/Attachments/LCDAttachment'
 
 // VIA Port A pin masks
 const PIN_RS = 0x20
 const PIN_RW = 0x40
 const PIN_E  = 0x80
 
-describe('GPIOLCDAttachment', () => {
-  let lcd: GPIOLCDAttachment
+describe('LCDAttachment', () => {
+  let lcd: LCDAttachment
 
   beforeEach(() => {
-    lcd = new GPIOLCDAttachment(16, 2)
+    lcd = new LCDAttachment(16, 2)
   })
 
   // ── Helper: write a command via the GPIO bus ────────────────────
 
   /** Simulate a command write: RS=0, RW=0 */
-  function writeCommand(lcd: GPIOLCDAttachment, cmd: number): void {
+  function writeCommand(lcd: LCDAttachment, cmd: number): void {
     lcd.sendCommand(cmd)
     lcd.updatePixels()
   }
 
   /** Simulate a data byte write: RS=1, RW=0 */
-  function writeData(lcd: GPIOLCDAttachment, data: number): void {
+  function writeData(lcd: LCDAttachment, data: number): void {
     lcd.writeByte(data)
     lcd.updatePixels()
   }
 
   /** Write a string to the LCD */
-  function writeString(lcd: GPIOLCDAttachment, str: string): void {
+  function writeString(lcd: LCDAttachment, str: string): void {
     for (let i = 0; i < str.length; i++) {
       writeData(lcd, str.charCodeAt(i))
     }
@@ -53,7 +53,7 @@ describe('GPIOLCDAttachment', () => {
 
   /** Simulate full GPIO bus cycle: set Port B data, set Port A control,
    *  raise E, then lower E (falling-edge latch) */
-  function gpioBusWrite(lcd: GPIOLCDAttachment, rs: boolean, data: number): void {
+  function gpioBusWrite(lcd: LCDAttachment, rs: boolean, data: number): void {
     const portAValue = (rs ? PIN_RS : 0) // RW = 0 (write)
     const ddr = 0xFF // all outputs
 
@@ -107,7 +107,7 @@ describe('GPIOLCDAttachment', () => {
     })
 
     it('should support different display sizes', () => {
-      const lcd20x4 = new GPIOLCDAttachment(20, 4)
+      const lcd20x4 = new LCDAttachment(20, 4)
       expect(lcd20x4.cols).toBe(20)
       expect(lcd20x4.rows).toBe(4)
       // 20 × (5+1) - 1 = 119
@@ -655,10 +655,10 @@ describe('GPIOLCDAttachment', () => {
     })
 
     describe('1-row mode', () => {
-      let lcd1: GPIOLCDAttachment
+      let lcd1: LCDAttachment
 
       beforeEach(() => {
-        lcd1 = new GPIOLCDAttachment(16, 1)
+        lcd1 = new LCDAttachment(16, 1)
       })
 
       it('should wrap from position 79 to 0', () => {

package/src/tests/IO/Empty.test.ts

@@ -0,0 +1,143 @@
+import { Empty } from '../../components/IO/Empty'
+
+describe('Empty', () => {
+  let empty: Empty
+
+  beforeEach(() => {
+    empty = new Empty()
+  })
+
+  describe('Initialization', () => {
+    it('should have IRQ callback', () => {
+      expect(typeof empty.raiseIRQ).toBe('function')
+    })
+
+    it('should have NMI callback', () => {
+      expect(typeof empty.raiseNMI).toBe('function')
+    })
+
+    it('should not throw when calling raiseIRQ', () => {
+      expect(() => empty.raiseIRQ()).not.toThrow()
+    })
+
+    it('should not throw when calling raiseNMI', () => {
+      expect(() => empty.raiseNMI()).not.toThrow()
+    })
+  })
+
+  describe('Reading', () => {
+    it('should return 0 for any address', () => {
+      expect(empty.read(0x00)).toBe(0)
+      expect(empty.read(0x42)).toBe(0)
+      expect(empty.read(0xFF)).toBe(0)
+      expect(empty.read(0x1000)).toBe(0)
+    })
+
+    it('should consistently return 0 for the same address', () => {
+      const address = 0x80
+      expect(empty.read(address)).toBe(0)
+      expect(empty.read(address)).toBe(0)
+      expect(empty.read(address)).toBe(0)
+    })
+  })
+
+  describe('Writing', () => {
+    it('should accept writes without throwing errors', () => {
+      expect(() => empty.write(0x00, 0x00)).not.toThrow()
+      expect(() => empty.write(0x42, 0xAA)).not.toThrow()
+      expect(() => empty.write(0xFF, 0xFF)).not.toThrow()
+    })
+
+    it('should not affect read values after writing', () => {
+      empty.write(0x10, 0x55)
+      expect(empty.read(0x10)).toBe(0)
+
+      empty.write(0x20, 0xAA)
+      expect(empty.read(0x20)).toBe(0)
+    })
+
+    it('should handle multiple writes to the same address', () => {
+      const address = 0x30
+      expect(() => {
+        empty.write(address, 0x11)
+        empty.write(address, 0x22)
+        empty.write(address, 0x33)
+      }).not.toThrow()
+
+      expect(empty.read(address)).toBe(0)
+    })
+  })
+
+  describe('Tick', () => {
+    it('should not throw when ticked', () => {
+      expect(() => empty.tick(1000000)).not.toThrow()
+    })
+
+    it('should handle various frequencies', () => {
+      expect(() => empty.tick(0)).not.toThrow()
+      expect(() => empty.tick(1)).not.toThrow()
+      expect(() => empty.tick(1000000)).not.toThrow()
+      expect(() => empty.tick(10000000)).not.toThrow()
+    })
+
+    it('should not affect read values', () => {
+      empty.tick(1000000)
+      expect(empty.read(0x50)).toBe(0)
+    })
+  })
+
+  describe('Reset', () => {
+    it('should not throw when reset with cold start', () => {
+      expect(() => empty.reset(true)).not.toThrow()
+    })
+
+    it('should not throw when reset without cold start', () => {
+      expect(() => empty.reset(false)).not.toThrow()
+    })
+
+    it('should not affect read values after reset', () => {
+      empty.reset(true)
+      expect(empty.read(0x60)).toBe(0)
+
+      empty.reset(false)
+      expect(empty.read(0x60)).toBe(0)
+    })
+
+    it('should handle multiple resets', () => {
+      expect(() => {
+        empty.reset(true)
+        empty.reset(false)
+        empty.reset(true)
+      }).not.toThrow()
+    })
+  })
+
+  describe('Integration', () => {
+    it('should handle a sequence of operations', () => {
+      expect(() => {
+        empty.reset(true)
+        empty.write(0x00, 0xFF)
+        const value = empty.read(0x00)
+        expect(value).toBe(0)
+        empty.tick(1000000)
+        empty.raiseIRQ()
+        empty.raiseNMI()
+        empty.reset(false)
+      }).not.toThrow()
+    })
+
+    it('should remain functional after extensive use', () => {
+      for (let i = 0; i < 100; i++) {
+        empty.write(i, i & 0xFF)
+        empty.tick(1000)
+      }
+
+      for (let i = 0; i < 100; i++) {
+        expect(empty.read(i)).toBe(0)
+      }
+
+      empty.reset(true)
+      expect(empty.read(0x00)).toBe(0)
+    })
+  })
+})

package/src/tests/IO/{RAMCard.test.ts → RAMBank.test.ts}

@@ -1,33 +1,33 @@
-import { RAMCard } from '../../components/IO/RAMCard'
+import { RAMBank } from '../../components/IO/RAMBank'
 
-describe('RAMCard', () => {
-  let ramCard: RAMCard
+describe('RAMBank', () => {
+  let ramCard: RAMBank
 
   beforeEach(() => {
-    ramCard = new RAMCard()
+    ramCard = new RAMBank()
   })
 
   describe('Static Properties', () => {
     it('should have correct total size', () => {
-      expect(RAMCard.TOTAL_SIZE).toBe(256 * 1024)
+      expect(RAMBank.TOTAL_SIZE).toBe(256 * 1024)
     })
 
     it('should have correct bank size', () => {
-      expect(RAMCard.BANK_SIZE).toBe(1024)
+      expect(RAMBank.BANK_SIZE).toBe(1024)
     })
 
     it('should have correct number of banks', () => {
-      expect(RAMCard.NUM_BANKS).toBe(256)
+      expect(RAMBank.NUM_BANKS).toBe(256)
     })
 
     it('should have correct bank control register address', () => {
-      expect(RAMCard.BANK_CONTROL_REGISTER).toBe(0x3FF)
+      expect(RAMBank.BANK_CONTROL_REGISTER).toBe(0x3FF)
     })
   })
 
   describe('Initialization', () => {
     it('should initialize with all data as 0x00', () => {
-      for (let i = 0; i < RAMCard.TOTAL_SIZE; i++) {
+      for (let i = 0; i < RAMBank.TOTAL_SIZE; i++) {
         expect(ramCard.data[i]).toBe(0x00)
       }
     })
@@ -60,13 +60,13 @@ describe('RAMCard', () => {
 
     it('should read bank control register and return current bank', () => {
       ramCard.currentBank = 0
-      expect(ramCard.read(RAMCard.BANK_CONTROL_REGISTER)).toBe(0)
+      expect(ramCard.read(RAMBank.BANK_CONTROL_REGISTER)).toBe(0)
 
       ramCard.currentBank = 42
-      expect(ramCard.read(RAMCard.BANK_CONTROL_REGISTER)).toBe(42)
+      expect(ramCard.read(RAMBank.BANK_CONTROL_REGISTER)).toBe(42)
 
       ramCard.currentBank = 255
-      expect(ramCard.read(RAMCard.BANK_CONTROL_REGISTER)).toBe(255)
+      expect(ramCard.read(RAMBank.BANK_CONTROL_REGISTER)).toBe(255)
     })
   })
 
@@ -98,15 +98,15 @@ describe('RAMCard', () => {
     })
 
     it('should switch banks via bank control register', () => {
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 5)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 5)
       expect(ramCard.currentBank).toBe(5)
     })
 
     it('should mask bank number to 0xFF', () => {
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 0x1FF)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 0x1FF)
       expect(ramCard.currentBank).toBe(0xFF)
 
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 0x100)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 0x100)
       expect(ramCard.currentBank).toBe(0x00)
     })
   })
@@ -118,7 +118,7 @@ describe('RAMCard', () => {
       expect(ramCard.read(50)).toBe(0x11)
 
       // Switch to bank 1
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 1)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 1)
       expect(ramCard.read(50)).toBe(0x00)
 
       // Write different value to address 50 in bank 1
@@ -126,7 +126,7 @@ describe('RAMCard', () => {
       expect(ramCard.read(50)).toBe(0x22)
 
       // Switch back to bank 0
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 0)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 0)
       expect(ramCard.read(50)).toBe(0x11)
     })
 
@@ -136,38 +136,38 @@ describe('RAMCard', () => {
       ramCard.write(200, 0xBB)
 
       // Switch to bank 1
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 1)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 1)
       ramCard.write(100, 0xCC)
       ramCard.write(200, 0xDD)
 
       // Switch to bank 2
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 2)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 2)
       ramCard.write(100, 0xEE)
 
       // Verify data in bank 2
       expect(ramCard.read(100)).toBe(0xEE)
 
       // Switch to bank 1
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 1)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 1)
       expect(ramCard.read(100)).toBe(0xCC)
       expect(ramCard.read(200)).toBe(0xDD)
 
       // Switch to bank 0
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 0)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 0)
       expect(ramCard.read(100)).toBe(0xAA)
       expect(ramCard.read(200)).toBe(0xBB)
     })
 
     it('should switch between all 256 banks', () => {
       // Write unique val to each bank at address 0
-      for (let bank = 0; bank < RAMCard.NUM_BANKS; bank++) {
-        ramCard.write(RAMCard.BANK_CONTROL_REGISTER, bank)
+      for (let bank = 0; bank < RAMBank.NUM_BANKS; bank++) {
+        ramCard.write(RAMBank.BANK_CONTROL_REGISTER, bank)
         ramCard.write(0, bank & 0xFF)
       }
 
       // Verify each bank has correct value
-      for (let bank = 0; bank < RAMCard.NUM_BANKS; bank++) {
-        ramCard.write(RAMCard.BANK_CONTROL_REGISTER, bank)
+      for (let bank = 0; bank < RAMBank.NUM_BANKS; bank++) {
+        ramCard.write(RAMBank.BANK_CONTROL_REGISTER, bank)
         expect(ramCard.read(0)).toBe(bank & 0xFF)
       }
     })
@@ -176,7 +176,7 @@ describe('RAMCard', () => {
   describe('Reset', () => {
     it('should not reset on warm start', () => {
       ramCard.write(100, 0x42)
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 42)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 42)
 
       ramCard.reset(false)
 
@@ -187,17 +187,17 @@ describe('RAMCard', () => {
     it('should reset all data on cold start', () => {
       ramCard.write(100, 0x42)
       ramCard.write(500, 0xAB)
-      ramCard.write(RAMCard.TOTAL_SIZE - 1, 0xFF)
+      ramCard.write(RAMBank.TOTAL_SIZE - 1, 0xFF)
 
       ramCard.reset(true)
 
       expect(ramCard.data[100]).toBe(0x00)
       expect(ramCard.data[500]).toBe(0x00)
-      expect(ramCard.data[RAMCard.TOTAL_SIZE - 1]).toBe(0x00)
+      expect(ramCard.data[RAMBank.TOTAL_SIZE - 1]).toBe(0x00)
     })
 
     it('should reset to bank 0 on cold start', () => {
-      ramCard.write(RAMCard.BANK_CONTROL_REGISTER, 100)
+      ramCard.write(RAMBank.BANK_CONTROL_REGISTER, 100)
       expect(ramCard.currentBank).toBe(100)
 
       ramCard.reset(true)
@@ -208,8 +208,8 @@ describe('RAMCard', () => {
     it('should clear all RAM on cold start', () => {
       // Fill multiple banks with data
       for (let bank = 0; bank < 10; bank++) {
-        ramCard.write(RAMCard.BANK_CONTROL_REGISTER, bank)
-        for (let addr = 0; addr < RAMCard.BANK_SIZE; addr++) {
+        ramCard.write(RAMBank.BANK_CONTROL_REGISTER, bank)
+        for (let addr = 0; addr < RAMBank.BANK_SIZE; addr++) {
           ramCard.write(addr, bank)
         }
       }
@@ -217,7 +217,7 @@ describe('RAMCard', () => {
       ramCard.reset(true)
 
       // Verify all data is cleared
-      for (let i = 0; i < RAMCard.TOTAL_SIZE; i++) {
+      for (let i = 0; i < RAMBank.TOTAL_SIZE; i++) {
         expect(ramCard.data[i]).toBe(0x00)
       }
     })
@@ -257,7 +257,7 @@ describe('RAMCard', () => {
 
     it('should handle rapid bank switches', () => {
       for (let i = 0; i < 100; i++) {
-        ramCard.write(RAMCard.BANK_CONTROL_REGISTER, i % 256)
+        ramCard.write(RAMBank.BANK_CONTROL_REGISTER, i % 256)
         ramCard.write(0, i & 0xFF)
       }
 

package/src/tests/IO/{RTCCard.test.ts → RTC.test.ts}

@@ -1,13 +1,13 @@
-import { RTCCard } from '../../components/IO/RTCCard'
+import { RTC } from '../../components/IO/RTC'
 
 const bcdToDecimal = (bcd: number): number => (((bcd >> 4) & 0x0f) * 10) + (bcd & 0x0f)
 
-const enableTransfers = (rtc: RTCCard): void => {
+const enableTransfers = (rtc: RTC): void => {
 	rtc.write(0x0f, 0x80)
 	rtc.tick(1)
 }
 
-const setTime = (rtc: RTCCard, values: {
+const setTime = (rtc: RTC, values: {
 	seconds: number
 	minutes: number
 	hours: number
@@ -28,11 +28,11 @@ const setTime = (rtc: RTCCard, values: {
 	rtc.write(0x07, values.century)
 }
 
-describe('RTCCard', () => {
-	let rtc: RTCCard
+describe('RTC', () => {
+	let rtc: RTC
 
 	beforeEach(() => {
-		rtc = new RTCCard()
+		rtc = new RTC()
 	})
 
 	describe('Initialization', () => {

package/src/tests/IO/{SoundCard.test.ts → Sound.test.ts}

@@ -1,4 +1,4 @@
-import { SoundCard, SIDVoice, EnvelopeState, SID_CLOCK_NTSC } from '../../components/IO/SoundCard'
+import { Sound, SIDVoice, EnvelopeState, SID_CLOCK_NTSC } from '../../components/IO/Sound'
 
 // Voice register offsets (relative to voice base)
 const VOICE1_BASE = 0x00
@@ -35,21 +35,21 @@ const CTRL_PULSE = 0x40
 const CTRL_NOISE = 0x80
 
 /**
- * Helper: tick the SoundCard for a given number of macro-ticks
+ * Helper: tick the Sound for a given number of macro-ticks
  * Each tick processes 128 SID clock cycles internally
  */
-const tickN = (sid: SoundCard, n: number): void => {
+const tickN = (sid: Sound, n: number): void => {
   for (let i = 0; i < n; i++) {
     sid.tick(SID_CLOCK_NTSC)
   }
 }
 
-describe('SoundCard (MOS 6581 SID)', () => {
+describe('Sound (MOS 6581 SID)', () => {
 
-  let sid: SoundCard
+  let sid: Sound
 
   beforeEach(() => {
-    sid = new SoundCard()
+    sid = new Sound()
     sid.sampleRate = 44100
     sid.sidClock = SID_CLOCK_NTSC
   })