ac6502 1.1.1 → 1.3.0

package/dist/components/CPU.d.ts

@@ -0,0 +1,162 @@
+export interface CPUInstruction {
+    name: string;
+    cycles: number;
+    opcode: () => number;
+    addrMode: () => number;
+}
+export declare class CPU {
+    static C: number;
+    static Z: number;
+    static I: number;
+    static D: number;
+    static B: number;
+    static U: number;
+    static V: number;
+    static N: number;
+    private fetched;
+    private temp;
+    private addrAbs;
+    private addrRel;
+    private opcode;
+    cyclesRem: number;
+    cycles: number;
+    a: number;
+    x: number;
+    y: number;
+    pc: number;
+    sp: number;
+    st: number;
+    read: (address: number) => number;
+    write: (address: number, data: number) => void;
+    constructor(read: (address: number) => number, write: (address: number, data: number) => void);
+    reset(): void;
+    irq(): void;
+    nmi(): void;
+    tick(): void;
+    step(): number;
+    private fetch;
+    private getFlag;
+    private setFlag;
+    private incPC;
+    private decPC;
+    private incSP;
+    private decSP;
+    private IMP;
+    private IMM;
+    private ZP0;
+    private ZPX;
+    private ZPY;
+    private REL;
+    private ABS;
+    private ABX;
+    private ABY;
+    private IND;
+    private IZX;
+    private IZY;
+    private IAX;
+    private ZPR;
+    private ADC;
+    private AND;
+    private ASL;
+    private BCC;
+    private BCS;
+    private BEQ;
+    private BIT;
+    private BMI;
+    private BNE;
+    private BPL;
+    private BRK;
+    private BVC;
+    private BVS;
+    private CLC;
+    private CLD;
+    private CLI;
+    private CLV;
+    private CMP;
+    private CPX;
+    private CPY;
+    private DEC;
+    private DEX;
+    private DEY;
+    private EOR;
+    private INC;
+    private INX;
+    private INY;
+    private JMP;
+    private JSR;
+    private LDA;
+    private LDX;
+    private LDY;
+    private LSR;
+    private NOP;
+    private ORA;
+    private PHA;
+    private PHP;
+    private PLA;
+    private PLP;
+    private ROL;
+    private ROR;
+    private RTI;
+    private RTS;
+    private SBC;
+    private SEC;
+    private SED;
+    private SEI;
+    private STA;
+    private STX;
+    private STY;
+    private TAX;
+    private TAY;
+    private TSX;
+    private TXA;
+    private TXS;
+    private TYA;
+    private BRA;
+    private PHX;
+    private PHY;
+    private PLX;
+    private PLY;
+    private STZ;
+    private TRB;
+    private TSB;
+    private STP;
+    private WAI;
+    private BBR;
+    private BBR0;
+    private BBR1;
+    private BBR2;
+    private BBR3;
+    private BBR4;
+    private BBR5;
+    private BBR6;
+    private BBR7;
+    private BBS;
+    private BBS0;
+    private BBS1;
+    private BBS2;
+    private BBS3;
+    private BBS4;
+    private BBS5;
+    private BBS6;
+    private BBS7;
+    private RMB;
+    private RMB0;
+    private RMB1;
+    private RMB2;
+    private RMB3;
+    private RMB4;
+    private RMB5;
+    private RMB6;
+    private RMB7;
+    private SMB;
+    private SMB0;
+    private SMB1;
+    private SMB2;
+    private SMB3;
+    private SMB4;
+    private SMB5;
+    private SMB6;
+    private SMB7;
+    private XXX;
+    instructionTable: CPUInstruction[];
+}

package/dist/components/Cart.d.ts

@@ -0,0 +1,9 @@
+export declare class Cart {
+    static START: number;
+    static END: number;
+    static CODE: number;
+    static SIZE: number;
+    data: number[];
+    read(address: number): number;
+    load(data: number[]): void;
+}

package/dist/components/IO/DevOutputBoard.d.ts

@@ -0,0 +1,19 @@
+import { IO } from '../IO';
+import { VTAC } from 'vtac-terminal';
+/**
+ * DevOutputBoard - Development output board using a VTAC terminal controller
+ *
+ * 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 declare class DevOutputBoard implements IO {
+    raiseIRQ: () => void;
+    raiseNMI: () => void;
+    readonly vtac: VTAC;
+    read(address: number): number;
+    write(address: number, data: number): void;
+    tick(frequency: number): void;
+    reset(coldStart: boolean): void;
+}

package/dist/components/IO/DevOutputBoard.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevOutputBoard = void 0;
+const vtac_terminal_1 = require("vtac-terminal");
+/**
+ * DevOutputBoard - Development output board using a VTAC terminal controller
+ *
+ * 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)
+ */
+class DevOutputBoard {
+    constructor() {
+        this.raiseIRQ = () => { };
+        this.raiseNMI = () => { };
+        this.vtac = new vtac_terminal_1.VTAC();
+    }
+    read(address) {
+        // Status register: bit 7 is busy flag on real device, never busy in emulation
+        return 0;
+    }
+    write(address, data) {
+        const register = address & 0x00;
+        if (register === 0x00) {
+            this.vtac.parse(data);
+        }
+    }
+    tick(frequency) { }
+    reset(coldStart) { }
+}
+exports.DevOutputBoard = DevOutputBoard;
+//# sourceMappingURL=DevOutputBoard.js.map

package/dist/components/IO/DevOutputBoard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DevOutputBoard.js","sourceRoot":"","sources":["../../../src/components/IO/DevOutputBoard.ts"],"names":[],"mappings":";;;AACA,iDAAoC;AAEpC;;;;;;;GAOG;AACH,MAAa,cAAc;IAA3B;QAEE,aAAQ,GAAG,GAAG,EAAE,GAAE,CAAC,CAAA;QACnB,aAAQ,GAAG,GAAG,EAAE,GAAE,CAAC,CAAA;QAEV,SAAI,GAAS,IAAI,oBAAI,EAAE,CAAA;IAiBlC,CAAC;IAfC,IAAI,CAAC,OAAe;QAClB,8EAA8E;QAC9E,OAAO,CAAC,CAAA;IACV,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,IAAY;QACjC,MAAM,QAAQ,GAAG,OAAO,GAAG,IAAI,CAAA;QAC/B,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACvB,CAAC;IACH,CAAC;IAED,IAAI,CAAC,SAAiB,IAAS,CAAC;IAChC,KAAK,CAAC,SAAkB,IAAS,CAAC;CAEnC;AAtBD,wCAsBC"}

package/dist/components/IO/EmptyCard.d.ts

@@ -0,0 +1,9 @@
+import { IO } from '../IO';
+export declare class EmptyCard implements IO {
+    raiseIRQ: () => void;
+    raiseNMI: () => void;
+    read(address: number): number;
+    write(address: number, data: number): void;
+    tick(frequency: number): void;
+    reset(coldStart: boolean): void;
+}

package/dist/components/IO/GPIOAttachments/GPIOAttachment.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Interface for devices that can be attached to GPIO ports
+ */
+export interface GPIOAttachment {
+    /**
+     * Reset the attachment to its initial state
+     */
+    reset(): void;
+    /**
+     * Update the attachment state based on CPU clock ticks
+     * @param cpuFrequency - The CPU frequency in Hz
+     */
+    tick(cpuFrequency: number): void;
+    /**
+     * Read data from Port A
+     * @param ddr - Data Direction Register value
+     * @param or - Output Register value
+     * @returns The data to be read from the port
+     */
+    readPortA(ddr: number, or: number): number;
+    /**
+     * Read data from Port B
+     * @param ddr - Data Direction Register value
+     * @param or - Output Register value
+     * @returns The data to be read from the port
+     */
+    readPortB(ddr: number, or: number): number;
+    /**
+     * Write data to Port A
+     * @param value - The value being written
+     * @param ddr - Data Direction Register value
+     */
+    writePortA(value: number, ddr: number): void;
+    /**
+     * Write data to Port B
+     * @param value - The value being written
+     * @param ddr - Data Direction Register value
+     */
+    writePortB(value: number, ddr: number): void;
+    /**
+     * Check if the attachment is enabled
+     * @returns true if enabled, false otherwise
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the priority of this attachment (lower values = higher priority)
+     * @returns The priority value
+     */
+    getPriority(): number;
+    /**
+     * Clear interrupt flags
+     * @param ca1 - Clear CA1 interrupt
+     * @param ca2 - Clear CA2 interrupt
+     * @param cb1 - Clear CB1 interrupt
+     * @param cb2 - Clear CB2 interrupt
+     */
+    clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    /**
+     * Update control line states
+     * @param ca1 - CA1 control line state
+     * @param ca2 - CA2 control line state
+     * @param cb1 - CB1 control line state
+     * @param cb2 - CB2 control line state
+     */
+    updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    /**
+     * Check if CA1 interrupt is pending
+     * @returns true if interrupt is pending
+     */
+    hasCA1Interrupt(): boolean;
+    /**
+     * Check if CA2 interrupt is pending
+     * @returns true if interrupt is pending
+     */
+    hasCA2Interrupt(): boolean;
+    /**
+     * Check if CB1 interrupt is pending
+     * @returns true if interrupt is pending
+     */
+    hasCB1Interrupt(): boolean;
+    /**
+     * Check if CB2 interrupt is pending
+     * @returns true if interrupt is pending
+     */
+    hasCB2Interrupt(): boolean;
+}
+/**
+ * Base abstract class for GPIO attachments with common functionality
+ */
+export declare abstract class GPIOAttachmentBase implements GPIOAttachment {
+    protected priority: number;
+    protected enabled: boolean;
+    protected ca1Interrupt: boolean;
+    protected ca2Interrupt: boolean;
+    protected cb1Interrupt: boolean;
+    protected cb2Interrupt: boolean;
+    constructor(priority: number, ca1Interrupt?: boolean, ca2Interrupt?: boolean, cb1Interrupt?: boolean, cb2Interrupt?: boolean);
+    reset(): void;
+    tick(cpuFrequency: number): void;
+    readPortA(ddr: number, or: number): number;
+    readPortB(ddr: number, or: number): number;
+    writePortA(value: number, ddr: number): void;
+    writePortB(value: number, ddr: number): void;
+    isEnabled(): boolean;
+    getPriority(): number;
+    clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    hasCA1Interrupt(): boolean;
+    hasCA2Interrupt(): boolean;
+    hasCB1Interrupt(): boolean;
+    hasCB2Interrupt(): boolean;
+}

package/dist/components/IO/GPIOAttachments/GPIOJoystickAttachment.d.ts

@@ -0,0 +1,53 @@
+import { GPIOAttachmentBase } from './GPIOAttachment';
+/**
+ * GPIOJoystickAttachment - Emulates a joystick/gamepad connected to GPIO port
+ *
+ * Buttons are active-low (0 = pressed, 1 = released)
+ * Can be attached to either Port A or Port B
+ */
+export declare class GPIOJoystickAttachment extends GPIOAttachmentBase {
+    static readonly BUTTON_UP = 1;
+    static readonly BUTTON_DOWN = 2;
+    static readonly BUTTON_LEFT = 4;
+    static readonly BUTTON_RIGHT = 8;
+    static readonly BUTTON_A = 16;
+    static readonly BUTTON_B = 32;
+    static readonly BUTTON_SELECT = 64;
+    static readonly BUTTON_START = 128;
+    private buttonState;
+    private attachedToPortA;
+    constructor(attachToPortA?: boolean, priority?: number);
+    reset(): void;
+    readPortA(ddr: number, or: number): number;
+    readPortB(ddr: number, or: number): number;
+    /**
+     * Update the joystick button state
+     * @param buttons - Button state byte (1 = pressed, 0 = released)
+     */
+    updateJoystick(buttons: number): void;
+    /**
+     * Get the current button state
+     * @returns The button state byte
+     */
+    getButtonState(): number;
+    /**
+     * Check if a specific button is pressed
+     * @param button - Button bit mask to check
+     * @returns true if button is pressed
+     */
+    isButtonPressed(button: number): boolean;
+    /**
+     * Press a button (set its bit)
+     * @param button - Button bit mask to press
+     */
+    pressButton(button: number): void;
+    /**
+     * Release a button (clear its bit)
+     * @param button - Button bit mask to release
+     */
+    releaseButton(button: number): void;
+    /**
+     * Clear all button presses
+     */
+    releaseAllButtons(): void;
+}

package/dist/components/IO/GPIOAttachments/GPIOKeyboardEncoderAttachment.d.ts

@@ -0,0 +1,63 @@
+import { GPIOAttachmentBase } from './GPIOAttachment';
+/**
+ * GPIOKeyboardEncoderAttachment - 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
+ */
+export declare class GPIOKeyboardEncoderAttachment extends GPIOAttachmentBase {
+    private asciiDataA;
+    private dataReadyA;
+    private interruptPendingA;
+    private enabledA;
+    private asciiDataB;
+    private dataReadyB;
+    private interruptPendingB;
+    private enabledB;
+    private shiftPressed;
+    private ctrlPressed;
+    private altPressed;
+    private menuPressed;
+    private stateCA1;
+    private stateCA2;
+    private stateCB1;
+    private stateCB2;
+    constructor(priority?: number);
+    reset(): void;
+    readPortA(ddrA: number, orA: number): number;
+    readPortB(ddrB: number, orB: number): number;
+    updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    hasCA1Interrupt(): boolean;
+    hasCB1Interrupt(): boolean;
+    clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    /**
+     * Map a USB HID keycode to ASCII with modifier keys applied
+     */
+    private mapKeyWithModifiers;
+    /**
+     * Update the keyboard state based on a USB HID key press or release
+     * @param usbHidKeycode USB HID keycode
+     * @param pressed true for key press, false for key release
+     */
+    updateKey(usbHidKeycode: number, pressed: boolean): void;
+    /**
+     * Check if Port A has data ready
+     */
+    hasDataReadyA(): boolean;
+    /**
+     * Check if Port B has data ready
+     */
+    hasDataReadyB(): boolean;
+}

package/dist/components/IO/GPIOAttachments/GPIOKeyboardMatrixAttachment.d.ts

@@ -0,0 +1,44 @@
+import { GPIOAttachmentBase } from './GPIOAttachment';
+/**
+ * GPIOKeyboardMatrixAttachment - Emulates a keyboard matrix connected to GPIO ports
+ *
+ * The keyboard matrix uses:
+ * - Port A (PA0-PA7): Rows (8 rows)
+ * - Port B (PB0-PB7): Columns (8 columns)
+ *
+ * Keys are active-low: when a key is pressed, the corresponding row/column intersection
+ * pulls the row line low when the column is selected (low).
+ */
+export declare class GPIOKeyboardMatrixAttachment extends GPIOAttachmentBase {
+    private static readonly KEYBOARD_LAYOUT;
+    private keyboardMatrix;
+    private selectedColumns;
+    constructor(priority?: number);
+    reset(): void;
+    readPortA(ddr: number, or: number): number;
+    readPortB(ddr: number, or: number): number;
+    writePortB(value: number, ddr: number): void;
+    /**
+     * Update a key state based on USB HID keycode
+     * @param usbHidKeycode - USB HID usage ID for the key
+     * @param pressed - true if key is pressed, false if released
+     */
+    updateKey(usbHidKeycode: number, pressed: boolean): void;
+    /**
+     * Update a specific matrix position directly
+     * @param row - Row index (0-7)
+     * @param col - Column index (0-7)
+     * @param pressed - true if key is pressed, false if released
+     */
+    updateMatrixPosition(row: number, col: number, pressed: boolean): void;
+    /**
+     * Get the current state of the keyboard matrix
+     * @returns Array of 8 bytes representing the matrix state
+     */
+    getMatrixState(): number[];
+    /**
+     * Get the currently selected columns
+     * @returns Byte representing selected columns
+     */
+    getSelectedColumns(): number;
+}

package/dist/components/IO/GPIOAttachments/GPIOKeypadAttachment.d.ts

@@ -0,0 +1,47 @@
+import { GPIOAttachmentBase } from './GPIOAttachment';
+/**
+ * GPIOKeypadAttachment - Emulates a 4×6 matrix keypad with a built-in hardware encoder
+ *
+ * The encoder converts a key press into a 5-bit code (PA0–PA4) that appears on the GPIO
+ * port.  Bits 5–7 are never driven by the keypad and always read as 0 when data is present.
+ *
+ * Behaviour mirrors a typical 74C922-style encoder:
+ * - On key press  → the 5-bit keypad code is latched and a CA1/CB1 interrupt is asserted
+ * - On port read  → the latched code is returned on bits 0–4 (bits 5–7 = 0)
+ * - clearInterrupts → clears the interrupt and the data-ready latch
+ * - Key releases  → ignored (encoder only reports on the falling edge of a keypress)
+ *
+ * The attachment may be wired to either Port A or Port B via the constructor parameter.
+ * CA1/CB1 is the DA (Data Available) interrupt line from the 74C922.
+ * CA2/CB2 is connected to the 74C922 OE (Output Enable) pin; data is only driven onto the
+ * bus when OE is asserted LOW by the 6522.
+ */
+export declare class GPIOKeypadAttachment extends GPIOAttachmentBase {
+    private keypadValue;
+    private dataReady;
+    private interruptPending;
+    private readonly attachedToPortA;
+    private oeState;
+    constructor(attachToPortA?: boolean, priority?: number);
+    reset(): void;
+    updateControlLines(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    readPortA(ddr: number, or: number): number;
+    readPortB(ddr: number, or: number): number;
+    hasCA1Interrupt(): boolean;
+    hasCB1Interrupt(): boolean;
+    clearInterrupts(ca1: boolean, ca2: boolean, cb1: boolean, cb2: boolean): void;
+    /**
+     * Notify the attachment of a USB HID key event.
+     * Key releases are ignored; only presses generate output on the GPIO port.
+     *
+     * @param usbHidKeycode - USB HID usage ID for the key
+     * @param pressed       - true for key-down, false for key-up
+     */
+    updateKey(usbHidKeycode: number, pressed: boolean): void;
+    /**
+     * Returns the current latched keypad code (bits 0–4) or 0xFF if no data is ready.
+     */
+    getCurrentKey(): number;
+    /** Returns true when a key has been pressed and the latch has not yet been cleared. */
+    hasDataReady(): boolean;
+}

package/dist/components/IO/GPIOAttachments/GPIOLCDAttachment.d.ts

@@ -0,0 +1,110 @@
+import { GPIOAttachmentBase } from './GPIOAttachment';
+/**
+ * HD44780 LCD Controller Emulation — GPIO Attachment
+ *
+ * Emulates a 16×2 (or configurable) character LCD with HD44780 controller
+ * connected via 8-bit parallel interface on a 65C22 VIA.
+ *
+ * Pin mapping (accent on VIA ports):
+ *   Port B (D0–D7): 8-bit data bus
+ *   Port A bit 5:   RS  (Register Select — 0 = command, 1 = data)
+ *   Port A bit 6:   RW  (Read/Write — 0 = write, 1 = read)
+ *   Port A bit 7:   E   (Enable — active-high strobe, latched on falling edge)
+ *
+ * Display modes:
+ *   Standard character display with 5×8 pixel characters
+ *   Supports CGRAM for up to 8 user-defined characters
+ *
+ * Output: pixel buffer (cols*(5+1)-1) × (rows*(8+1)-1) with values:
+ *   -1 = no pixel (inter-character gap)
+ *    0 = pixel off
+ *    1 = pixel on
+ *
+ * Reference: vrEmuLcd by Troy Schrapel
+ * https://github.com/visrealm/vrEmuLcd
+ */
+export declare const LCD_CMD_CLEAR = 1;
+export declare const LCD_CMD_HOME = 2;
+export declare const LCD_CMD_ENTRY_MODE = 4;
+export declare const LCD_CMD_ENTRY_MODE_INCREMENT = 2;
+export declare const LCD_CMD_ENTRY_MODE_SHIFT = 1;
+export declare const LCD_CMD_DISPLAY = 8;
+export declare const LCD_CMD_DISPLAY_ON = 4;
+export declare const LCD_CMD_DISPLAY_CURSOR = 2;
+export declare const LCD_CMD_DISPLAY_CURSOR_BLINK = 1;
+export declare const LCD_CMD_SHIFT = 16;
+export declare const LCD_CMD_SHIFT_DISPLAY = 8;
+export declare const LCD_CMD_SHIFT_RIGHT = 4;
+export declare const LCD_CMD_FUNCTION = 32;
+export declare const LCD_CMD_FUNCTION_LCD_2LINE = 8;
+export declare const LCD_CMD_SET_CGRAM_ADDR = 64;
+export declare const LCD_CMD_SET_DRAM_ADDR = 128;
+export declare class GPIOLCDAttachment extends GPIOAttachmentBase {
+    readonly cols: number;
+    readonly rows: number;
+    private entryModeFlags;
+    private displayFlags;
+    private scrollOffset;
+    /** 128-byte Display Data RAM */
+    private ddRam;
+    /** Current DDRAM pointer offset */
+    private ddPtr;
+    private dataWidthCols;
+    /** Character Generator RAM — 16 characters × 8 rows, stored column-major
+     *  as 16 × CHAR_WIDTH_PX bytes (matching vrEmuLcd cgRam layout) */
+    private cgRam;
+    /** Current CGRAM pointer (null when not in CGRAM mode) */
+    private cgPtr;
+    /** Pixel buffer: each byte is -1 (gap), 0 (off) or 1 (on) */
+    buffer: Int8Array;
+    readonly pixelsWidth: number;
+    readonly pixelsHeight: number;
+    private blinkAccumulator;
+    private blinkState;
+    private static readonly BLINK_PERIOD_MS;
+    private lastPortA;
+    private lastE;
+    constructor(cols?: number, rows?: number, priority?: number);
+    reset(): void;
+    tick(cpuFrequency: number): void;
+    /**
+     * Port A carries the control signals.
+     * We detect E falling edge to latch the bus.
+     */
+    writePortA(value: number, ddr: number): void;
+    readPortA(ddr: number, or: number): number;
+    readPortB(ddr: number, or: number): number;
+    private latchBus;
+    private lastPortBValue;
+    writePortB(value: number, ddr: number): void;
+    sendCommand(command: number): void;
+    writeByte(data: number): void;
+    private readByte;
+    readAddress(): number;
+    private incrementDdPtr;
+    private decrementDdPtr;
+    private doShift;
+    /**
+     * Get the 5-column font data for a character.
+     * Characters 0–15 come from CGRAM; 16–255 from ROM.
+     */
+    private charBits;
+    private getDataOffset;
+    updatePixels(): void;
+    /** Get the raw DDRAM contents */
+    getDDRam(): Uint8Array;
+    /** Get the current DDRAM address pointer */
+    getDDPtr(): number;
+    /** Get the display flags */
+    getDisplayFlags(): number;
+    /** Get the entry mode flags */
+    getEntryModeFlags(): number;
+    /** Get scroll offset */
+    getScrollOffset(): number;
+    /** Get CGRAM pointer (null if not in CGRAM mode) */
+    getCGPtr(): number | null;
+    /** Read the text content of a specific display row */
+    getRowText(row: number): string;
+    /** Pixel state at a given coordinate: -1 (gap), 0 (off), 1 (on) */
+    pixelState(x: number, y: number): number;
+}