@slurrps/chippy 0.1.0

package/dist/audio/audio.d.ts

@@ -0,0 +1,27 @@
+export declare class Audio {
+    private audioContext;
+    private masterGain;
+    private oscillator;
+    private wave;
+    private volumeLevel;
+    private soundEnabled;
+    constructor();
+    /** Initialize audio context and gain node */
+    private initAudio;
+    /** Ensure AudioContext is running */
+    private ensureAudioContext;
+    /** Enable sound playback */
+    enableSound(): Promise<void>;
+    /** Disable sound playback */
+    disableSound(): void;
+    /** Mute audio */
+    mute(): void;
+    /** Unmute audio and set volume */
+    unMute(value?: number): void;
+    /** Play sound if timer > 0 */
+    playSound(timerValue: number): Promise<void>;
+    /** Set oscillator wave type */
+    setWave(type: OscillatorType): void;
+    /** Set master volume */
+    setVolume(value: number): void;
+}

package/dist/chip8.d.ts

@@ -0,0 +1,25 @@
+import { CPU } from "@/cpu/cpu";
+import { Display } from "@/display/display";
+import { Audio } from "@/audio/audio";
+import { Keyboard } from "@/input/keyboard";
+export declare class Chip8 {
+    cpu: CPU;
+    display: Display;
+    keyboard: Keyboard;
+    speaker: Audio;
+    private ctx;
+    private frameFinishedCallback?;
+    private fps;
+    private maxFps;
+    private interval;
+    private previousTime;
+    constructor();
+    /** Starts the main emulator loop */
+    run(): void;
+    /** Load a ROM into memory */
+    loadRom(romBuffer: Uint8Array): void;
+    /** Set a callback to receive rendered frame and CPU state */
+    onFrameFinished(callback: Function): void;
+    /** Main frame loop, synced to browser's requestAnimationFrame */
+    private runFrame;
+}

package/dist/chip8.js

@@ -0,0 +1 @@
+const e=4096,s=512;class t{V=new Uint8Array(16);I=0;stack=new Uint16Array(16);SP=-1;PC=s;DT=0;ST=0;paused=!1;constructor(){this.reset()}reset(){this.V.fill(0),this.I=0,this.stack.fill(0),this.SP=-1,this.PC=s,this.DT=0,this.ST=0,this.paused=!1}nextInstruction(){this.PC+=2,console.log(`[PC] nextInstruction: PC=0x${this.PC.toString(16)}`)}stackPush(e){if(this.SP>=15)throw new Error("Stack Overflow: Attempted to push beyond stack depth.");this.SP++,this.stack[this.SP]=e,console.log(`[STACK] PUSH: SP=${this.SP}, value=0x${e.toString(16)}`)}stackPop(){if(this.SP<0)throw new Error("Stack Underflow: Attempted to pop from an empty stack.");const e=this.stack[this.SP];return this.SP--,console.log(`[STACK] POP: SP=${this.SP}, value=0x${e.toString(16)}`),e}updateTimers(){return this.DT>0&&this.DT--,this.ST>0&&(this.ST--,0===this.ST)}}const r={mask:4095},i={mask:15},a={mask:3840,shift:8},n={mask:240,shift:4},o={mask:255},h=61440,m=61455,d=[{key:2,id:"CLS",name:"CLS",mask:65535,pattern:224,arguments:[]},{key:3,id:"RET",name:"RET",mask:65535,pattern:238,arguments:[]},{key:4,id:"JP_ADDR",name:"JP",mask:h,pattern:4096,arguments:[r]},{key:5,id:"CALL_ADDR",name:"CALL",mask:h,pattern:8192,arguments:[r]},{key:6,id:"SE_VX_KK",name:"SE",mask:h,pattern:12288,arguments:[a,o]},{key:7,id:"SNE_VX_KK",name:"SNE",mask:h,pattern:16384,arguments:[a,o]},{key:8,id:"SE_VX_VY",name:"SE",mask:m,pattern:20480,arguments:[a,n]},{key:9,id:"LD_VX_KK",name:"LD",mask:h,pattern:24576,arguments:[a,o]},{key:10,id:"ADD_VX_KK",name:"ADD",mask:h,pattern:28672,arguments:[a,o]},{key:11,id:"LD_VX_VY",name:"LD",mask:m,pattern:32768,arguments:[a,n]},{key:12,id:"OR_VX_VY",name:"OR",mask:m,pattern:32769,arguments:[a,n]},{key:13,id:"AND_VX_VY",name:"AND",mask:m,pattern:32770,arguments:[a,n]},{key:14,id:"XOR_VX_VY",name:"XOR",mask:m,pattern:32771,arguments:[a,n]},{key:15,id:"ADD_VX_VY",name:"ADD",mask:m,pattern:32772,arguments:[a,n]},{key:16,id:"SUB_VX_VY",name:"SUB",mask:m,pattern:32773,arguments:[a,n]},{key:17,id:"SHR_VX_VY",name:"SHR",mask:m,pattern:32774,arguments:[a,n]},{key:18,id:"SUBN_VX_VY",name:"SUBN",mask:m,pattern:32775,arguments:[a,n]},{key:19,id:"SHL_VX_VY",name:"SHL",mask:m,pattern:32782,arguments:[a,n]},{key:20,id:"SNE_VX_VY",name:"SNE",mask:m,pattern:36864,arguments:[a,n]},{key:21,id:"LD_I_ADDR",name:"LD",mask:h,pattern:40960,arguments:[r]},{key:22,id:"JP_V0_ADDR",name:"JP",mask:h,pattern:45056,arguments:[r]},{key:23,id:"RND_VX_KK",name:"RND",mask:h,pattern:49152,arguments:[a,o]},{key:24,id:"DRW_VX_VY_N",name:"DRW",mask:h,pattern:53248,arguments:[a,n,i]},{key:25,id:"SKP_VX",name:"SKP",mask:61695,pattern:57502,arguments:[a]},{key:26,id:"SKNP_VX",name:"SKNP",mask:61695,pattern:57505,arguments:[a]},{key:27,id:"LD_VX_DT",name:"LD",mask:61695,pattern:61447,arguments:[a]},{key:28,id:"LD_VX_K",name:"LD",mask:61695,pattern:61450,arguments:[a]},{key:29,id:"LD_DT_VX",name:"LD",mask:61695,pattern:61461,arguments:[a]},{key:30,id:"LD_ST_VX",name:"LD",mask:61695,pattern:61464,arguments:[a]},{key:31,id:"ADD_I_VX",name:"ADD",mask:61695,pattern:61470,arguments:[a]},{key:32,id:"LD_F_VX",name:"LD",mask:61695,pattern:61481,arguments:[a]},{key:33,id:"LD_B_VX",name:"LD",mask:61695,pattern:61491,arguments:[a]},{key:34,id:"LD_I_VX",name:"LD",mask:61695,pattern:61525,arguments:[a]},{key:35,id:"LD_VX_I",name:"LD",mask:61695,pattern:61541,arguments:[a]},{key:36,id:"SCD nibble",name:"SCD",mask:i,pattern:192,arguments:[]}];class u{disassemble(e){try{const s=d.find(s=>(e&Number(s.mask))===s.pattern);if(!s)return console.error(`Opcode not found: 0x${e.toString(16)}`),{instruction:null,args:[]};const t=s.arguments.map(s=>{const t=s.shift??0;return(e&Number(s.mask))>>t});return{instruction:s,args:t}}catch(s){return console.error(`Error disassembling opcode: 0x${e.toString(16)}`,s),{instruction:null,args:[]}}}}const g={CLS(e){e.drawSprite(0,0,new Uint8Array)},RET(e){e.registers.PC=e.registers.stackPop()},JP_ADDR(e,[s]){e.registers.PC=s},CALL_ADDR(e,[s]){e.registers.stackPush(e.registers.PC),e.registers.PC=s},SE_VX_KK(e,[s,t]){e.registers.V[s]===t&&e.registers.nextInstruction()},SNE_VX_KK(e,[s,t]){e.registers.V[s]!==t&&e.registers.nextInstruction()},SE_VX_VY(e,[s,t]){e.registers.V[s]===e.registers.V[t]&&e.registers.nextInstruction()},LD_VX_KK(e,[s,t]){e.registers.V[s]=t},ADD_VX_KK(e,[s,t]){e.registers.V[s]+=t},LD_VX_VY(e,[s,t]){e.registers.V[s]=e.registers.V[t]},OR_VX_VY(e,[s,t]){e.registers.V[s]|=e.registers.V[t]},AND_VX_VY(e,[s,t]){e.registers.V[s]&=e.registers.V[t]},XOR_VX_VY(e,[s,t]){e.registers.V[s]^=e.registers.V[t]},ADD_VX_VY(e,[s,t]){const r=e.registers.V[s]+e.registers.V[t];e.registers.V[15]=r>255?1:0,e.registers.V[s]=255&r},SUB_VX_VY(e,[s,t]){e.registers.V[15]=e.registers.V[s]>=e.registers.V[t]?1:0,e.registers.V[s]=e.registers.V[s]-e.registers.V[t]&255},SHR_VX_VY(e,[s]){e.registers.V[15]=1&e.registers.V[s],e.registers.V[s]>>=1},SUBN_VX_VY(e,[s,t]){e.registers.V[15]=e.registers.V[t]>=e.registers.V[s]?1:0,e.registers.V[s]=e.registers.V[t]-e.registers.V[s]&255},SHL_VX_VY(e,[s]){e.registers.V[15]=(128&e.registers.V[s])>>7,e.registers.V[s]<<=1,e.registers.V[s]&=255},SNE_VX_VY(e,[s,t]){e.registers.V[s]!==e.registers.V[t]&&e.registers.nextInstruction()},LD_I_ADDR(e,[s]){e.registers.I=s},JP_V0_ADDR(e,[s]){e.registers.PC=s+e.registers.V[0]},RND_VX_KK(e,[s],t){const r=Math.floor(255*Math.random());e.registers.V[s]=255&r&t},DRW_VX_VY_N(e,[s,t],r){const i=15&r,a=e.memory.slice(e.registers.I,e.registers.I+i),n=e.drawSprite(e.registers.V[s],e.registers.V[t],a);e.registers.V[15]=n?1:0},SKP_VX(e,[s]){e.isKeyPressed(e.registers.V[s])&&e.registers.nextInstruction()},SKNP_VX(e,[s]){e.isKeyPressed(e.registers.V[s])||e.registers.nextInstruction()},LD_VX_DT(e,[s]){e.registers.V[s]=e.registers.DT},LD_VX_K(e,[s]){e.registers.paused=!0,e.waitForKeyPress(t=>{e.registers.V[s]=t,e.registers.paused=!1})},LD_DT_VX(e,[s]){e.registers.DT=e.registers.V[s]},LD_ST_VX(e,[s]){e.registers.ST=e.registers.V[s]},ADD_I_VX(e,[s]){e.registers.I+=e.registers.V[s]},LD_F_VX(e,[s]){e.registers.I=5*e.registers.V[s]},LD_B_VX(e,[s]){const t=e.registers.V[s];e.memory.write(e.registers.I,Math.floor(t/100)),e.memory.write(e.registers.I+1,Math.floor(t%100/10)),e.memory.write(e.registers.I+2,t%10)},LD_I_VX(e,[s]){for(let t=0;t<=s;t++)e.memory.write(e.registers.I+t,e.registers.V[t])},LD_VX_I(e,[s]){for(let t=0;t<=s;t++)e.registers.V[t]=e.memory.read(e.registers.I+t)}};class l{registers=new t;disassembler=new u;tick(e){if(this.registers.paused)return 0;const s=e.memory.readOpcode(this.registers.PC);this.registers.nextInstruction();const{instruction:t,args:r}=this.disassembler.disassemble(s);if(!t)return console.error(`Invalid opcode 0x${s.toString(16)}`),0;const i=g[t.id];return i?(i(e,r,s),e.decrementTimers(),1):(console.error(`Unimplemented instruction: ${t.id}`),0)}reset(){this.registers.reset()}}const c=[240,144,144,144,240,32,96,32,32,112,240,16,240,128,240,240,16,240,16,240,144,144,240,16,16,240,128,240,16,240,240,128,240,144,240,240,16,32,64,64,240,144,240,144,240,240,144,240,16,240,240,144,240,144,144,224,144,224,144,224,240,128,128,128,240,224,144,144,144,224,240,128,240,128,240,240,128,240,128,128];class V extends ImageData{setPixel(e,s,t,r,i,a=255){if(e<0||e>=this.width||s<0||s>=this.height)return;const n=s*this.width*4+4*e;this.data[n]=t,this.data[n+1]=r,this.data[n+2]=i,this.data[n+3]=a}}class _{width=64;height=32;scale;scaledWidth;scaledHeight;frameBuffer;foregroundColor=[255,255,255];backgroundColor=[0,0,0];constructor(e=1){this.scale=e,this.scaledWidth=this.width*this.scale,this.scaledHeight=this.height*this.scale,this.frameBuffer=new V(this.scaledWidth,this.scaledHeight),this.clear()}setForegroundColor(e){this.foregroundColor=this.parseColor(e)}setBackgroundColor(e){this.backgroundColor=this.parseColor(e)}clear(){for(let e=0;e<this.scaledHeight;e++)for(let s=0;s<this.scaledWidth;s++)this.frameBuffer.setPixel(s,e,this.backgroundColor[0],this.backgroundColor[1],this.backgroundColor[2],255)}drawSprite(e,s,t){let r=!1;for(let i=0;i<t.length;i++){let a=t[i];for(let t=0;t<8;t++){if((128&a)>0){const a=(e+t)%this.width,n=(s+i)%this.height;let o=!1;for(let e=0;e<this.scale;e++)for(let s=0;s<this.scale;s++){const t=a*this.scale+s,r=4*((n*this.scale+e)*this.scaledWidth+t),i=this.frameBuffer.data[r]>0?1:0,h=1^i;this.frameBuffer.data[r]=h*this.foregroundColor[0],this.frameBuffer.data[r+1]=h*this.foregroundColor[1],this.frameBuffer.data[r+2]=h*this.foregroundColor[2],this.frameBuffer.data[r+3]=255,1===i&&0===h&&(o=!0)}o&&(r=!0)}a<<=1}}return r}parseColor(e){if("string"==typeof e){3===(e=e.replace(/^#/,"")).length&&(e=e.split("").map(e=>e+e).join(""));const s=parseInt(e,16);return[s>>16&255,s>>8&255,255&s]}return e}}const k=new class{memory=new Uint8Array(e);romLength=0;constructor(){this.reset()}read(e){return this.assertMemory(e),this.memory[e]}write(e,s){this.assertMemory(e),this.memory[e]=255&s}slice(e,s){return this.memory.slice(e,s)}readOpcode(e){return this.isAddressInROM(e)?this.read(e)<<8|this.read(e+1):(console.warn(`PC 0x${e.toString(16)} out of ROM bounds, returning 0x0000`),0)}reset(){this.memory.fill(0),this.memory.set(c,0)}loadROM(t){if(t.length+s>e)throw new Error("ROM size exceeds memory capacity");this.memory.set(t,s),this.romLength=t.length}isAddressInROM(e){return e>=s&&e<s+this.romLength}assertMemory(s){if(s<0||s>=e)throw new Error(`Memory access out of bounds at 0x${s.toString(16)}`)}};class y{audioContext=null;masterGain=null;oscillator=null;wave="square";volumeLevel=.3;soundEnabled=!1;constructor(){this.initAudio()}initAudio(){const e=window.AudioContext||window.webkitAudioContext;e&&(this.audioContext=new e,this.masterGain=this.audioContext.createGain(),this.masterGain.connect(this.audioContext.destination),this.masterGain.gain.value=this.volumeLevel)}async ensureAudioContext(){this.audioContext&&"suspended"===this.audioContext.state&&await this.audioContext.resume()}async enableSound(){this.audioContext&&(await this.ensureAudioContext(),this.soundEnabled||(this.oscillator=new OscillatorNode(this.audioContext,{type:this.wave}),this.oscillator.connect(this.masterGain),this.oscillator.start(),this.soundEnabled=!0))}disableSound(){this.oscillator&&this.soundEnabled&&(this.oscillator.stop(),this.oscillator.disconnect(),this.oscillator=null,this.soundEnabled=!1)}mute(){this.volumeLevel=0,this.masterGain&&(this.masterGain.gain.value=0)}unMute(e=.3){this.volumeLevel=e,this.masterGain&&(this.masterGain.gain.value=e)}async playSound(e){e>0?await this.enableSound():this.disableSound()}setWave(e){this.wave=e,this.oscillator&&(this.oscillator.type=e)}setVolume(e){this.volumeLevel=e,this.masterGain&&(this.masterGain.gain.value=e)}}const p={49:1,50:2,51:3,52:12,81:4,87:5,69:6,82:13,65:7,83:8,68:9,70:14,90:10,88:0,67:11,86:15};class D{keyPressed=new Array(16).fill(!1);onNextKeyPress=null;constructor(){window.addEventListener("keydown",e=>this.onKeyDown(e)),window.addEventListener("keyup",e=>this.onKeyUp(e))}isKeyPressed(e){return this.keyPressed[e]||!1}onKeyDown(e){const s=p[String(e.keyCode)];void 0!==s&&(this.keyPressed[s]=!0)}onKeyUp(e){const s=p[String(e.keyCode)];void 0!==s&&(this.keyPressed[s]=!1,this.onNextKeyPress&&(this.onNextKeyPress(s),this.onNextKeyPress=null))}triggerKeyDown(e){this.keyPressed[e]=!0}triggerKeyUp(e){this.keyPressed[e]=!1,this.onNextKeyPress&&(this.onNextKeyPress(e),this.onNextKeyPress=null)}waitForNextKeyPress(e){this.onNextKeyPress=e}}class S{cpu;display;keyboard;speaker;ctx;frameFinishedCallback;fps=0;maxFps=60;interval=1e3/this.maxFps;previousTime=0;constructor(){this.display=new _(10),this.keyboard=new D,this.speaker=new y,this.cpu=new l,this.ctx={registers:this.cpu.registers,memory:k,drawSprite:(e,s,t)=>this.display.drawSprite(e,s,t),isKeyPressed:e=>this.keyboard.isKeyPressed(e),waitForKeyPress:e=>this.keyboard.onNextKeyPress=e,decrementTimers:()=>this.cpu.registers.updateTimers()}}run(){requestAnimationFrame(e=>this.runFrame(e))}loadRom(e){this.ctx.memory.reset(),this.display.clear(),this.cpu.registers.reset(),k.loadROM(e)}onFrameFinished(e){this.frameFinishedCallback=e}runFrame(e){this.previousTime||(this.previousTime=e);const s=e-this.previousTime;if(s>=this.interval){this.fps=1e3/s,this.previousTime=e-s%this.interval;const t=10;for(let e=0;e<t;e++)this.cpu.tick(this.ctx),this.speaker.playSound(this.cpu.registers.ST);this.frameFinishedCallback&&this.frameFinishedCallback(this.display.frameBuffer,this.fps,this.cpu.registers)}requestAnimationFrame(e=>this.runFrame(e))}}export{S as Chip8};

package/dist/constants/cpu.constants.d.ts

@@ -0,0 +1 @@
+export declare const CHIP8_SPEED = 10;

package/dist/constants/display.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DISPLAY_WIDTH = 64;
+export declare const DISPLAY_HEIGHT = 32;

package/dist/constants/instructions.constants.d.ts

@@ -0,0 +1,19 @@
+export declare const INSTRUCTION_SET: ({
+    key: number;
+    id: string;
+    name: string;
+    mask: number;
+    pattern: number;
+    arguments: {
+        mask: number;
+    }[];
+} | {
+    key: number;
+    id: string;
+    name: string;
+    mask: {
+        mask: number;
+    };
+    pattern: number;
+    arguments: never[];
+})[];

package/dist/constants/keymap.constants.d.ts

@@ -0,0 +1,37 @@
+export declare const NUMBER_OF_KEYS = 16;
+export declare const KEYMAP: {
+    49: number;
+    50: number;
+    51: number;
+    52: number;
+    81: number;
+    87: number;
+    69: number;
+    82: number;
+    65: number;
+    83: number;
+    68: number;
+    70: number;
+    90: number;
+    88: number;
+    67: number;
+    86: number;
+};
+export declare const DigitalKeyMapping: {
+    key1: number;
+    key2: number;
+    key3: number;
+    keyC: number;
+    key4: number;
+    key5: number;
+    key6: number;
+    keyD: number;
+    key7: number;
+    key8: number;
+    key9: number;
+    keyE: number;
+    keyA: number;
+    key0: number;
+    keyB: number;
+    keyF: number;
+};

package/dist/constants/memory.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MEMORY_SIZE = 4096;
+export declare const LOAD_PROGRAM_ADDRESS = 512;
+export declare const SPRITE_SET_ADDRESS = 0;

package/dist/constants/registers.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NUMBER_OF_REGISTERS = 16;
+export declare const STACK_DEEP = 16;

package/dist/constants/sprite.constants.d.ts

@@ -0,0 +1,3 @@
+export declare const SPRITE_WIDTH = 8;
+export declare const SPRITE_SET_ADDRESS = 0;
+export declare const SPRITES: number[];

package/dist/cpu/cpu.d.ts

@@ -0,0 +1,16 @@
+import { Registers } from "@/cpu/registers/registers";
+import type { ExecutionContext } from "@/cpu/operations/executionContext";
+export declare class CPU {
+    registers: Registers;
+    private disassembler;
+    /**
+     * Execute one CPU tick (instruction cycle)
+     * @param ctx The execution context (memory, registers, I/O)
+     * @returns Number of instructions executed (1 per tick)
+     */
+    tick(ctx: ExecutionContext): number;
+    /**
+     * Reset CPU registers
+     */
+    reset(): void;
+}

package/dist/cpu/disassembler/disassembler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Disassembler converts a 16-bit opcode into a Chip8 instruction and its arguments.
+ */
+export declare class Disassembler {
+    /**
+     * Disassemble a given opcode
+     * @param opcode 16-bit opcode
+     * @returns { instruction: Instruction | null, args: number[] }
+     */
+    disassemble(opcode: number): {
+        instruction: any | null;
+        args: number[];
+    };
+}

package/dist/cpu/operations/executionContext.d.ts

@@ -0,0 +1,29 @@
+import { Registers } from "@/cpu/registers/registers";
+import { Memory } from "@/memory/memory";
+/**
+ * ExecutionContext provides the CPU with access to memory, registers,
+ * display, input, and timers. It abstracts the underlying hardware
+ * so that the CPU can operate independently.
+ */
+export interface ExecutionContext {
+    /** CPU registers */
+    registers: Registers;
+    /** System memory */
+    memory: Memory;
+    /**
+     * Draw a sprite at (x, y). Returns true if any pixels were flipped from set to unset (collision).
+     * @param x - X coordinate
+     * @param y - Y coordinate
+     * @param sprite - Uint8Array of sprite bytes
+     */
+    drawSprite(x: number, y: number, sprite: Uint8Array): boolean;
+    /** Check if a key is currently pressed */
+    isKeyPressed(key: number): boolean;
+    /**
+     * Wait for the next key press.
+     * @param callback - called with the key value once pressed
+     */
+    waitForKeyPress(callback: (key: number) => void): void;
+    /** Called each cycle to decrement delay and sound timers */
+    decrementTimers(): void;
+}

package/dist/cpu/operations/operations.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutionContext } from "@/cpu/operations/executionContext";
+type Operation = (ctx: ExecutionContext, args: number[], opcode: number) => void;
+export declare const OPERATIONS: Record<string, Operation>;
+export {};

package/dist/cpu/registers/registers.d.ts

@@ -0,0 +1,24 @@
+export declare class Registers {
+    V: Uint8Array;
+    I: number;
+    stack: Uint16Array;
+    SP: number;
+    PC: number;
+    DT: number;
+    ST: number;
+    paused: boolean;
+    constructor();
+    /** Reset all registers, stack, PC, timers, and pause flag */
+    reset(): void;
+    /** Increment program counter to next instruction (2 bytes per CHIP-8 instruction) */
+    nextInstruction(): void;
+    /** Push value onto stack */
+    stackPush(value: number): void;
+    /** Pop value from stack */
+    stackPop(): number;
+    /**
+     * Update timers (called each cycle at ~60Hz)
+     * Decrements DT and ST, returns true if ST reached 0 (useful for beeps)
+     */
+    updateTimers(): boolean;
+}

package/dist/display/display.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Enhanced ImageData with a setPixel helper
+ */
+export declare class EnhancedImageData extends ImageData {
+    setPixel(x: number, y: number, red: number, green: number, blue: number, alpha?: number): void;
+}
+/**
+ * Display class for Chip8
+ */
+export declare class Display {
+    width: number;
+    height: number;
+    scale: number;
+    scaledWidth: number;
+    scaledHeight: number;
+    frameBuffer: EnhancedImageData;
+    foregroundColor: [number, number, number];
+    backgroundColor: [number, number, number];
+    constructor(scale?: number);
+    setForegroundColor(color: string | [number, number, number]): void;
+    setBackgroundColor(color: string | [number, number, number]): void;
+    /** Clear the screen */
+    clear(): void;
+    /**
+     * Draw a sprite at x, y. Returns true if any pixel was erased (collision)
+     * Each sprite row is a byte (8 pixels)
+     * Draws each CHIP-8 pixel as a block of size scale x scale
+     */
+    drawSprite(x: number, y: number, sprite: Uint8Array): boolean;
+    private parseColor;
+}

package/dist/example.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/input/keyboard.d.ts

@@ -0,0 +1,19 @@
+export declare class Keyboard {
+    /** Array of pressed keys */
+    keyPressed: boolean[];
+    /** Callback for waiting for next key press */
+    onNextKeyPress: ((key: number) => void) | null;
+    constructor();
+    /** Checks if a key is pressed */
+    isKeyPressed(keyCode: number): boolean;
+    /** Handle physical key down */
+    private onKeyDown;
+    /** Handle physical key up */
+    private onKeyUp;
+    /** Manually trigger a key press (useful for virtual or headless input) */
+    triggerKeyDown(keyCode: number): void;
+    /** Manually trigger a key release (useful for virtual or headless input) */
+    triggerKeyUp(keyCode: number): void;
+    /** Wait for the next key press (for FX0A opcode) */
+    waitForNextKeyPress(callback: (key: number) => void): void;
+}

package/dist/memory/memory.d.ts

@@ -0,0 +1,14 @@
+export declare class Memory {
+    private memory;
+    private romLength;
+    constructor();
+    read(address: number): number;
+    write(address: number, value: number): void;
+    slice(start: number, end: number): Uint8Array;
+    readOpcode(address: number): number;
+    reset(): void;
+    loadROM(buffer: Uint8Array): void;
+    isAddressInROM(address: number): boolean;
+    private assertMemory;
+}
+export declare const memory: Memory;

package/index.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Chip8 Emulator</title>
+  <style>
+    body {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      background-color: #222;
+      color: #eee;
+      font-family: sans-serif;
+    }
+
+    canvas {
+      image-rendering: pixelated;
+      margin-top: 20px;
+      border: 2px solid #eee;
+    }
+
+    input {
+      margin-top: 10px;
+    }
+  </style>
+</head>
+<body>
+  <h1>Chip8 Emulator</h1>
+  <canvas id="screen"></canvas>
+  <input type="file" id="romLoader" accept=".ch8,.rom" />
+  <script type="module" src="/src/example.ts"></script>
+</body>
+</html>

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@slurrps/chippy",
+  "private": false,
+  "version": "0.1.0",
+  "type": "module",
+  "description": "a Chip8 emulator written in typescript",
+  "scripts": {
+    "dev": "vite",
+    "build": "webpack",
+    "preview": "vite preview"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "ts-loader": "^9.5.4",
+    "typescript": "~5.9.3",
+    "vite": "^7.2.4",
+    "webpack": "^5.104.1",
+    "webpack-cli": "^6.0.1"
+  }
+}