@gba-kit/gba-react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Macabeus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# @gba-kit/gba-react
+
+Headless React hooks for GBA emulation. Wraps [`@gba-kit/gba-browser`](../gba-browser) with proper React lifecycle management.
+
+## Install
+
+```bash
+npm install @gba-kit/gba-react
+```
+
+## Hooks
+
+### `useEmulator(options?)`
+
+Creates and owns an `EmulatorBridge` instance. The instance is stable across re-renders and cleaned up on unmount.
+
+Returns `{ emulator, state }` where `state` is reactive (`'idle' | 'paused' | 'running'`).
+
+```tsx
+import { useEmulator } from '@gba-kit/gba-react';
+
+function App() {
+  const { emulator, state } = useEmulator({
+    onFrame: () => {
+      /* called after each emulated frame */
+    },
+    onBreakpoint: (addr) => console.log('breakpoint hit at', addr),
+  });
+
+  return (
+    <div>
+      <p>State: {state}</p>
+      <button onClick={() => emulator.run()}>Run</button>
+      <button onClick={() => emulator.pause()}>Pause</button>
+    </div>
+  );
+}
+```
+
+### `useEmulatorCanvas(emulator)`
+
+Binds a `<canvas>` element to the emulator's display output. Returns a ref to attach to your own canvas. The hook handles `attachCanvas` on mount and `detachCanvas` on unmount.
+
+The canvas dimensions are set to 240x160 (native GBA resolution) by the emulator. Control display size with CSS.
+
+```tsx
+import { useEmulatorCanvas } from '@gba-kit/gba-react';
+
+function Screen({ emulator }) {
+  const canvasRef = useEmulatorCanvas(emulator);
+  return <canvas ref={canvasRef} style={{ width: 720, height: 480, imageRendering: 'pixelated' }} />;
+}
+```
+
+### `useEmulatorKeyboard(emulator)`
+
+Registers global `keydown`/`keyup` listeners that forward to the emulator's built-in key map. It's pure side-effect and returns nothing.
+
+Default key map: Arrow keys = D-pad, Z = A, X = B, Enter = Start, Backspace = Select, A/S = L/R.
+
+Omit this hook if you handle input differently (e.g. on-screen touch controls).
+
+```tsx
+import { useEmulatorKeyboard } from '@gba-kit/gba-react';
+
+function Game({ emulator }) {
+  useEmulatorKeyboard(emulator);
+  // ...
+}
+```
+
+## Full Example
+
+```tsx
+import { useEmulator, useEmulatorCanvas, useEmulatorKeyboard } from '@gba-kit/gba-react';
+
+function GbaPlayer({ romUrl }: { romUrl: string }) {
+  const { emulator, state } = useEmulator();
+  const canvasRef = useEmulatorCanvas(emulator);
+  useEmulatorKeyboard(emulator);
+
+  const loadAndRun = async () => {
+    const res = await fetch(romUrl);
+    const data = await res.arrayBuffer();
+    emulator.loadRom(data);
+    emulator.run();
+  };
+
+  return (
+    <div>
+      {state === 'idle' ? (
+        <button onClick={loadAndRun}>Load ROM</button>
+      ) : (
+        <canvas ref={canvasRef} style={{ width: 480, height: 320 }} />
+      )}
+    </div>
+  );
+}
+```
+
+## Exports
+
+| Export                | Description                                            |
+| --------------------- | ------------------------------------------------------ |
+| `useEmulator`         | Create and own an `EmulatorBridge` with reactive state |
+| `useEmulatorCanvas`   | Bind a canvas ref to the emulator display              |
+| `useEmulatorKeyboard` | Register global keyboard input listeners               |
+
+Type: `UseEmulatorOptions`
+
+## See Also
+
+- [`@gba-kit/gba-browser`](../gba-browser) — The underlying browser runtime (framework-agnostic)
+- [`@gba-kit/gba-node`](../gba-node) — Headless Node.js runtime for scripted emulation

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { useEmulator } from './use-emulator.js';
+export type { UseEmulatorOptions } from './use-emulator.js';
+export { useEmulatorCanvas } from './use-emulator-canvas.js';
+export { useEmulatorKeyboard } from './use-emulator-keyboard.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { useEmulator } from './use-emulator.js';
+export { useEmulatorCanvas } from './use-emulator-canvas.js';
+export { useEmulatorKeyboard } from './use-emulator-keyboard.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/use-emulator-canvas.d.ts

@@ -0,0 +1,23 @@
+import type { EmulatorBridge } from '@gba-kit/gba-browser';
+import { type RefObject } from 'react';
+/**
+ * Binds a `<canvas>` element to the emulator's display output.
+ *
+ * Returns a ref that the consumer attaches to their own `<canvas>`.
+ * The hook calls {@link EmulatorBridge.attachCanvas} when the canvas mounts
+ * and {@link EmulatorBridge.detachCanvas} when it unmounts, so the
+ * emulator's framebuffer is always blitted to the visible canvas.
+ *
+ * The canvas dimensions are set to 240x160 (native GBA resolution) by the
+ * bridge. The consumer controls the display size via CSS.
+ *
+ * @example
+ * ```tsx
+ * function Screen({ emulator }: { emulator: EmulatorBridge }) {
+ *   const canvasRef = useEmulatorCanvas(emulator);
+ *   return <canvas ref={canvasRef} style={{ width: 720, height: 480 }} />;
+ * }
+ * ```
+ */
+export declare function useEmulatorCanvas(emulator: EmulatorBridge): RefObject<HTMLCanvasElement | null>;
+//# sourceMappingURL=use-emulator-canvas.d.ts.map

package/dist/use-emulator-canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator-canvas.d.ts","sourceRoot":"","sources":["../src/use-emulator-canvas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAgB/F"}

package/dist/use-emulator-canvas.js

@@ -0,0 +1,35 @@
+import { useEffect, useRef } from 'react';
+/**
+ * Binds a `<canvas>` element to the emulator's display output.
+ *
+ * Returns a ref that the consumer attaches to their own `<canvas>`.
+ * The hook calls {@link EmulatorBridge.attachCanvas} when the canvas mounts
+ * and {@link EmulatorBridge.detachCanvas} when it unmounts, so the
+ * emulator's framebuffer is always blitted to the visible canvas.
+ *
+ * The canvas dimensions are set to 240x160 (native GBA resolution) by the
+ * bridge. The consumer controls the display size via CSS.
+ *
+ * @example
+ * ```tsx
+ * function Screen({ emulator }: { emulator: EmulatorBridge }) {
+ *   const canvasRef = useEmulatorCanvas(emulator);
+ *   return <canvas ref={canvasRef} style={{ width: 720, height: 480 }} />;
+ * }
+ * ```
+ */
+export function useEmulatorCanvas(emulator) {
+    const canvasRef = useRef(null);
+    useEffect(() => {
+        const canvas = canvasRef.current;
+        if (!canvas) {
+            return;
+        }
+        emulator.attachCanvas(canvas);
+        return () => {
+            emulator.detachCanvas();
+        };
+    }, [emulator]);
+    return canvasRef;
+}
+//# sourceMappingURL=use-emulator-canvas.js.map

package/dist/use-emulator-canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator-canvas.js","sourceRoot":"","sources":["../src/use-emulator-canvas.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,SAAS,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAE1D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAwB;IACxD,MAAM,SAAS,GAAG,MAAM,CAA2B,IAAI,CAAC,CAAC;IAEzD,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC;QACjC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QAED,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,GAAG,EAAE;YACV,QAAQ,CAAC,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/use-emulator-keyboard.d.ts

@@ -0,0 +1,22 @@
+import type { EmulatorBridge } from '@gba-kit/gba-browser';
+/**
+ * Registers global keyboard listeners that forward key events to the emulator.
+ *
+ * Uses the bridge's built-in key map (arrow keys for D-pad, Z/X for A/B,
+ * Enter for Start, Backspace for Select, A/S for L/R).
+ *
+ * Listeners are added on mount and removed on unmount. The hook is a pure
+ * side-effect — it returns nothing. Consumers that handle input differently
+ * (e.g. on-screen touch controls) simply omit this hook.
+ *
+ * @example
+ * ```tsx
+ * function Game({ emulator }: { emulator: EmulatorBridge }) {
+ *   useEmulatorKeyboard(emulator);
+ *   const canvasRef = useEmulatorCanvas(emulator);
+ *   return <canvas ref={canvasRef} />;
+ * }
+ * ```
+ */
+export declare function useEmulatorKeyboard(emulator: EmulatorBridge): void;
+//# sourceMappingURL=use-emulator-keyboard.d.ts.map

package/dist/use-emulator-keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator-keyboard.d.ts","sourceRoot":"","sources":["../src/use-emulator-keyboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI,CAalE"}

package/dist/use-emulator-keyboard.js

@@ -0,0 +1,33 @@
+import { useEffect } from 'react';
+/**
+ * Registers global keyboard listeners that forward key events to the emulator.
+ *
+ * Uses the bridge's built-in key map (arrow keys for D-pad, Z/X for A/B,
+ * Enter for Start, Backspace for Select, A/S for L/R).
+ *
+ * Listeners are added on mount and removed on unmount. The hook is a pure
+ * side-effect — it returns nothing. Consumers that handle input differently
+ * (e.g. on-screen touch controls) simply omit this hook.
+ *
+ * @example
+ * ```tsx
+ * function Game({ emulator }: { emulator: EmulatorBridge }) {
+ *   useEmulatorKeyboard(emulator);
+ *   const canvasRef = useEmulatorCanvas(emulator);
+ *   return <canvas ref={canvasRef} />;
+ * }
+ * ```
+ */
+export function useEmulatorKeyboard(emulator) {
+    useEffect(() => {
+        const handleKeyDown = (e) => emulator.handleKeyDown(e);
+        const handleKeyUp = (e) => emulator.handleKeyUp(e);
+        window.addEventListener('keydown', handleKeyDown);
+        window.addEventListener('keyup', handleKeyUp);
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown);
+            window.removeEventListener('keyup', handleKeyUp);
+        };
+    }, [emulator]);
+}
+//# sourceMappingURL=use-emulator-keyboard.js.map

package/dist/use-emulator-keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator-keyboard.js","sourceRoot":"","sources":["../src/use-emulator-keyboard.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAwB;IAC1D,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,aAAa,GAAG,CAAC,CAAgB,EAAE,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QACtE,MAAM,WAAW,GAAG,CAAC,CAAgB,EAAE,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAElE,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAClD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAE9C,OAAO,GAAG,EAAE;YACV,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YACrD,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACnD,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;AACjB,CAAC"}

package/dist/use-emulator.d.ts

@@ -0,0 +1,52 @@
+import { EmulatorBridge, type EmulatorState } from '@gba-kit/gba-browser';
+/**
+ * Options for {@link useEmulator}.
+ *
+ * All callbacks are optional. They are registered once when the hook mounts
+ * and updated on every render via a stable ref, so the consumer does not need
+ * to memoize them.
+ */
+export interface UseEmulatorOptions {
+    /**
+     * Called after each emulated frame (during `run()`, `stepInstruction()`,
+     * `stepOver()`, etc.). Useful for triggering re-renders in debug views
+     * that display registers, memory, or disassembly.
+     *
+     * **Caution:** During normal play this fires ~60 times per second.
+     * Avoid expensive work here unless the emulator is paused/stepping.
+     */
+    onFrame?: () => void;
+    /** Called when the emulator hits an enabled breakpoint. */
+    onBreakpoint?: (address: number) => void;
+}
+/**
+ * Core hook that creates and owns a GBA {@link EmulatorBridge} instance.
+ *
+ * The bridge is created once and is stable for the lifetime of the component.
+ * The returned `state` is reactive — it triggers a re-render when the
+ * emulator transitions between `'idle'`, `'paused'`, and `'running'`.
+ *
+ * Cleans up the emulation loop on unmount.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { emulator, state } = useEmulator({
+ *     onBreakpoint: (addr) => console.log('hit', addr),
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => emulator.run()}>
+ *       {state === 'running' ? 'Pause' : 'Run'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useEmulator(options?: UseEmulatorOptions): {
+    /** The stable emulator bridge instance. Safe to pass as a prop. */
+    emulator: EmulatorBridge;
+    /** Reactive emulator state — re-renders the component on transitions. */
+    state: EmulatorState;
+};
+//# sourceMappingURL=use-emulator.d.ts.map

package/dist/use-emulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator.d.ts","sourceRoot":"","sources":["../src/use-emulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG1E;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,2DAA2D;IAC3D,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG;IACzD,mEAAmE;IACnE,QAAQ,EAAE,cAAc,CAAC;IACzB,yEAAyE;IACzE,KAAK,EAAE,aAAa,CAAC;CACtB,CA6BA"}

package/dist/use-emulator.js

@@ -0,0 +1,52 @@
+import { EmulatorBridge } from '@gba-kit/gba-browser';
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Core hook that creates and owns a GBA {@link EmulatorBridge} instance.
+ *
+ * The bridge is created once and is stable for the lifetime of the component.
+ * The returned `state` is reactive — it triggers a re-render when the
+ * emulator transitions between `'idle'`, `'paused'`, and `'running'`.
+ *
+ * Cleans up the emulation loop on unmount.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { emulator, state } = useEmulator({
+ *     onBreakpoint: (addr) => console.log('hit', addr),
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => emulator.run()}>
+ *       {state === 'running' ? 'Pause' : 'Run'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export function useEmulator(options) {
+    // Keep options in a ref so the callback closure always sees the latest
+    // without needing the consumer to memoize.
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const [state, setState] = useState('idle');
+    // Create the bridge exactly once (stable across renders).
+    const emulatorRef = useRef(null);
+    if (emulatorRef.current === null) {
+        emulatorRef.current = new EmulatorBridge();
+    }
+    const emulator = emulatorRef.current;
+    // Wire callbacks on mount; update the ref-based forwarding on every render.
+    useEffect(() => {
+        emulator.setCallbacks({
+            onStateChange: (s) => setState(s),
+            onFrame: () => optionsRef.current?.onFrame?.(),
+            onBreakpoint: (addr) => optionsRef.current?.onBreakpoint?.(addr),
+        });
+        return () => {
+            emulator.stop();
+        };
+    }, [emulator]);
+    return { emulator, state };
+}
+//# sourceMappingURL=use-emulator.js.map

package/dist/use-emulator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-emulator.js","sourceRoot":"","sources":["../src/use-emulator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAsB,MAAM,sBAAsB,CAAC;AAC1E,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAuBpD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,WAAW,CAAC,OAA4B;IAMtD,uEAAuE;IACvE,2CAA2C;IAC3C,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IACnC,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IAE7B,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAgB,MAAM,CAAC,CAAC;IAE1D,0DAA0D;IAC1D,MAAM,WAAW,GAAG,MAAM,CAAwB,IAAI,CAAC,CAAC;IACxD,IAAI,WAAW,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QACjC,WAAW,CAAC,OAAO,GAAG,IAAI,cAAc,EAAE,CAAC;IAC7C,CAAC;IACD,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC;IAErC,4EAA4E;IAC5E,SAAS,CAAC,GAAG,EAAE;QACb,QAAQ,CAAC,YAAY,CAAC;YACpB,aAAa,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;YACjC,OAAO,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;YAC9C,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC,IAAI,CAAC;SACjE,CAAC,CAAC;QAEH,OAAO,GAAG,EAAE;YACV,QAAQ,CAAC,IAAI,EAAE,CAAC;QAClB,CAAC,CAAC;IACJ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAC7B,CAAC"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gba-kit/gba-react",
+  "version": "0.1.0",
+  "description": "React hooks for GBA emulation",
+  "author": "macabeus",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/macabeus/gba-kit",
+    "directory": "packages/gba-react"
+  },
+  "homepage": "https://github.com/macabeus/gba-kit",
+  "bugs": "https://github.com/macabeus/gba-kit/issues",
+  "keywords": [
+    "gba",
+    "gameboy-advance",
+    "emulator",
+    "react",
+    "hooks",
+    "typescript"
+  ],
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@gba-kit/gba-browser": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "check-types": "tsc --noEmit",
+    "lint": "eslint src/"
+  }
+}