ac6502 1.3.0 → 1.4.1

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

package/src/tests/IO/{StorageCard.test.ts → Storage.test.ts}

@@ -1,14 +1,14 @@
-import { StorageCard } from '../../components/IO/StorageCard'
+import { Storage } from '../../components/IO/Storage'
 import { writeFile, unlink, readFile } from 'fs/promises'
 import { existsSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 
-describe('StorageCard (Compact Flash in IDE Mode)', () => {
-  let storageCard: StorageCard
+describe('Storage (Compact Flash in IDE Mode)', () => {
+  let storageCard: Storage
 
   beforeEach(() => {
-    storageCard = new StorageCard()
+    storageCard = new Storage()
   })
 
   describe('Initialization', () => {
@@ -587,7 +587,8 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         }
 
         // Save to file
-        await storageCard.saveToFile(testFile)
+        const storageData = storageCard.getData()
+        await writeFile(testFile, storageData)
 
         // Verify file exists
         expect(existsSync(testFile)).toBe(true)
@@ -609,7 +610,8 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
           }
         }
 
-        await storageCard.saveToFile(testFile)
+        const storageData = storageCard.getData()
+        await writeFile(testFile, storageData)
 
         // Read file directly and verify
         const fileData = await readFile(testFile)
@@ -639,7 +641,8 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         await writeFile(testFile, testData)
 
         // Load into storage card
-        await storageCard.loadFromFile(testFile)
+        const fileData = await readFile(testFile)
+        storageCard.loadData(new Uint8Array(fileData))
 
         // Verify data was loaded
         storageCard.write(0x02, 1)
@@ -651,9 +654,9 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         }
       })
 
-      it('should handle non-existent file gracefully', async () => {
-        // Try to load from a file that doesn't exist
-        await expect(storageCard.loadFromFile(nonExistentFile)).resolves.not.toThrow()
+      it('should handle non-existent file gracefully', () => {
+        // Load with null data
+        storageCard.loadData(null)
 
         // Storage should remain empty (zeros)
         storageCard.write(0x02, 1)
@@ -670,7 +673,8 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         const smallData = Buffer.alloc(1024, 0xFF) // Only 1KB
         await writeFile(invalidSizeFile, smallData)
 
-        await storageCard.loadFromFile(invalidSizeFile)
+        const fileData = await readFile(invalidSizeFile)
+        storageCard.loadData(new Uint8Array(fileData))
 
         // Storage should remain empty (zeros)
         storageCard.write(0x02, 1)
@@ -693,7 +697,8 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         }
 
         await writeFile(testFile, testData)
-        await storageCard.loadFromFile(testFile)
+        const fileData = await readFile(testFile)
+        storageCard.loadData(new Uint8Array(fileData))
 
         // Verify each sector
         for (let sector = 0; sector < 10; sector++) {
@@ -722,20 +727,22 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         }
 
         // Save to file
-        await storageCard.saveToFile(testFile)
+        const storageData = storageCard.getData()
+        await writeFile(testFile, storageData)
 
         // Create new storage card and load
-        const newStorageCard = new StorageCard()
-        await newStorageCard.loadFromFile(testFile)
+        const newStorage = new Storage()
+        const savedData = await readFile(testFile)
+        newStorage.loadData(new Uint8Array(savedData))
 
         // Verify all sectors match
         for (let sector = 0; sector < 100; sector++) {
-          newStorageCard.write(0x02, 1)
-          newStorageCard.write(0x03, sector)
-          newStorageCard.write(0x07, 0x20)
+          newStorage.write(0x02, 1)
+          newStorage.write(0x03, sector)
+          newStorage.write(0x07, 0x20)
 
           for (let i = 0; i < 512; i++) {
-            expect(newStorageCard.read(0x00)).toBe(((sector * 7 + i * 3) ^ 0x55) & 0xFF)
+            expect(newStorage.read(0x00)).toBe(((sector * 7 + i * 3) ^ 0x55) & 0xFF)
           }
         }
       })
@@ -748,22 +755,24 @@ describe('StorageCard (Compact Flash in IDE Mode)', () => {
         for (let i = 0; i < 512; i++) {
           storageCard.write(0x00, 0xCC)
         }
-        await storageCard.saveToFile(testFile)
+        await writeFile(testFile, storageCard.getData())
 
         // Load and modify
-        const card2 = new StorageCard()
-        await card2.loadFromFile(testFile)
+        const card2 = new Storage()
+        let fileData = await readFile(testFile)
+        card2.loadData(new Uint8Array(fileData))
         card2.write(0x02, 1)
         card2.write(0x03, 43)
         card2.write(0x07, 0x30)
         for (let i = 0; i < 512; i++) {
           card2.write(0x00, 0xDD)
         }
-        await card2.saveToFile(testFile)
+        await writeFile(testFile, card2.getData())
 
         // Load again and verify both sectors
-        const card3 = new StorageCard()
-        await card3.loadFromFile(testFile)
+        const card3 = new Storage()
+        fileData = await readFile(testFile)
+        card3.loadData(new Uint8Array(fileData))
 
         // Check sector 42
         card3.write(0x02, 1)

package/src/tests/IO/{GPIOCard.test.ts → VIA.test.ts}

@@ -1,5 +1,5 @@
-import { GPIOCard } from '../../components/IO/GPIOCard'
-import { GPIOAttachment } from '../../components/IO/GPIOAttachments/GPIOAttachment'
+import { VIA } from '../../components/IO/VIA'
+import { Attachment } from '../../components/IO/Attachments/Attachment'
 
 /**
  * Helper function to create a mock GPIO attachment
@@ -13,7 +13,7 @@ const createMockAttachment = (options: {
   ca2Interrupt?: boolean
   cb1Interrupt?: boolean
   cb2Interrupt?: boolean
-} = {}): GPIOAttachment => {
+} = {}): Attachment => {
   const {
     priority = 0,
     enabled = true,
@@ -46,14 +46,14 @@ const createMockAttachment = (options: {
     // Helper method to update values (not part of interface)
     setPortAValue: (value: number) => { currentPortAValue = value },
     setPortBValue: (value: number) => { currentPortBValue = value },
-  } as GPIOAttachment & { setPortAValue: (v: number) => void; setPortBValue: (v: number) => void }
+  } as Attachment & { setPortAValue: (v: number) => void; setPortBValue: (v: number) => void }
 }
 
-describe('GPIOCard (65C22 VIA)', () => {
-  let gpio: GPIOCard
+describe('VIA (65C22 VIA)', () => {
+  let gpio: VIA
 
   beforeEach(() => {
-    gpio = new GPIOCard()
+    gpio = new VIA()
   })
 
   describe('Initialization', () => {