ac6502 1.9.3 → 1.11.0

package/src/components/IO/Attachments/KeyboardEncoderAttachment.ts

@@ -2,35 +2,35 @@ import { AttachmentBase } from './Attachment'
 
 /**
  * USB HID Keycode to ASCII mapping table
- * Maps USB HID usage IDs to ASCII characters
+ * Maps USB HID usage IDs to uppercase ASCII characters
  */
 const USB_HID_TO_ASCII: { [key: number]: number } = {
-  0x04: 0x61, // a
-  0x05: 0x62, // b
-  0x06: 0x63, // c
-  0x07: 0x64, // d
-  0x08: 0x65, // e
-  0x09: 0x66, // f
-  0x0A: 0x67, // g
-  0x0B: 0x68, // h
-  0x0C: 0x69, // i
-  0x0D: 0x6A, // j
-  0x0E: 0x6B, // k
-  0x0F: 0x6C, // l
-  0x10: 0x6D, // m
-  0x11: 0x6E, // n
-  0x12: 0x6F, // o
-  0x13: 0x70, // p
-  0x14: 0x71, // q
-  0x15: 0x72, // r
-  0x16: 0x73, // s
-  0x17: 0x74, // t
-  0x18: 0x75, // u
-  0x19: 0x76, // v
-  0x1A: 0x77, // w
-  0x1B: 0x78, // x
-  0x1C: 0x79, // y
-  0x1D: 0x7A, // z
+  0x04: 0x41, // A
+  0x05: 0x42, // B
+  0x06: 0x43, // C
+  0x07: 0x44, // D
+  0x08: 0x45, // E
+  0x09: 0x46, // F
+  0x0A: 0x47, // G
+  0x0B: 0x48, // H
+  0x0C: 0x49, // I
+  0x0D: 0x4A, // J
+  0x0E: 0x4B, // K
+  0x0F: 0x4C, // L
+  0x10: 0x4D, // M
+  0x11: 0x4E, // N
+  0x12: 0x4F, // O
+  0x13: 0x50, // P
+  0x14: 0x51, // Q
+  0x15: 0x52, // R
+  0x16: 0x53, // S
+  0x17: 0x54, // T
+  0x18: 0x55, // U
+  0x19: 0x56, // V
+  0x1A: 0x57, // W
+  0x1B: 0x58, // X
+  0x1C: 0x59, // Y
+  0x1D: 0x5A, // Z
   0x1E: 0x31, // 1
   0x1F: 0x32, // 2
   0x20: 0x33, // 3
@@ -68,27 +68,25 @@ const USB_HID_TO_ASCII: { [key: number]: number } = {
 /**
  * KeyboardEncoderAttachment - Emulates a keyboard encoder that provides ASCII-encoded
  * key data on both GPIO ports A and B.
- * 
+ *
  * This attachment uses the VIA control lines to signal data availability:
  * - CA2 LOW enables Port A
  * - CB2 LOW enables Port B
  * - CA1 interrupt signals data ready on Port A
  * - CB1 interrupt signals data ready on Port B
- * 
- * The encoder supports extensive modifier key combinations:
- * - MENU key: 0x80 (alone), 0x90 (with Alt)
- * - Function keys F1-F15: 0x81-0x8F (alone), 0x91-0x9F (with Alt)
- * - Ctrl combinations: Control codes 0x00-0x1F
- * - Alt+Shift: Extended character set 0xA0-0xFF
- * - Alt: Extended character set 0xE0-0xFF
- * - Shift: Uppercase letters and shifted symbols
+ *
+ * Letters are always output as uppercase ASCII (0x41-0x5A).
+ * Supported modifier combinations:
+ * - Ctrl+letter: Control codes 0x01-0x1A
+ * - Ctrl+special: Ctrl+2=NUL, Ctrl+6=RS, Ctrl+-=US, Ctrl+[=ESC, Ctrl+\=FS, Ctrl+]=GS
+ * - Shift+number/symbol: Standard US keyboard shifted symbols
  */
 export class KeyboardEncoderAttachment extends AttachmentBase {
   // Selects which port(s) receive data and fire interrupts:
   // 'A' = PS/2 encoder on Port A (CA1 IRQ only)
   // 'B' = Matrix encoder on Port B (CB1 IRQ only)
   // 'both' = both ports active (default)
-  activePort: 'A' | 'B' | 'both' = 'both'
+  activePort: 'A' | 'B' | 'both' = 'B'
 
   // Port A state
   private asciiDataA: number = 0x00
@@ -105,9 +103,6 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
   // Modifier key states
   private shiftPressed: boolean = false
   private ctrlPressed: boolean = false
-  private altPressed: boolean = false
-  private menuPressed: boolean = false
-  private capsLockActive: boolean = false
 
   // Control line states
   private stateCA1: boolean = false
@@ -133,9 +128,6 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
     this.enabledB = false
     this.shiftPressed = false
     this.ctrlPressed = false
-    this.altPressed = false
-    this.menuPressed = false
-    this.capsLockActive = false
   }
 
   readPortA(ddrA: number, orA: number): number {
@@ -196,34 +188,6 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
    * Map a USB HID keycode to ASCII with modifier keys applied
    */
   private mapKeyWithModifiers(usbHidKeycode: number): number {
-    // Handle MENU key (USB HID 0xE3 Left GUI, 0xE7 Right GUI)
-    if (usbHidKeycode === 0xE3 || usbHidKeycode === 0xE7) {
-      if (this.altPressed) {
-        return 0x90  // Alt+MENU
-      }
-      return 0x80  // MENU alone
-    }
-
-    // Handle function keys F1-F15 (USB HID 0x3A-0x45 for F1-F12, 0x68-0x6A for F13-F15)
-    // F1-F15 without Alt → 0x81-0x8F
-    // Alt+F1-F15 → 0x91-0x9F
-    if (usbHidKeycode >= 0x3A && usbHidKeycode <= 0x45) {
-      // F1-F12 (0x3A-0x45)
-      const fKeyOffset = usbHidKeycode - 0x3A  // 0-11 for F1-F12
-      if (this.altPressed) {
-        return 0x91 + fKeyOffset  // Alt+F1-F12 → 0x91-0x9C
-      }
-      return 0x81 + fKeyOffset  // F1-F12 → 0x81-0x8C
-    }
-    if (usbHidKeycode >= 0x68 && usbHidKeycode <= 0x6A) {
-      // F13-F15 (0x68-0x6A)
-      const fKeyOffset = usbHidKeycode - 0x68 + 12  // 12-14 for F13-F15
-      if (this.altPressed) {
-        return 0x91 + fKeyOffset  // Alt+F13-F15 → 0x9D-0x9F
-      }
-      return 0x81 + fKeyOffset  // F13-F15 → 0x8D-0x8F
-    }
-
     // Get base ASCII character from USB HID keycode
     const baseChar = USB_HID_TO_ASCII[usbHidKeycode] || 0x00
 
@@ -233,144 +197,25 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
     }
 
     // Handle Ctrl combinations - control codes
-    if (this.ctrlPressed && !this.altPressed) {
+    if (this.ctrlPressed) {
       // Ctrl with letters produces control codes 0x01-0x1A
-      if (baseChar >= 0x61 && baseChar <= 0x7A) {  // a-z
-        return baseChar - 0x61 + 0x01
-      }
       if (baseChar >= 0x41 && baseChar <= 0x5A) {  // A-Z
         return baseChar - 0x41 + 0x01
       }
 
       // Ctrl with other special keys
       switch (baseChar) {
-        case 0x32: case 0x40: return 0x00  // Ctrl+2 or Ctrl+@ = NUL
-        case 0x36: case 0x5E: return 0x1E  // Ctrl+6 or Ctrl+^ = RS (UP arrow position)
-        case 0x2D: case 0x5F: return 0x1F  // Ctrl+- or Ctrl+_ = US (DOWN arrow position)
-        case 0x5B: case 0x7B: return 0x1B  // Ctrl+[ or Ctrl+{ = ESC
-        case 0x5C: case 0x7C: return 0x1C  // Ctrl+\ or Ctrl+| = FS (LEFT arrow position)
-        case 0x5D: case 0x7D: return 0x1D  // Ctrl+] or Ctrl+} = GS (RIGHT arrow position)
-      }
-    }
-
-    // Handle Alt+Shift combinations - extended character set
-    if (this.altPressed && this.shiftPressed) {
-      switch (baseChar) {
-        case 0x31: return 0xA1  // '1' -> ¡
-        case 0x27: return 0xA2  // '\'' -> ¢
-        case 0x33: return 0xA3  // '3' -> £
-        case 0x34: return 0xA4  // '4' -> ¤
-        case 0x35: return 0xA5  // '5' -> ¥
-        case 0x37: return 0xA6  // '7' -> ¦
-        case 0x39: return 0xA8  // '9' -> ¨
-        case 0x30: return 0xA9  // '0' -> ©
-        case 0x38: return 0xAA  // '8' -> ª
-        case 0x3D: return 0xAB  // '=' -> «
-        case 0x3B: return 0xBA  // ';' -> º
-        case 0x2C: return 0xBC  // ',' -> ¼
-        case 0x2E: return 0xBE  // '.' -> ¾
-        case 0x2F: return 0xBF  // '/' -> ¿
-        case 0x32: return 0xC0  // '2' -> À
-        case 0x61: case 0x41: return 0xC1  // 'a'/'A' -> Á
-        case 0x62: case 0x42: return 0xC2  // 'b'/'B' -> Â
-        case 0x63: case 0x43: return 0xC3  // 'c'/'C' -> Ã
-        case 0x64: case 0x44: return 0xC4  // 'd'/'D' -> Ä
-        case 0x65: case 0x45: return 0xC5  // 'e'/'E' -> Å
-        case 0x66: case 0x46: return 0xC6  // 'f'/'F' -> Æ
-        case 0x67: case 0x47: return 0xC7  // 'g'/'G' -> Ç
-        case 0x68: case 0x48: return 0xC8  // 'h'/'H' -> È
-        case 0x69: case 0x49: return 0xC9  // 'i'/'I' -> É
-        case 0x6A: case 0x4A: return 0xCA  // 'j'/'J' -> Ê
-        case 0x6B: case 0x4B: return 0xCB  // 'k'/'K' -> Ë
-        case 0x6C: case 0x4C: return 0xCC  // 'l'/'L' -> Ì
-        case 0x6D: case 0x4D: return 0xCD  // 'm'/'M' -> Í
-        case 0x6E: case 0x4E: return 0xCE  // 'n'/'N' -> Î
-        case 0x6F: case 0x4F: return 0xCF  // 'o'/'O' -> Ï
-        case 0x70: case 0x50: return 0xD0  // 'p'/'P' -> Ð
-        case 0x71: case 0x51: return 0xD1  // 'q'/'Q' -> Ñ
-        case 0x72: case 0x52: return 0xD2  // 'r'/'R' -> Ò
-        case 0x73: case 0x53: return 0xD3  // 's'/'S' -> Ó
-        case 0x74: case 0x54: return 0xD4  // 't'/'T' -> Ô
-        case 0x75: case 0x55: return 0xD5  // 'u'/'U' -> Õ
-        case 0x76: case 0x56: return 0xD6  // 'v'/'V' -> Ö
-        case 0x77: case 0x57: return 0xD7  // 'w'/'W' -> ×
-        case 0x78: case 0x58: return 0xD8  // 'x'/'X' -> Ø
-        case 0x79: case 0x59: return 0xD9  // 'y'/'Y' -> Ù
-        case 0x7A: case 0x5A: return 0xDA  // 'z'/'Z' -> Ú
-        case 0x5B: return 0xFB  // '[' -> û
-        case 0x5C: return 0xFC  // '\\' -> ü
-        case 0x5D: return 0xFD  // ']' -> ý
-        case 0x60: return 0xFE  // '`' -> þ
-        case 0x36: return 0xDE  // '6' -> Þ
-        case 0x2D: return 0xDF  // '-' -> ß
-      }
-    }
-
-    // Handle Alt combinations (without shift)
-    if (this.altPressed && !this.shiftPressed) {
-      switch (baseChar) {
-        case 0x20: return 0xA0  // Space -> nbsp
-        case 0x27: return 0xA7  // '\'' -> §
-        case 0x2C: return 0xAC  // ',' -> ¬
-        case 0x2D: return 0xAD  // '-' -> soft hyphen
-        case 0x2E: return 0xAE  // '.' -> ®
-        case 0x2F: return 0xAF  // '/' -> ¯
-        case 0x30: return 0xB0  // '0' -> °
-        case 0x31: return 0xB1  // '1' -> ±
-        case 0x32: return 0xB2  // '2' -> ²
-        case 0x33: return 0xB3  // '3' -> ³
-        case 0x34: return 0xB4  // '4' -> ´
-        case 0x35: return 0xB5  // '5' -> µ
-        case 0x36: return 0xB6  // '6' -> ¶
-        case 0x37: return 0xB7  // '7' -> ·
-        case 0x38: return 0xB8  // '8' -> ¸
-        case 0x39: return 0xB9  // '9' -> ¹
-        case 0x3B: return 0xBB  // ';' -> »
-        case 0x3D: return 0xBD  // '=' -> ½
-        case 0x5B: return 0xDB  // '[' -> Û
-        case 0x5C: return 0xDC  // '\\' -> Ü
-        case 0x5D: return 0xDD  // ']' -> Ý
-        case 0x60: return 0xE0  // '`' -> à
-        case 0x61: case 0x41: return 0xE1  // 'a'/'A' -> á
-        case 0x62: case 0x42: return 0xE2  // 'b'/'B' -> â
-        case 0x63: case 0x43: return 0xE3  // 'c'/'C' -> ã
-        case 0x64: case 0x44: return 0xE4  // 'd'/'D' -> ä
-        case 0x65: case 0x45: return 0xE5  // 'e'/'E' -> å
-        case 0x66: case 0x46: return 0xE6  // 'f'/'F' -> æ
-        case 0x67: case 0x47: return 0xE7  // 'g'/'G' -> ç
-        case 0x68: case 0x48: return 0xE8  // 'h'/'H' -> è
-        case 0x69: case 0x49: return 0xE9  // 'i'/'I' -> é
-        case 0x6A: case 0x4A: return 0xEA  // 'j'/'J' -> ê
-        case 0x6B: case 0x4B: return 0xEB  // 'k'/'K' -> ë
-        case 0x6C: case 0x4C: return 0xEC  // 'l'/'L' -> ì
-        case 0x6D: case 0x4D: return 0xED  // 'm'/'M' -> í
-        case 0x6E: case 0x4E: return 0xEE  // 'n'/'N' -> î
-        case 0x6F: case 0x4F: return 0xEF  // 'o'/'O' -> ï
-        case 0x70: case 0x50: return 0xF0  // 'p'/'P' -> ð
-        case 0x71: case 0x51: return 0xF1  // 'q'/'Q' -> ñ
-        case 0x72: case 0x52: return 0xF2  // 'r'/'R' -> ò
-        case 0x73: case 0x53: return 0xF3  // 's'/'S' -> ó
-        case 0x74: case 0x54: return 0xF4  // 't'/'T' -> ô
-        case 0x75: case 0x55: return 0xF5  // 'u'/'U' -> õ
-        case 0x76: case 0x56: return 0xF6  // 'v'/'V' -> ö
-        case 0x77: case 0x57: return 0xF7  // 'w'/'W' -> ÷
-        case 0x78: case 0x58: return 0xF8  // 'x'/'X' -> ø
-        case 0x79: case 0x59: return 0xF9  // 'y'/'Y' -> ù
-        case 0x7A: case 0x5A: return 0xFA  // 'z'/'Z' -> ú
-        case 0x7F: return 0xFF  // DEL -> ÿ
+        case 0x32: return 0x00  // Ctrl+2 = NUL
+        case 0x36: return 0x1E  // Ctrl+6 = RS
+        case 0x2D: return 0x1F  // Ctrl+- = US
+        case 0x5B: return 0x1B  // Ctrl+[ = ESC
+        case 0x5C: return 0x1C  // Ctrl+\ = FS
+        case 0x5D: return 0x1D  // Ctrl+] = GS
       }
     }
 
-    // Handle Shift combinations - uppercase and shifted symbols
-    // Caps Lock XORs with Shift for letters (they cancel each other out)
-    const effectiveUppercase = this.capsLockActive !== this.shiftPressed
-    if (effectiveUppercase && !this.ctrlPressed && !this.altPressed) {
-      if (baseChar >= 0x61 && baseChar <= 0x7A) {  // a-z
-        return baseChar - 0x61 + 0x41  // A-Z
-      }
-    }
-    if (this.shiftPressed && !this.ctrlPressed && !this.altPressed) {
-      // Shifted symbols (Caps Lock does not affect symbols)
+    // Handle Shift combinations - shifted symbols only (letters are always uppercase)
+    if (this.shiftPressed && !this.ctrlPressed) {
       switch (baseChar) {
         case 0x31: return 0x21  // '1' -> '!'
         case 0x32: return 0x40  // '2' -> '@'
@@ -413,27 +258,10 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
         this.ctrlPressed = pressed
         return  // Don't generate output for modifier keys alone
 
-      case 0x39:  // Caps Lock - toggle on press, ignore release
-        if (pressed) {
-          this.capsLockActive = !this.capsLockActive
-        }
-        return
-
       case 0xE1:  // Left Shift
       case 0xE5:  // Right Shift
         this.shiftPressed = pressed
         return
-
-      case 0xE2:  // Left Alt
-      case 0xE6:  // Right Alt
-        this.altPressed = pressed
-        return
-
-      case 0xE3:  // Left GUI (MENU)
-      case 0xE7:  // Right GUI (MENU)
-        this.menuPressed = pressed
-        // MENU key generates output, so don't return - fall through
-        break
     }
 
     // Only process key presses, not releases (encoder only reports keypress events)
@@ -445,7 +273,7 @@ export class KeyboardEncoderAttachment extends AttachmentBase {
     const mappedValue = this.mapKeyWithModifiers(usbHidKeycode)
 
     // Ignore keys with no mapping (0x00 unless it's a valid control code like Ctrl+2 = NUL)
-    // Valid 0x00: Ctrl+2, Ctrl+@
+    // Valid 0x00: Ctrl+2
     if (mappedValue === 0x00 && !this.ctrlPressed) {
       return
     }

package/src/components/IO/Empty.ts

@@ -2,15 +2,12 @@ import { IO } from '../IO'
 
 export class Empty implements IO {
 
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
-
   read(address: number): number {
     return 0
   }
 
   write(address: number, data: number): void {}
-  tick(frequency: number): void {}
+  tick(frequency: number): number { return 0 }
   reset(coldStart: boolean): void {}
 
 }

package/src/components/IO/RAMBank.ts

@@ -20,40 +20,29 @@ export class RAMBank implements IO {
   data: number[] = [...Array(RAMBank.TOTAL_SIZE)].fill(0x00)
   currentBank: number = 0
 
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
-
   /**
-   * Read from RAM or bank control register
+   * Read from RAM - all addresses read from the data array
    */
   read(address: number): number {
-    // Reading from bank control register returns current bank number
-    if (address === RAMBank.BANK_CONTROL_REGISTER) {
-      return this.currentBank
-    }
-    
-    // Calculate actual address in RAM: bank * bank_size + offset and return data
     return this.data[this.currentBank * RAMBank.BANK_SIZE + address]
   }
 
   /**
    * Write to RAM or bank control register
+   * Writing to $3FF sets the bank AND writes through to the new bank's data
    */
   write(address: number, data: number): void {
-    // Writing to bank control register switches banks
     if (address === RAMBank.BANK_CONTROL_REGISTER) {
-      this.currentBank = data & 0xFF // Ensure 0-255 range
-      return
+      this.currentBank = data & 0xFF
     }
     
-    // Calculate actual address in RAM: bank * bank_size + offset and store data
     this.data[this.currentBank * RAMBank.BANK_SIZE + address] = data & 0xFF
   }
   
   /**
    * Tick - no timing behavior for RAM
    */
-  tick(frequency: number): void {}
+  tick(frequency: number): number { return 0 }
   
   /**
    * Reset the RAM card

package/src/components/IO/RTC.ts

@@ -26,8 +26,6 @@ import { IO } from '../IO'
  * 0x13: RAM Data (Extended RAM Data at address pointed to by 0x10)
  */
 export class RTC implements IO {
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
 
   // RTC Registers (user-visible)
   private userSeconds: number = 0        // 0x00
@@ -61,6 +59,7 @@ export class RTC implements IO {
   private watchdog2: number = 0      // 0x0D (0.1 Second and Second)
   private watchdogCounterCentis: number = 0
   private watchdogCycleCounter: number = 0
+  private nmiPending: boolean = false
 
   // Control registers
   private controlA: number = 0       // 0x0E
@@ -261,7 +260,6 @@ export class RTC implements IO {
     if ((this.controlA & flagMask) === 0) return
     if ((this.controlB & enableMask) === 0) return
     this.controlA |= 0x01 // Set IRQF flag (bit 0)
-    this.raiseIRQ()
   }
 
   private setKickstartFlag(): void {
@@ -304,7 +302,7 @@ export class RTC implements IO {
     } else {
       // WDS=1 steers watchdog to reset; emulate by clearing WDE
       this.controlB &= ~0x02
-      this.raiseNMI()
+      this.nmiPending = true
     }
   }
 
@@ -449,7 +447,7 @@ export class RTC implements IO {
 
 
 
-  tick(frequency: number, cycles: number = 1): void {
+  tick(frequency: number): number {
     this.cpuFrequency = frequency > 0 ? frequency : 1000000
 
     const teEnabled = (this.controlB & 0x80) !== 0
@@ -457,12 +455,17 @@ export class RTC implements IO {
     if ((this.monthControl & 0x80) !== 0) {
       // EOSC=1: oscillator disabled (DS1511Y+ active-low enable)
       this.stepWatchdog()
-      return
+      let status = (this.controlA & 0x01) ? 0x80 : 0
+      if (this.nmiPending) {
+        status |= 0x40
+        this.nmiPending = false
+      }
+      return status
     }
 
     // Advance the clock by counting CPU cycles.
     // One emulated second = cpuFrequency cycles.
-    this.cycleAccumulator += cycles
+    this.cycleAccumulator++
     while (this.cycleAccumulator >= this.cpuFrequency) {
       this.cycleAccumulator -= this.cpuFrequency
       this.incrementTime()
@@ -482,6 +485,14 @@ export class RTC implements IO {
     }
 
     this.stepWatchdog()
+
+    // Return interrupt status: bit 7 = IRQ, bit 6 = NMI
+    let status = (this.controlA & 0x01) ? 0x80 : 0
+    if (this.nmiPending) {
+      status |= 0x40
+      this.nmiPending = false
+    }
+    return status
   }
 
   reset(coldStart: boolean): void {

package/src/components/IO/Sound.ts

@@ -40,9 +40,6 @@ export const SID_CLOCK_PAL = 985248
 /** Number of SID registers */
 const NUM_REGISTERS = 29
 
-/** Cycles per tick from Machine.ts ioTickInterval */
-const CYCLES_PER_TICK = 128
-
 // Register offsets within each voice (relative to voice base)
 const REG_FREQ_LO = 0
 const REG_FREQ_HI = 1
@@ -162,9 +159,6 @@ export class SIDVoice {
 
 export class Sound implements IO {
 
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
-
   /** Callback to push audio samples to the host emulator */
   pushSamples?: (samples: Float32Array) => void
 
@@ -202,7 +196,7 @@ export class Sound implements IO {
   sidClock: number = SID_CLOCK_NTSC
 
   /** Internal sample buffer for pushing to host */
-  private sampleBuffer: Float32Array = new Float32Array(4096)
+  private sampleBuffer: Float32Array = new Float32Array(128)
   private sampleBufferIndex: number = 0
 
   // ================================================================
@@ -247,35 +241,28 @@ export class Sound implements IO {
     }
   }
 
-  tick(frequency: number): void {
+  tick(frequency: number): number {
     // SID clock runs at the CPU clock rate
     this.sidClock = frequency
 
-    // Each tick represents CYCLES_PER_TICK SID clock cycles
-    const cycles = CYCLES_PER_TICK
-
-    for (let c = 0; c < cycles; c++) {
-      this.clockOneCycle()
+    // Each tick represents 1 SID clock cycle
+    this.clockOneCycle()
 
-      // Sample rate conversion: accumulate and downsample
-      this.cycleAccumulator += this.sampleRate
-      if (this.cycleAccumulator >= this.sidClock) {
-        this.cycleAccumulator -= this.sidClock
+    // Sample rate conversion: accumulate and downsample
+    this.cycleAccumulator += this.sampleRate
+    if (this.cycleAccumulator >= this.sidClock) {
+      this.cycleAccumulator -= this.sidClock
 
-        const sample = this.generateSample()
-        this.sampleBuffer[this.sampleBufferIndex++] = sample
+      const sample = this.generateSample()
+      this.sampleBuffer[this.sampleBufferIndex++] = sample
 
-        // Buffer full - push to host
-        if (this.sampleBufferIndex >= this.sampleBuffer.length) {
-          this.flushSampleBuffer()
-        }
+      // Buffer full - push to host
+      if (this.sampleBufferIndex >= this.sampleBuffer.length) {
+        this.flushSampleBuffer()
       }
     }
 
-    // Flush remaining samples
-    if (this.sampleBufferIndex > 0) {
-      this.flushSampleBuffer()
-    }
+    return 0
   }
 
   reset(coldStart: boolean): void {

package/src/components/IO/Storage.ts

@@ -65,9 +65,6 @@ export class Storage implements IO {
   private isIdentifying: boolean = false
   private isTransferring: boolean = false
 
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
-
   constructor() {
     // Initialize storage and identity buffers
     this.storage = new Uint8Array(Storage.STORAGE_SIZE)
@@ -129,8 +126,8 @@ export class Storage implements IO {
     }
   }
 
-  tick(frequency: number): void {
-    // No timing behavior needed for this implementation
+  tick(frequency: number): number {
+    return 0
   }
 
   reset(coldStart: boolean): void {

package/src/components/IO/VIA.ts

@@ -78,9 +78,6 @@ export class VIA implements IO {
   private portA_attachmentCount: number = 0
   private portB_attachmentCount: number = 0
 
-  raiseIRQ = () => {}
-  raiseNMI = () => {}
-
   constructor() {
     this.reset(true)
   }
@@ -333,12 +330,12 @@ export class VIA implements IO {
     }
   }
 
-  tick(frequency: number, cycles: number = 1): void {
+  tick(frequency: number): number {
     this.tickCounter++
 
     // Update Timer 1
     if (this.T1_running && this.regT1C > 0) {
-      this.regT1C -= cycles
+      this.regT1C--
       if (this.regT1C <= 0) {
         this.setIRQFlag(VIA.IRQ_T1)
 
@@ -359,7 +356,7 @@ export class VIA implements IO {
 
     // Update Timer 2
     if (this.T2_running && this.regT2C > 0) {
-      this.regT2C -= cycles
+      this.regT2C--
       if (this.regT2C <= 0) {
         this.setIRQFlag(VIA.IRQ_T2)
         this.regT2C = 0
@@ -401,10 +398,11 @@ export class VIA implements IO {
       }
     }
 
-    // Raise IRQ if any enabled interrupt is active
+    // Return IRQ status if any enabled interrupt is active
     if (this.regIFR & this.regIER & 0x7F) {
-      this.raiseIRQ()
+      return 0x80
     }
+    return 0
   }
 
   private updateIRQ(): void {