ac6502 1.2.0 → 1.4.0

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', () => {

package/src/tests/IO/{VideoCard.test.ts → Video.test.ts}

@@ -1,9 +1,9 @@
-import { VideoCard, TmsMode, TmsColor } from '../../components/IO/VideoCard'
+import { Video, TmsMode, TmsColor } from '../../components/IO/Video'
 
 /**
  * Helper: write a register value through the control port (two-stage write)
  */
-const writeRegister = (vdp: VideoCard, reg: number, value: number): void => {
+const writeRegister = (vdp: Video, reg: number, value: number): void => {
   vdp.write(1, value)          // Stage 0: register value
   vdp.write(1, 0x80 | reg)    // Stage 1: register number with bit 7 set
 }
@@ -11,7 +11,7 @@ const writeRegister = (vdp: VideoCard, reg: number, value: number): void => {
 /**
  * Helper: set VRAM write address through the control port
  */
-const setWriteAddress = (vdp: VideoCard, addr: number): void => {
+const setWriteAddress = (vdp: Video, addr: number): void => {
   vdp.write(1, addr & 0xFF)           // Stage 0: address low byte
   vdp.write(1, ((addr >> 8) & 0x3F) | 0x40) // Stage 1: address high + write flag
 }
@@ -19,7 +19,7 @@ const setWriteAddress = (vdp: VideoCard, addr: number): void => {
 /**
  * Helper: set VRAM read address through the control port
  */
-const setReadAddress = (vdp: VideoCard, addr: number): void => {
+const setReadAddress = (vdp: Video, addr: number): void => {
   vdp.write(1, addr & 0xFF)           // Stage 0: address low byte
   vdp.write(1, (addr >> 8) & 0x3F)    // Stage 1: address high (no write flag)
 }
@@ -27,7 +27,7 @@ const setReadAddress = (vdp: VideoCard, addr: number): void => {
 /**
  * Helper: write a sequence of bytes to VRAM starting at an address
  */
-const writeVramBytes = (vdp: VideoCard, addr: number, bytes: number[]): void => {
+const writeVramBytes = (vdp: Video, addr: number, bytes: number[]): void => {
   setWriteAddress(vdp, addr)
   for (const b of bytes) {
     vdp.write(0, b) // Data port
@@ -37,7 +37,7 @@ const writeVramBytes = (vdp: VideoCard, addr: number, bytes: number[]): void =>
 /**
  * Helper: setup Graphics I mode with standard table addresses
  */
-const setupGraphicsI = (vdp: VideoCard): void => {
+const setupGraphicsI = (vdp: Video): void => {
   writeRegister(vdp, 0, 0x00) // No external VDP, Graphics I
   writeRegister(vdp, 1, 0x60) // 16K, display active, interrupts enabled, Graphics I
   writeRegister(vdp, 2, 0x0E) // Name table at 0x3800
@@ -51,7 +51,7 @@ const setupGraphicsI = (vdp: VideoCard): void => {
 /**
  * Helper: setup Graphics II mode with standard table addresses
  */
-const setupGraphicsII = (vdp: VideoCard): void => {
+const setupGraphicsII = (vdp: Video): void => {
   writeRegister(vdp, 0, 0x02) // Graphics II mode
   writeRegister(vdp, 1, 0x60) // 16K, display active, interrupts enabled
   writeRegister(vdp, 2, 0x0E) // Name table at 0x3800
@@ -65,7 +65,7 @@ const setupGraphicsII = (vdp: VideoCard): void => {
 /**
  * Helper: setup Text mode
  */
-const setupTextMode = (vdp: VideoCard): void => {
+const setupTextMode = (vdp: Video): void => {
   writeRegister(vdp, 0, 0x00) // No external VDP
   writeRegister(vdp, 1, 0x70) // 16K, display active, interrupts, Text mode
   writeRegister(vdp, 2, 0x0E) // Name table at 0x3800
@@ -78,7 +78,7 @@ const setupTextMode = (vdp: VideoCard): void => {
  * Must not overshoot into the next frame (scanline 0 of the next
  * frame clears the status register during sprite processing).
  */
-const renderOneFrame = (vdp: VideoCard, frequency: number = 2000000): void => {
+const renderOneFrame = (vdp: Video, frequency: number = 2000000): void => {
   // At 2MHz: cyclesPerFrame ≈ 33333, each tick = 128 cycles → ~261 ticks/frame
   const ticksPerFrame = Math.ceil((frequency / 60) / 128)
   for (let i = 0; i < ticksPerFrame; i++) {
@@ -89,7 +89,7 @@ const renderOneFrame = (vdp: VideoCard, frequency: number = 2000000): void => {
 /**
  * Helper: clear sprite attribute table (set all Y positions to 0xD0 = stop)
  */
-const clearSprites = (vdp: VideoCard, spriteAttrAddr: number = 0x3B00): void => {
+const clearSprites = (vdp: Video, spriteAttrAddr: number = 0x3B00): void => {
   setWriteAddress(vdp, spriteAttrAddr)
   for (let i = 0; i < 32; i++) {
     vdp.write(0, 0xD0) // Y = stop sentinel
@@ -99,11 +99,11 @@ const clearSprites = (vdp: VideoCard, spriteAttrAddr: number = 0x3B00): void =>
   }
 }
 
-describe('VideoCard (TMS9918 VDP)', () => {
-  let vdp: VideoCard
+describe('Video (TMS9918 VDP)', () => {
+  let vdp: Video
 
   beforeEach(() => {
-    vdp = new VideoCard()
+    vdp = new Video()
   })
 
   // ================================================================

package/src/tests/Machine.test.ts

@@ -2,17 +2,18 @@ import { Machine } from '../components/Machine'
 import { RAM } from '../components/RAM'
 import { ROM } from '../components/ROM'
 import { Cart } from '../components/Cart'
+import { ACIA } from '../components/IO/ACIA'
 
 describe('Machine', () => {
   let machine: Machine
 
   beforeEach(() => {
-    machine = new Machine()
+    machine = new Machine('cob')
   })
 
   afterEach(() => {
     // Ensure the machine loop is stopped after each test
-    machine.end()
+    machine.stop()
   })
 
   describe('Initialization', () => {
@@ -22,7 +23,6 @@ describe('Machine', () => {
     })
 
     test('Machine initializes with correct default properties', () => {
-      expect(machine.isAlive).toBe(false)
       expect(machine.isRunning).toBe(false)
       expect(machine.frequency).toBe(2000000)
       expect(machine.scale).toBe(2)
@@ -54,26 +54,11 @@ describe('Machine', () => {
   })
 
   describe('State Management', () => {
-    test('start() sets isRunning and isAlive to true', () => {
-      expect(machine.isRunning).toBe(false)
-      expect(machine.isAlive).toBe(false)
-      machine.start()
-      expect(machine.isRunning).toBe(true)
-      expect(machine.isAlive).toBe(true)
-    })
-
-    test('end() sets isRunning and isAlive to false', () => {
-      machine.start()
-      expect(machine.isRunning).toBe(true)
-      machine.end()
-      expect(machine.isRunning).toBe(false)
-      expect(machine.isAlive).toBe(false)
-    })
-
     test('run() sets isRunning to true', () => {
       expect(machine.isRunning).toBe(false)
       machine.run()
       expect(machine.isRunning).toBe(true)
+      machine.stop() // Cleanup
     })
 
     test('stop() sets isRunning to false', () => {
@@ -215,19 +200,19 @@ describe('Machine', () => {
       expect(machine.cart).toBeUndefined()
     })
 
-    test('loadCart should load cart data', async () => {
-      // Create a mock cart file path - this will test the error handling
-      await machine.loadCart('/nonexistent/path.bin')
-      // The machine should handle the error gracefully
-      expect(machine.cart).toBeUndefined()
+    test('loadCart should load cart data', () => {
+      // Load cart with test data
+      const testData = new Uint8Array(16384).fill(0xEA) // NOP instruction
+      machine.loadCart(testData)
+      expect(machine.cart).toBeDefined()
     })
   })
 
   describe('ROM Operations', () => {
-    test('loadROM should load ROM data', async () => {
-      // Create a mock ROM file path - this will test the error handling
-      await machine.loadROM('/nonexistent/path.bin')
-      // The machine should handle the error gracefully
+    test('loadROM should load ROM data', () => {
+      // Load ROM with test data
+      const testData = new Uint8Array(16384).fill(0xEA) // NOP instruction
+      machine.loadROM(testData)
       expect(machine.rom).toBeDefined()
     })
   })
@@ -266,15 +251,18 @@ describe('Machine', () => {
 
   describe('Input Handling', () => {
     test('onReceive() passes data to Serial card', () => {
-      const spy = jest.spyOn(machine.io5, 'onData')
+      const acia = machine.io5 as ACIA
+      const spy = jest.spyOn(acia, 'onData')
       machine.onReceive(0x41)
       expect(spy).toHaveBeenCalledWith(0x41)
       spy.mockRestore()
     })
 
     test('onKeyDown() routes key to GPIO attachments', () => {
-      const matrixSpy = jest.spyOn(machine.keyboardMatrixAttachment, 'updateKey')
-      const encoderSpy = jest.spyOn(machine.keyboardEncoderAttachment, 'updateKey')
+      expect(machine.keyboardMatrixAttachment).toBeDefined()
+      expect(machine.keyboardEncoderAttachment).toBeDefined()
+      const matrixSpy = jest.spyOn(machine.keyboardMatrixAttachment!, 'updateKey')
+      const encoderSpy = jest.spyOn(machine.keyboardEncoderAttachment!, 'updateKey')
       machine.onKeyDown(0x52) // Arrow Up USB HID keycode
       expect(matrixSpy).toHaveBeenCalledWith(0x52, true)
       expect(encoderSpy).toHaveBeenCalledWith(0x52, true)
@@ -283,8 +271,10 @@ describe('Machine', () => {
     })
 
     test('onKeyUp() routes key to GPIO attachments', () => {
-      const matrixSpy = jest.spyOn(machine.keyboardMatrixAttachment, 'updateKey')
-      const encoderSpy = jest.spyOn(machine.keyboardEncoderAttachment, 'updateKey')
+      expect(machine.keyboardMatrixAttachment).toBeDefined()
+      expect(machine.keyboardEncoderAttachment).toBeDefined()
+      const matrixSpy = jest.spyOn(machine.keyboardMatrixAttachment!, 'updateKey')
+      const encoderSpy = jest.spyOn(machine.keyboardEncoderAttachment!, 'updateKey')
       machine.onKeyUp(0x52) // Arrow Up USB HID keycode
       expect(matrixSpy).toHaveBeenCalledWith(0x52, false)
       expect(encoderSpy).toHaveBeenCalledWith(0x52, false)
@@ -293,14 +283,16 @@ describe('Machine', () => {
     })
 
     test('onJoystickA() routes button state to joystick A attachment', () => {
-      const spy = jest.spyOn(machine.joystickAttachmentA, 'updateJoystick')
+      expect(machine.joystickAttachmentA).toBeDefined()
+      const spy = jest.spyOn(machine.joystickAttachmentA!, 'updateJoystick')
       machine.onJoystickA(0xFF)
       expect(spy).toHaveBeenCalledWith(0xFF)
       spy.mockRestore()
     })
 
     test('onJoystickB() routes button state to joystick B attachment', () => {
-      const spy = jest.spyOn(machine.joystickAttachmentB, 'updateJoystick')
+      expect(machine.joystickAttachmentB).toBeDefined()
+      const spy = jest.spyOn(machine.joystickAttachmentB!, 'updateJoystick')
       machine.onJoystickB(0xFF)
       expect(spy).toHaveBeenCalledWith(0xFF)
       spy.mockRestore()
@@ -374,11 +366,12 @@ describe('Machine', () => {
       expect(machine.render).toBe(mockRender)
     })
 
-    test('SerialCard uses transmit callback when set', () => {
+    test('ACIA uses transmit callback when set', () => {
       const mockTransmit = jest.fn()
       machine.transmit = mockTransmit
-      // Trigger SerialCard to transmit if possible
-      machine.io5.transmit?.(0x41)
+      // Trigger ACIA to transmit if possible
+      const acia = machine.io5 as ACIA
+      acia.transmit?.(0x41)
       expect(mockTransmit).toHaveBeenCalledWith(0x41)
     })
   })

package/tsconfig.json

@@ -6,6 +6,7 @@
     "target": "es6",
     "module": "commonjs",
     "sourceMap": true,
+    "declaration": true,
     "esModuleInterop": true,
     "moduleResolution": "node"
   }