ac6502 1.3.0 → 1.4.1

package/src/components/IO/{StorageCard.ts → Storage.ts}

@@ -1,9 +1,7 @@
 import { IO } from '../IO'
-import { readFile, writeFile } from 'fs/promises'
-import { existsSync } from 'fs'
 
 /**
- * StorageCard - Emulates a Compact Flash card in 8-bit IDE mode
+ * Storage - Emulates a Compact Flash card in 8-bit IDE mode
  * 
  * Emulates a 128MB CF card with ATA-style register interface.
  * Uses LBA (Logical Block Addressing) for sector access.
@@ -25,12 +23,12 @@ import { existsSync } from 'fs'
  * 0xEC: Identify Drive
  * 0xEF: Set Features (accepted but not implemented)
  */
-export class StorageCard implements IO {
+export class Storage implements IO {
 
   // Constants
   private static readonly STORAGE_SIZE = 128 * 1024 * 1024  // 128MB
   private static readonly SECTOR_SIZE = 512
-  private static readonly SECTOR_COUNT = StorageCard.STORAGE_SIZE / StorageCard.SECTOR_SIZE  // 262144 sectors
+  private static readonly SECTOR_COUNT = Storage.STORAGE_SIZE / Storage.SECTOR_SIZE  // 262144 sectors
 
   // Status Register Flags
   private static readonly STATUS_ERR = 0x01  // Error
@@ -43,13 +41,13 @@ export class StorageCard implements IO {
   private static readonly ERR_IDNF = 0x10    // ID Not Found
 
   // Storage and Identity data (in-memory simulation)
-  private storage: Buffer
-  private identity: Buffer
+  private storage: Uint8Array
+  private identity: Uint8Array
 
   // Data buffer (512 bytes)
-  private buffer: Buffer = Buffer.alloc(StorageCard.SECTOR_SIZE)
+  private buffer: Uint8Array = new Uint8Array(Storage.SECTOR_SIZE)
   private bufferIndex: number = 0
-  private commandDataSize: number = StorageCard.SECTOR_SIZE
+  private commandDataSize: number = Storage.SECTOR_SIZE
   private sectorOffset: number = 0
 
   // Registers
@@ -72,8 +70,8 @@ export class StorageCard implements IO {
 
   constructor() {
     // Initialize storage and identity buffers
-    this.storage = Buffer.alloc(StorageCard.STORAGE_SIZE, 0x00)
-    this.identity = Buffer.alloc(StorageCard.SECTOR_SIZE)
+    this.storage = new Uint8Array(Storage.STORAGE_SIZE)
+    this.identity = new Uint8Array(Storage.SECTOR_SIZE)
     this.generateIdentity()
     this.reset(true)
   }
@@ -137,7 +135,7 @@ export class StorageCard implements IO {
 
   reset(coldStart: boolean): void {
     this.bufferIndex = 0x0000
-    this.commandDataSize = StorageCard.SECTOR_SIZE
+    this.commandDataSize = Storage.SECTOR_SIZE
     this.sectorOffset = 0
 
     this.error = 0x00
@@ -147,7 +145,7 @@ export class StorageCard implements IO {
     this.lba1 = 0x00
     this.lba2 = 0x00
     this.lba3 = 0xE0
-    this.status = 0x00 | StorageCard.STATUS_RDY
+    this.status = 0x00 | Storage.STATUS_RDY
     this.command = 0x00
 
     this.isIdentifying = false
@@ -162,36 +160,36 @@ export class StorageCard implements IO {
 
   private executeCommand(): void {
     // New command so clear errors and flags
-    this.status &= ~StorageCard.STATUS_ERR
-    this.status &= ~StorageCard.STATUS_DRQ
+    this.status &= ~Storage.STATUS_ERR
+    this.status &= ~Storage.STATUS_DRQ
     this.error = 0x00
-    this.commandDataSize = StorageCard.SECTOR_SIZE * this.sectorCount
+    this.commandDataSize = Storage.SECTOR_SIZE * this.sectorCount
     this.bufferIndex = 0
     this.sectorOffset = 0
 
     // Check if already executing a command
     if (this.isTransferring || this.isIdentifying) {
-      this.status |= StorageCard.STATUS_ERR
-      this.error |= StorageCard.ERR_ABRT
+      this.status |= Storage.STATUS_ERR
+      this.error |= Storage.ERR_ABRT
       return
     }
 
     switch (this.command) {
       case 0xC0: { // Erase sector
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
-          const offset = this.sectorIndex() * StorageCard.SECTOR_SIZE
-          this.storage.fill(0x00, offset, offset + StorageCard.SECTOR_SIZE)
+          const offset = this.sectorIndex() * Storage.SECTOR_SIZE
+          this.storage.fill(0x00, offset, offset + Storage.SECTOR_SIZE)
         }
         break
       }
 
       case 0xEC: { // Identify drive
-        this.identity.copy(this.buffer, 0, 0, StorageCard.SECTOR_SIZE)
-        this.commandDataSize = StorageCard.SECTOR_SIZE
-        this.status |= StorageCard.STATUS_DRQ
+        this.buffer.set(this.identity.subarray(0, Storage.SECTOR_SIZE))
+        this.commandDataSize = Storage.SECTOR_SIZE
+        this.status |= Storage.STATUS_DRQ
         this.isIdentifying = true
         break
       }
@@ -199,13 +197,13 @@ export class StorageCard implements IO {
       case 0x20: // Read sector
       case 0x21:
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
           // Load first sector into buffer
-          const offset = this.sectorIndex() * StorageCard.SECTOR_SIZE
-          this.storage.copy(this.buffer, 0, offset, offset + StorageCard.SECTOR_SIZE)
-          this.status |= StorageCard.STATUS_DRQ
+          const offset = this.sectorIndex() * Storage.SECTOR_SIZE
+          this.buffer.set(this.storage.subarray(offset, offset + Storage.SECTOR_SIZE))
+          this.status |= Storage.STATUS_DRQ
           this.isTransferring = true
         }
         break
@@ -217,18 +215,18 @@ export class StorageCard implements IO {
       case 0x30: // Write sector
       case 0x31:
         if (!this.sectorValid()) {
-          this.status |= StorageCard.STATUS_ERR
-          this.error |= StorageCard.ERR_ABRT | StorageCard.ERR_IDNF
+          this.status |= Storage.STATUS_ERR
+          this.error |= Storage.ERR_ABRT | Storage.ERR_IDNF
         } else {
-          this.status |= StorageCard.STATUS_DRQ
+          this.status |= Storage.STATUS_DRQ
           this.isTransferring = true
         }
         break
 
       default:
         // Unsupported command
-        this.status |= StorageCard.STATUS_ERR
-        this.error |= StorageCard.ERR_ABRT
+        this.status |= Storage.STATUS_ERR
+        this.error |= Storage.ERR_ABRT
         break
     }
   }
@@ -242,14 +240,14 @@ export class StorageCard implements IO {
       } else {
         this.bufferIndex = 0
         this.isIdentifying = false
-        this.status &= ~StorageCard.STATUS_DRQ
+        this.status &= ~Storage.STATUS_DRQ
       }
 
       return data
     } else if (this.isTransferring) {
       const data = this.buffer[this.bufferIndex]
 
-      if (this.bufferIndex < StorageCard.SECTOR_SIZE - 1) {
+      if (this.bufferIndex < Storage.SECTOR_SIZE - 1) {
         this.bufferIndex++
       } else {
         this.bufferIndex = 0
@@ -257,11 +255,11 @@ export class StorageCard implements IO {
 
         if (this.sectorOffset < this.sectorCount) {
           // Load the next sector
-          const offset = (this.sectorIndex() + this.sectorOffset) * StorageCard.SECTOR_SIZE
-          this.storage.copy(this.buffer, 0, offset, offset + StorageCard.SECTOR_SIZE)
+          const offset = (this.sectorIndex() + this.sectorOffset) * Storage.SECTOR_SIZE
+          this.buffer.set(this.storage.subarray(offset, offset + Storage.SECTOR_SIZE))
         } else {
           this.isTransferring = false
-          this.status &= ~StorageCard.STATUS_DRQ
+          this.status &= ~Storage.STATUS_DRQ
         }
       }
 
@@ -274,21 +272,21 @@ export class StorageCard implements IO {
   private writeBuffer(value: number): void {
     this.buffer[this.bufferIndex] = value
 
-    if (this.bufferIndex < StorageCard.SECTOR_SIZE - 1) {
+    if (this.bufferIndex < Storage.SECTOR_SIZE - 1) {
       this.bufferIndex++
     } else {
       this.bufferIndex = 0
 
       // Write the current sector to storage
-      const offset = (this.sectorIndex() + this.sectorOffset) * StorageCard.SECTOR_SIZE
-      this.buffer.copy(this.storage, offset, 0, StorageCard.SECTOR_SIZE)
+      const offset = (this.sectorIndex() + this.sectorOffset) * Storage.SECTOR_SIZE
+      this.storage.set(this.buffer.subarray(0, Storage.SECTOR_SIZE), offset)
 
       this.sectorOffset++
 
       // Check if all sectors have been written
       if (this.sectorOffset >= this.sectorCount) {
         this.isTransferring = false
-        this.status &= ~StorageCard.STATUS_DRQ
+        this.status &= ~Storage.STATUS_DRQ
       }
     }
   }
@@ -298,7 +296,7 @@ export class StorageCard implements IO {
   }
 
   private sectorValid(): boolean {
-    return this.sectorIndex() < StorageCard.SECTOR_COUNT
+    return this.sectorIndex() < Storage.SECTOR_COUNT
   }
 
   private generateIdentity(): void {
@@ -434,40 +432,39 @@ export class StorageCard implements IO {
   }
 
   /**
-   * Load storage data from a file
-   * If the file doesn't exist, storage remains empty (initialized to 0x00)
+   * Load storage data from a Uint8Array, ArrayBuffer, or number array
+   * If data is not provided or wrong size, storage remains empty
    */
-  async loadFromFile(filePath: string): Promise<void> {
-    try {
-      if (existsSync(filePath)) {
-        const data = await readFile(filePath)
-        // Ensure the file is exactly the expected size
-        if (data.length === StorageCard.STORAGE_SIZE) {
-          data.copy(this.storage, 0, 0, StorageCard.STORAGE_SIZE)
-          console.log(`Storage loaded from: ${filePath}`)
-        } else {
-          console.warn(`Warning: Storage file size mismatch. Expected ${StorageCard.STORAGE_SIZE} bytes, got ${data.length} bytes.`)
-          console.warn('Storage will remain empty.')
-        }
-      } else {
-        console.log(`Storage file not found: ${filePath}`)
-        console.log('A new storage file will be created on exit.')
-      }
-    } catch (error) {
-      console.error('Error loading storage file:', error)
+  loadData(data: Uint8Array | ArrayBuffer | number[] | null): void {
+    if (!data) {
+      console.log('No storage data provided. Storage will remain empty.')
+      return
+    }
+
+    let uint8Data: Uint8Array
+    if (data instanceof ArrayBuffer) {
+      uint8Data = new Uint8Array(data)
+    } else if (data instanceof Uint8Array) {
+      uint8Data = data
+    } else {
+      uint8Data = new Uint8Array(data)
+    }
+
+    // Ensure the data is exactly the expected size
+    if (uint8Data.length === Storage.STORAGE_SIZE) {
+      this.storage.set(uint8Data)
+      console.log(`Storage loaded (${Storage.STORAGE_SIZE} bytes)`)
+    } else {
+      console.warn(`Warning: Storage data size mismatch. Expected ${Storage.STORAGE_SIZE} bytes, got ${uint8Data.length} bytes.`)
+      console.warn('Storage will remain empty.')
     }
   }
 
   /**
-   * Save storage data to a file
+   * Get storage data as Uint8Array for saving
    */
-  async saveToFile(filePath: string): Promise<void> {
-    try {
-      await writeFile(filePath, this.storage)
-      console.log(`Storage saved to: ${filePath}`)
-    } catch (error) {
-      console.error('Error saving storage file:', error)
-    }
+  getData(): Uint8Array {
+    return new Uint8Array(this.storage)
   }
 
 }

package/src/components/IO/{DevOutputBoard.ts → Terminal.ts}

@@ -2,14 +2,14 @@ import { IO } from '../IO'
 import { VTAC } from 'vtac-terminal'
 
 /**
- * DevOutputBoard - Development output board using a VTAC terminal controller
+ * Terminal - Emulates the VTAC fantasy terminal
  *
  * Register Map:
  * $00: Data / Status Register
  *   Write: sends byte to VTAC for processing
  *   Read:  always returns 0 (bit 7 is a busy flag on the real device; busy is never set here)
  */
-export class DevOutputBoard implements IO {
+export class Terminal implements IO {
 
   raiseIRQ = () => {}
   raiseNMI = () => {}

package/src/components/IO/{GPIOCard.ts → VIA.ts}

@@ -1,8 +1,8 @@
 import { IO } from '../IO'
-import { GPIOAttachment } from './GPIOAttachments/GPIOAttachment'
+import { Attachment } from './Attachments/Attachment'
 
 /**
- * GPIOCard - Emulates the 65C22 VIA (Versatile Interface Adapter)
+ * VIA - Emulates the 65C22 VIA (Versatile Interface Adapter)
  * 
  * The 65C22 VIA provides:
  * - Two 8-bit bidirectional I/O ports (Port A and Port B)
@@ -10,7 +10,7 @@ import { GPIOAttachment } from './GPIOAttachments/GPIOAttachment'
  * - Shift register for serial I/O
  * - Handshaking lines for data transfer
  */
-export class GPIOCard implements IO {
+export class VIA implements IO {
   // VIA Register addresses (offset from base address)
   private static readonly VIA_ORB = 0x00      // Output Register B
   private static readonly VIA_ORA = 0x01      // Output Register A
@@ -73,8 +73,8 @@ export class GPIOCard implements IO {
   private ticksPerMicrosecond: number = 1
 
   // Attachments
-  private portA_attachments: (GPIOAttachment | null)[] = []
-  private portB_attachments: (GPIOAttachment | null)[] = []
+  private portA_attachments: (Attachment | null)[] = []
+  private portB_attachments: (Attachment | null)[] = []
   private portA_attachmentCount: number = 0
   private portB_attachmentCount: number = 0
 
@@ -116,7 +116,7 @@ export class GPIOCard implements IO {
     // Initialize attachment arrays
     this.portA_attachmentCount = 0
     this.portB_attachmentCount = 0
-    for (let i = 0; i < GPIOCard.MAX_ATTACHMENTS_PER_PORT; i++) {
+    for (let i = 0; i < VIA.MAX_ATTACHMENTS_PER_PORT; i++) {
       this.portA_attachments[i] = null
       this.portB_attachments[i] = null
     }
@@ -143,9 +143,9 @@ export class GPIOCard implements IO {
     let value = 0x00
 
     switch (reg) {
-      case GPIOCard.VIA_ORB:
+      case VIA.VIA_ORB:
         // Reading ORB clears CB1 and CB2 interrupt flags
-        this.clearIRQFlag(GPIOCard.IRQ_CB1 | GPIOCard.IRQ_CB2)
+        this.clearIRQFlag(VIA.IRQ_CB1 | VIA.IRQ_CB2)
         value = this.readPortB()
         // Notify attachments that interrupts were cleared
         for (let i = 0; i < this.portB_attachmentCount; i++) {
@@ -155,9 +155,9 @@ export class GPIOCard implements IO {
         }
         break
 
-      case GPIOCard.VIA_ORA:
+      case VIA.VIA_ORA:
         // Reading ORA clears CA1 and CA2 interrupt flags
-        this.clearIRQFlag(GPIOCard.IRQ_CA1 | GPIOCard.IRQ_CA2)
+        this.clearIRQFlag(VIA.IRQ_CA1 | VIA.IRQ_CA2)
         value = this.readPortA()
         // Notify attachments that interrupts were cleared
         for (let i = 0; i < this.portA_attachmentCount; i++) {
@@ -167,69 +167,69 @@ export class GPIOCard implements IO {
         }
         break
 
-      case GPIOCard.VIA_DDRB:
+      case VIA.VIA_DDRB:
         value = this.regDDRB
         break
 
-      case GPIOCard.VIA_DDRA:
+      case VIA.VIA_DDRA:
         value = this.regDDRA
         break
 
-      case GPIOCard.VIA_T1CL:
+      case VIA.VIA_T1CL:
         // Reading T1CL clears T1 interrupt flag
-        this.clearIRQFlag(GPIOCard.IRQ_T1)
+        this.clearIRQFlag(VIA.IRQ_T1)
         value = this.regT1C & 0xFF
         break
 
-      case GPIOCard.VIA_T1CH:
+      case VIA.VIA_T1CH:
         value = (this.regT1C >> 8) & 0xFF
         break
 
-      case GPIOCard.VIA_T1LL:
+      case VIA.VIA_T1LL:
         value = this.regT1L & 0xFF
         break
 
-      case GPIOCard.VIA_T1LH:
+      case VIA.VIA_T1LH:
         value = (this.regT1L >> 8) & 0xFF
         break
 
-      case GPIOCard.VIA_T2CL:
+      case VIA.VIA_T2CL:
         // Reading T2CL clears T2 interrupt flag
-        this.clearIRQFlag(GPIOCard.IRQ_T2)
+        this.clearIRQFlag(VIA.IRQ_T2)
         value = this.regT2C & 0xFF
         break
 
-      case GPIOCard.VIA_T2CH:
+      case VIA.VIA_T2CH:
         value = (this.regT2C >> 8) & 0xFF
         break
 
-      case GPIOCard.VIA_SR:
+      case VIA.VIA_SR:
         // Reading SR clears SR interrupt flag
-        this.clearIRQFlag(GPIOCard.IRQ_SR)
+        this.clearIRQFlag(VIA.IRQ_SR)
         value = this.regSR
         break
 
-      case GPIOCard.VIA_ACR:
+      case VIA.VIA_ACR:
         value = this.regACR
         break
 
-      case GPIOCard.VIA_PCR:
+      case VIA.VIA_PCR:
         value = this.regPCR
         break
 
-      case GPIOCard.VIA_IFR:
+      case VIA.VIA_IFR:
         value = this.regIFR
         // Bit 7 is set if any enabled interrupt is active
         if (this.regIFR & this.regIER & 0x7F) {
-          value |= GPIOCard.IRQ_IRQ
+          value |= VIA.IRQ_IRQ
         }
         break
 
-      case GPIOCard.VIA_IER:
+      case VIA.VIA_IER:
         value = this.regIER | 0x80  // Bit 7 always reads as 1
         break
 
-      case GPIOCard.VIA_ORA_NH:
+      case VIA.VIA_ORA_NH:
         // Reading ORA without handshake (no interrupt flag clearing)
         value = this.readPortA()
         break
@@ -243,84 +243,84 @@ export class GPIOCard implements IO {
     const value = data & 0xFF
 
     switch (reg) {
-      case GPIOCard.VIA_ORB:
+      case VIA.VIA_ORB:
         // Writing ORB clears CB1 and CB2 interrupt flags
-        this.clearIRQFlag(GPIOCard.IRQ_CB1 | GPIOCard.IRQ_CB2)
+        this.clearIRQFlag(VIA.IRQ_CB1 | VIA.IRQ_CB2)
         this.regORB = value
         this.writePortB(value)
         break
 
-      case GPIOCard.VIA_ORA:
+      case VIA.VIA_ORA:
         // Writing ORA clears CA1 and CA2 interrupt flags
-        this.clearIRQFlag(GPIOCard.IRQ_CA1 | GPIOCard.IRQ_CA2)
+        this.clearIRQFlag(VIA.IRQ_CA1 | VIA.IRQ_CA2)
         this.regORA = value
         this.writePortA(value)
         break
 
-      case GPIOCard.VIA_DDRB:
+      case VIA.VIA_DDRB:
         this.regDDRB = value
         break
 
-      case GPIOCard.VIA_DDRA:
+      case VIA.VIA_DDRA:
         this.regDDRA = value
         break
 
-      case GPIOCard.VIA_T1CL:
-      case GPIOCard.VIA_T1LL:
+      case VIA.VIA_T1CL:
+      case VIA.VIA_T1LL:
         // Write to T1 low latch
         this.regT1L = (this.regT1L & 0xFF00) | value
         break
 
-      case GPIOCard.VIA_T1CH:
+      case VIA.VIA_T1CH:
         // Write to T1 high counter - loads latch into counter and starts timer
         this.regT1L = (this.regT1L & 0x00FF) | (value << 8)
         this.regT1C = this.regT1L
-        this.clearIRQFlag(GPIOCard.IRQ_T1)
+        this.clearIRQFlag(VIA.IRQ_T1)
         this.T1_running = true
         break
 
-      case GPIOCard.VIA_T1LH:
+      case VIA.VIA_T1LH:
         // Write to T1 high latch
         this.regT1L = (this.regT1L & 0x00FF) | (value << 8)
-        this.clearIRQFlag(GPIOCard.IRQ_T1)
+        this.clearIRQFlag(VIA.IRQ_T1)
         break
 
-      case GPIOCard.VIA_T2CL:
+      case VIA.VIA_T2CL:
         // Write to T2 low latch
         this.regT2L = value
         break
 
-      case GPIOCard.VIA_T2CH:
+      case VIA.VIA_T2CH:
         // Write to T2 high counter - loads latch into counter and starts timer
         this.regT2C = (value << 8) | this.regT2L
-        this.clearIRQFlag(GPIOCard.IRQ_T2)
+        this.clearIRQFlag(VIA.IRQ_T2)
         this.T2_running = true
         break
 
-      case GPIOCard.VIA_SR:
+      case VIA.VIA_SR:
         this.regSR = value
-        this.clearIRQFlag(GPIOCard.IRQ_SR)
+        this.clearIRQFlag(VIA.IRQ_SR)
         break
 
-      case GPIOCard.VIA_ACR:
+      case VIA.VIA_ACR:
         this.regACR = value
         // ACR controls timer modes, shift register, and latching
         break
 
-      case GPIOCard.VIA_PCR:
+      case VIA.VIA_PCR:
         this.regPCR = value
         // PCR controls CA1, CA2, CB1, CB2 behavior
         this.updateCA2()
         this.updateCB2()
         break
 
-      case GPIOCard.VIA_IFR:
+      case VIA.VIA_IFR:
         // Writing to IFR clears the corresponding interrupt flags
         this.regIFR &= ~(value & 0x7F)
         this.updateIRQ()
         break
 
-      case GPIOCard.VIA_IER:
+      case VIA.VIA_IER:
         // Bit 7 determines set (1) or clear (0)
         if (value & 0x80) {
           this.regIER |= (value & 0x7F)
@@ -330,7 +330,7 @@ export class GPIOCard implements IO {
         this.updateIRQ()
         break
 
-      case GPIOCard.VIA_ORA_NH:
+      case VIA.VIA_ORA_NH:
         // Writing ORA without handshake (no interrupt flag clearing)
         this.regORA = value
         this.writePortA(value)
@@ -345,7 +345,7 @@ export class GPIOCard implements IO {
     if (this.T1_running && this.regT1C > 0) {
       this.regT1C--
       if (this.regT1C === 0) {
-        this.setIRQFlag(GPIOCard.IRQ_T1)
+        this.setIRQFlag(VIA.IRQ_T1)
 
         // Check if timer is in free-run mode (ACR bit 6)
         if (this.regACR & 0x40) {
@@ -365,7 +365,7 @@ export class GPIOCard implements IO {
     if (this.T2_running && this.regT2C > 0) {
       this.regT2C--
       if (this.regT2C === 0) {
-        this.setIRQFlag(GPIOCard.IRQ_T2)
+        this.setIRQFlag(VIA.IRQ_T2)
         this.T2_running = false
       }
     }
@@ -386,20 +386,20 @@ export class GPIOCard implements IO {
     for (let i = 0; i < this.portA_attachmentCount; i++) {
       if (this.portA_attachments[i] !== null) {
         if (this.portA_attachments[i]!.hasCA1Interrupt()) {
-          this.setIRQFlag(GPIOCard.IRQ_CA1)
+          this.setIRQFlag(VIA.IRQ_CA1)
         }
         if (this.portA_attachments[i]!.hasCA2Interrupt()) {
-          this.setIRQFlag(GPIOCard.IRQ_CA2)
+          this.setIRQFlag(VIA.IRQ_CA2)
         }
       }
     }
     for (let i = 0; i < this.portB_attachmentCount; i++) {
       if (this.portB_attachments[i] !== null) {
         if (this.portB_attachments[i]!.hasCB1Interrupt()) {
-          this.setIRQFlag(GPIOCard.IRQ_CB1)
+          this.setIRQFlag(VIA.IRQ_CB1)
         }
         if (this.portB_attachments[i]!.hasCB2Interrupt()) {
-          this.setIRQFlag(GPIOCard.IRQ_CB2)
+          this.setIRQFlag(VIA.IRQ_CB2)
         }
       }
     }
@@ -413,9 +413,9 @@ export class GPIOCard implements IO {
   private updateIRQ(): void {
     // Update bit 7 of IFR based on enabled interrupts
     if (this.regIFR & this.regIER & 0x7F) {
-      this.regIFR |= GPIOCard.IRQ_IRQ
+      this.regIFR |= VIA.IRQ_IRQ
     } else {
-      this.regIFR &= ~GPIOCard.IRQ_IRQ
+      this.regIFR &= ~VIA.IRQ_IRQ
     }
   }
 
@@ -629,8 +629,8 @@ export class GPIOCard implements IO {
    * Attach a GPIO device to Port A
    * @param attachment - The attachment to add
    */
-  attachToPortA(attachment: GPIOAttachment): void {
-    if (attachment !== null && this.portA_attachmentCount < GPIOCard.MAX_ATTACHMENTS_PER_PORT) {
+  attachToPortA(attachment: Attachment): void {
+    if (attachment !== null && this.portA_attachmentCount < VIA.MAX_ATTACHMENTS_PER_PORT) {
       this.portA_attachments[this.portA_attachmentCount++] = attachment
       this.sortAttachmentsByPriority()
       // Notify the attachment of current control line states
@@ -642,8 +642,8 @@ export class GPIOCard implements IO {
    * Attach a GPIO device to Port B
    * @param attachment - The attachment to add
    */
-  attachToPortB(attachment: GPIOAttachment): void {
-    if (attachment !== null && this.portB_attachmentCount < GPIOCard.MAX_ATTACHMENTS_PER_PORT) {
+  attachToPortB(attachment: Attachment): void {
+    if (attachment !== null && this.portB_attachmentCount < VIA.MAX_ATTACHMENTS_PER_PORT) {
       this.portB_attachments[this.portB_attachmentCount++] = attachment
       this.sortAttachmentsByPriority()
       // Notify the attachment of current control line states
@@ -656,7 +656,7 @@ export class GPIOCard implements IO {
    * @param index - The attachment index
    * @returns The attachment or null if not found
    */
-  getPortAAttachment(index: number): GPIOAttachment | null {
+  getPortAAttachment(index: number): Attachment | null {
     if (index < this.portA_attachmentCount) {
       return this.portA_attachments[index]
     }
@@ -668,7 +668,7 @@ export class GPIOCard implements IO {
    * @param index - The attachment index
    * @returns The attachment or null if not found
    */
-  getPortBAttachment(index: number): GPIOAttachment | null {
+  getPortBAttachment(index: number): Attachment | null {
     if (index < this.portB_attachmentCount) {
       return this.portB_attachments[index]
     }

package/src/components/IO/{VideoCard.ts → Video.ts}

@@ -136,7 +136,7 @@ const CYCLES_PER_TICK = 128 // Must match Machine.ts ioTickInterval
 const BORDER_X = (DISPLAY_WIDTH - TMS_PIXELS_X) / 2   // 32
 const BORDER_Y = (DISPLAY_HEIGHT - TMS_PIXELS_Y) / 2  // 24
 
-export class VideoCard implements IO {
+export class Video implements IO {
 
   raiseIRQ = () => {}
   raiseNMI = () => {}