ink-native 0.1.0 → 0.3.0

package/README.md

@@ -127,7 +127,7 @@ window.on("close", () => process.exit(0));
 
 ## Direct Framebuffer Access
 
-For high-framerate graphics (emulators, games, video players), you can write pixels directly to the framebuffer while pausing the Ink event loop:
+For high-framerate graphics (emulators, games, video players), you can write pixels directly to the framebuffer while pausing Ink:
 
 ```tsx
 import { createStreams, packColor } from "ink-native";
@@ -147,12 +147,25 @@ const { stdin, stdout, window, renderer } = createStreams({
 
 render(<App />, { stdin, stdout });
 
-// Pause Ink's event loop to take over rendering
+// Pause Ink to take over rendering
 window.pause();
 
 const fb = renderer.getFramebuffer();
 
-// Game loop — you control timing and rendering
+// Keyboard events keep firing when paused
+window.on("keydown", (event) => {
+  if (event.key === "q") {
+    clearInterval(gameLoop);
+    window.resume(); // hand control back to Ink
+  }
+});
+
+window.on("close", () => {
+  clearInterval(gameLoop);
+  process.exit(0);
+});
+
+// Game loop — just render, events are handled automatically
 const gameLoop = setInterval(() => {
   // Write pixels directly (0xAARRGGBB format)
   for (let y = 100; y < 200; y++) {
@@ -161,24 +174,8 @@ const gameLoop = setInterval(() => {
     }
   }
 
-  // Present the framebuffer and poll window events
+  // Copy to native buffer (the event loop presents it)
   renderer.present();
-  const { keyEvents, mod } = renderer.processEventsAndPresent();
-
-  // Handle input
-  for (const event of keyEvents) {
-    const seq = renderer.keyEventToSequence(event, mod);
-    if (seq === "q") {
-      clearInterval(gameLoop);
-      window.resume(); // hand control back to Ink
-    }
-  }
-
-  if (renderer.shouldClose()) {
-    clearInterval(gameLoop);
-    window.close();
-    process.exit(0);
-  }
 }, 16); // ~60fps
 ```
 
@@ -211,31 +208,24 @@ const startEmulator = () => {
   window.pause();
 
   const fb = renderer.getFramebuffer();
+  let emuLoop: ReturnType<typeof setInterval>;
+
+  // Keyboard events keep firing when paused
+  window.on("keydown", (event) => {
+    if (event.key === "Escape") {
+      // Return to menu
+      clearInterval(emuLoop);
+      renderer.clear();
+      window.resume(); // hand control back to Ink
+    }
+  });
 
-  const emuLoop = setInterval(() => {
+  emuLoop = setInterval(() => {
     // Write emulator frame directly to the framebuffer
     renderEmulatorFrame(fb.pixels, fb.width, fb.height);
 
-    // Present and poll events
+    // Copy to native buffer (the event loop presents it)
     renderer.present();
-    const { keyEvents, mod } = renderer.processEventsAndPresent();
-
-    for (const event of keyEvents) {
-      const seq = renderer.keyEventToSequence(event, mod);
-      if (seq === "\x1b") {
-        // Escape pressed — return to menu
-        clearInterval(emuLoop);
-        renderer.clear();
-        window.resume(); // hand control back to Ink
-        return;
-      }
-    }
-
-    if (renderer.shouldClose()) {
-      clearInterval(emuLoop);
-      window.close();
-      process.exit(0);
-    }
   }, 16);
 };
 ```
@@ -248,9 +238,9 @@ The framebuffer is shared — Ink renders to it when active, and you write pixel
 | --------------------------- | ------------------------------------------------------- |
 | `packColor(r, g, b)`        | Pack RGB values into `0xAARRGGBB` pixel format          |
 | `renderer.getFramebuffer()` | Get `{ pixels, width, height }` — the live pixel buffer |
-| `window.pause()`            | Stop Ink's event loop for manual rendering              |
-| `window.resume()`           | Restart Ink's event loop                                |
-| `window.isPaused()`         | Check if the event loop is paused                       |
+| `window.pause()`            | Pause Ink (events keep firing)                          |
+| `window.resume()`           | Resume Ink                                              |
+| `window.isPaused()`         | Check if Ink is paused                                  |
 
 ## API
 
@@ -286,8 +276,9 @@ Event emitter for window lifecycle and input events.
 
 #### Events
 
+- `keydown` -- Emitted when a key is pressed (with `NativeKeyboardEvent` payload)
+- `keyup` -- Emitted when a key is released (with `NativeKeyboardEvent` payload)
 - `close` -- Emitted when the window is closed
-- `key` -- Emitted on keyboard events
 - `resize` -- Emitted when the window is resized (with `{ columns, rows }`)
 - `sigint` -- Emitted on Ctrl+C (if a listener is registered; otherwise sends SIGINT to the process)
 
@@ -299,13 +290,64 @@ Event emitter for window lifecycle and input events.
 - `clear()` -- Clear the screen
 - `close()` -- Close the window
 - `isClosed()` -- Check if the window is closed
-- `pause()` -- Pause the Ink event loop for manual rendering
-- `resume()` -- Resume the Ink event loop
-- `isPaused()` -- Check if the event loop is paused
+- `pause()` -- Pause Ink for manual rendering (keydown/keyup/resize/close events keep firing)
+- `resume()` -- Resume Ink
+- `isPaused()` -- Check if Ink is paused
+- `processEvents()` -- Manually poll events and present the framebuffer (for custom render loops that need explicit control)
 
-## Keyboard Support
+## Keyboard Events
 
-The following keys are mapped to terminal sequences:
+The `window` emits `keydown` and `keyup` events with a `NativeKeyboardEvent` payload:
+
+```typescript
+import { createStreams, type NativeKeyboardEvent } from "ink-native";
+
+const { window } = createStreams({ title: "My Game" });
+
+window.on("keydown", (event: NativeKeyboardEvent) => {
+  console.log(event.key);     // "a", "A", "Enter", "ArrowUp", "Shift"
+  console.log(event.code);    // "KeyA", "Enter", "ArrowUp", "ShiftLeft"
+  console.log(event.ctrlKey); // true if Ctrl is held
+  console.log(event.type);    // "keydown"
+});
+
+window.on("keyup", (event: NativeKeyboardEvent) => {
+  console.log(event.key, "released");
+});
+```
+
+#### `NativeKeyboardEvent`
+
+| Property   | Type                     | Description                                             |
+| ---------- | ------------------------ | ------------------------------------------------------- |
+| `key`      | `string`                 | The key value: `"a"`, `"A"`, `"Enter"`, `"Shift"`      |
+| `code`     | `string`                 | Physical key code: `"KeyA"`, `"Enter"`, `"ShiftLeft"`   |
+| `ctrlKey`  | `boolean`                | Whether Ctrl is held                                    |
+| `shiftKey` | `boolean`                | Whether Shift is held                                   |
+| `altKey`   | `boolean`                | Whether Alt is held                                     |
+| `metaKey`  | `boolean`                | Whether Meta/Command is held                            |
+| `repeat`   | `false`                  | Always `false` (fenster only reports transitions)       |
+| `type`     | `"keydown" \| "keyup"`   | Whether the key was pressed or released                 |
+
+Modifier keys fire their own events with left/right distinction — `event.code` will be `"ShiftLeft"` or `"ShiftRight"`, while `event.key` gives the generic name `"Shift"`.
+
+#### `isNativeKeyboardEvent(value)`
+
+Type guard to check if a value is a `NativeKeyboardEvent`:
+
+```typescript
+import { isNativeKeyboardEvent } from "ink-native";
+
+window.on("keydown", (event) => {
+  if (isNativeKeyboardEvent(event)) {
+    // event is typed as NativeKeyboardEvent
+  }
+});
+```
+
+### Terminal Sequences
+
+In addition to `keydown`/`keyup` events, key presses are also mapped to terminal escape sequences and pushed to `stdin` for Ink's built-in key handling:
 
 - Arrow keys (Up, Down, Left, Right)
 - Enter, Escape, Backspace, Tab, Delete
@@ -327,6 +369,11 @@ import {
   InputStream,
   OutputStream,
 
+  // Keyboard events
+  createKeyboardEvent,
+  isNativeKeyboardEvent,
+  type NativeKeyboardEvent,
+
   // Renderer
   UiRenderer,
   packColor,

package/dist/{chunk-3NCUBVFY.js → chunk-FE3HR4I4.js}

@@ -123867,13 +123867,66 @@ var FENSTER_KEY_HOME = 2;
 var FENSTER_KEY_PAGEUP = 3;
 var FENSTER_KEY_PAGEDOWN = 4;
 var FENSTER_KEY_END = 5;
+var FENSTER_KEY_INSERT = 26;
 var FENSTER_KEY_A = 65;
+var FENSTER_KEY_B = 66;
+var FENSTER_KEY_C = 67;
+var FENSTER_KEY_D = 68;
+var FENSTER_KEY_E = 69;
+var FENSTER_KEY_F = 70;
+var FENSTER_KEY_G = 71;
+var FENSTER_KEY_H = 72;
+var FENSTER_KEY_I = 73;
+var FENSTER_KEY_J = 74;
+var FENSTER_KEY_K = 75;
+var FENSTER_KEY_L = 76;
+var FENSTER_KEY_M = 77;
+var FENSTER_KEY_N = 78;
+var FENSTER_KEY_O = 79;
+var FENSTER_KEY_P = 80;
+var FENSTER_KEY_Q = 81;
+var FENSTER_KEY_R = 82;
+var FENSTER_KEY_S = 83;
+var FENSTER_KEY_T = 84;
+var FENSTER_KEY_U = 85;
+var FENSTER_KEY_V = 86;
+var FENSTER_KEY_W = 87;
+var FENSTER_KEY_X = 88;
+var FENSTER_KEY_Y = 89;
 var FENSTER_KEY_Z = 90;
+var FENSTER_KEY_0 = 48;
+var FENSTER_KEY_1 = 49;
+var FENSTER_KEY_2 = 50;
+var FENSTER_KEY_3 = 51;
+var FENSTER_KEY_4 = 52;
+var FENSTER_KEY_5 = 53;
+var FENSTER_KEY_6 = 54;
+var FENSTER_KEY_7 = 55;
+var FENSTER_KEY_8 = 56;
+var FENSTER_KEY_9 = 57;
+var FENSTER_KEY_APOSTROPHE = 39;
+var FENSTER_KEY_COMMA = 44;
+var FENSTER_KEY_MINUS = 45;
+var FENSTER_KEY_PERIOD = 46;
+var FENSTER_KEY_SLASH = 47;
+var FENSTER_KEY_SEMICOLON = 59;
+var FENSTER_KEY_EQUAL = 61;
 var FENSTER_KEY_BRACKET_LEFT = 91;
 var FENSTER_KEY_BACKSLASH = 92;
 var FENSTER_KEY_BRACKET_RIGHT = 93;
+var FENSTER_KEY_GRAVE = 96;
+var FENSTER_KEY_SHIFT_LEFT = 128;
+var FENSTER_KEY_SHIFT_RIGHT = 129;
+var FENSTER_KEY_CONTROL_LEFT = 130;
+var FENSTER_KEY_CONTROL_RIGHT = 131;
+var FENSTER_KEY_ALT_LEFT = 132;
+var FENSTER_KEY_ALT_RIGHT = 133;
+var FENSTER_KEY_META_LEFT = 134;
+var FENSTER_KEY_META_RIGHT = 135;
 var FENSTER_MOD_CTRL = 1;
 var FENSTER_MOD_SHIFT = 2;
+var FENSTER_MOD_ALT = 4;
+var FENSTER_MOD_META = 8;
 var KEYS_ARRAY_SIZE = 256;
 var INT32_BYTES = 4;
 var FENSTER_LIB_PATHS = {
@@ -123888,6 +123941,10 @@ var findFensterLibrary = () => {
   if (!libName) {
     return null;
   }
+  try {
+    return fileURLToPath(import.meta.resolve(`ink-native/${libName}`));
+  } catch {
+  }
   const currentDir = dirname(fileURLToPath(import.meta.url));
   const projectRoot = resolve(currentDir, "../..");
   return resolve(projectRoot, libName);
@@ -124134,9 +124191,249 @@ var InputStream = class extends Readable {
   }
 };
 
+// src/KeyboardEvent/consts.ts
+var FENSTER_TO_CODE = {
+  // Navigation / control
+  [FENSTER_KEY_BACKSPACE]: "Backspace",
+  [FENSTER_KEY_TAB]: "Tab",
+  [FENSTER_KEY_RETURN]: "Enter",
+  [FENSTER_KEY_UP]: "ArrowUp",
+  [FENSTER_KEY_DOWN]: "ArrowDown",
+  [FENSTER_KEY_RIGHT]: "ArrowRight",
+  [FENSTER_KEY_LEFT]: "ArrowLeft",
+  [FENSTER_KEY_ESCAPE]: "Escape",
+  [FENSTER_KEY_SPACE]: "Space",
+  [FENSTER_KEY_DELETE]: "Delete",
+  [FENSTER_KEY_HOME]: "Home",
+  [FENSTER_KEY_PAGEUP]: "PageUp",
+  [FENSTER_KEY_PAGEDOWN]: "PageDown",
+  [FENSTER_KEY_END]: "End",
+  [FENSTER_KEY_INSERT]: "Insert",
+  // Letters (A-Z → KeyA-KeyZ)
+  [FENSTER_KEY_A]: "KeyA",
+  [FENSTER_KEY_B]: "KeyB",
+  [FENSTER_KEY_C]: "KeyC",
+  [FENSTER_KEY_D]: "KeyD",
+  [FENSTER_KEY_E]: "KeyE",
+  [FENSTER_KEY_F]: "KeyF",
+  [FENSTER_KEY_G]: "KeyG",
+  [FENSTER_KEY_H]: "KeyH",
+  [FENSTER_KEY_I]: "KeyI",
+  [FENSTER_KEY_J]: "KeyJ",
+  [FENSTER_KEY_K]: "KeyK",
+  [FENSTER_KEY_L]: "KeyL",
+  [FENSTER_KEY_M]: "KeyM",
+  [FENSTER_KEY_N]: "KeyN",
+  [FENSTER_KEY_O]: "KeyO",
+  [FENSTER_KEY_P]: "KeyP",
+  [FENSTER_KEY_Q]: "KeyQ",
+  [FENSTER_KEY_R]: "KeyR",
+  [FENSTER_KEY_S]: "KeyS",
+  [FENSTER_KEY_T]: "KeyT",
+  [FENSTER_KEY_U]: "KeyU",
+  [FENSTER_KEY_V]: "KeyV",
+  [FENSTER_KEY_W]: "KeyW",
+  [FENSTER_KEY_X]: "KeyX",
+  [FENSTER_KEY_Y]: "KeyY",
+  [FENSTER_KEY_Z]: "KeyZ",
+  // Digits (0-9 → Digit0-Digit9)
+  [FENSTER_KEY_0]: "Digit0",
+  [FENSTER_KEY_1]: "Digit1",
+  [FENSTER_KEY_2]: "Digit2",
+  [FENSTER_KEY_3]: "Digit3",
+  [FENSTER_KEY_4]: "Digit4",
+  [FENSTER_KEY_5]: "Digit5",
+  [FENSTER_KEY_6]: "Digit6",
+  [FENSTER_KEY_7]: "Digit7",
+  [FENSTER_KEY_8]: "Digit8",
+  [FENSTER_KEY_9]: "Digit9",
+  // Symbols
+  [FENSTER_KEY_APOSTROPHE]: "Quote",
+  [FENSTER_KEY_COMMA]: "Comma",
+  [FENSTER_KEY_MINUS]: "Minus",
+  [FENSTER_KEY_PERIOD]: "Period",
+  [FENSTER_KEY_SLASH]: "Slash",
+  [FENSTER_KEY_SEMICOLON]: "Semicolon",
+  [FENSTER_KEY_EQUAL]: "Equal",
+  [FENSTER_KEY_BRACKET_LEFT]: "BracketLeft",
+  [FENSTER_KEY_BACKSLASH]: "Backslash",
+  [FENSTER_KEY_BRACKET_RIGHT]: "BracketRight",
+  [FENSTER_KEY_GRAVE]: "Backquote",
+  // Modifier keys (left/right)
+  [FENSTER_KEY_SHIFT_LEFT]: "ShiftLeft",
+  [FENSTER_KEY_SHIFT_RIGHT]: "ShiftRight",
+  [FENSTER_KEY_CONTROL_LEFT]: "ControlLeft",
+  [FENSTER_KEY_CONTROL_RIGHT]: "ControlRight",
+  [FENSTER_KEY_ALT_LEFT]: "AltLeft",
+  [FENSTER_KEY_ALT_RIGHT]: "AltRight",
+  [FENSTER_KEY_META_LEFT]: "MetaLeft",
+  [FENSTER_KEY_META_RIGHT]: "MetaRight"
+};
+var FENSTER_TO_KEY = {
+  // Navigation / control
+  [FENSTER_KEY_BACKSPACE]: "Backspace",
+  [FENSTER_KEY_TAB]: "Tab",
+  [FENSTER_KEY_RETURN]: "Enter",
+  [FENSTER_KEY_UP]: "ArrowUp",
+  [FENSTER_KEY_DOWN]: "ArrowDown",
+  [FENSTER_KEY_RIGHT]: "ArrowRight",
+  [FENSTER_KEY_LEFT]: "ArrowLeft",
+  [FENSTER_KEY_ESCAPE]: "Escape",
+  [FENSTER_KEY_SPACE]: " ",
+  [FENSTER_KEY_DELETE]: "Delete",
+  [FENSTER_KEY_HOME]: "Home",
+  [FENSTER_KEY_PAGEUP]: "PageUp",
+  [FENSTER_KEY_PAGEDOWN]: "PageDown",
+  [FENSTER_KEY_END]: "End",
+  [FENSTER_KEY_INSERT]: "Insert",
+  // Letters (A-Z → a-z lowercase)
+  [FENSTER_KEY_A]: "a",
+  [FENSTER_KEY_B]: "b",
+  [FENSTER_KEY_C]: "c",
+  [FENSTER_KEY_D]: "d",
+  [FENSTER_KEY_E]: "e",
+  [FENSTER_KEY_F]: "f",
+  [FENSTER_KEY_G]: "g",
+  [FENSTER_KEY_H]: "h",
+  [FENSTER_KEY_I]: "i",
+  [FENSTER_KEY_J]: "j",
+  [FENSTER_KEY_K]: "k",
+  [FENSTER_KEY_L]: "l",
+  [FENSTER_KEY_M]: "m",
+  [FENSTER_KEY_N]: "n",
+  [FENSTER_KEY_O]: "o",
+  [FENSTER_KEY_P]: "p",
+  [FENSTER_KEY_Q]: "q",
+  [FENSTER_KEY_R]: "r",
+  [FENSTER_KEY_S]: "s",
+  [FENSTER_KEY_T]: "t",
+  [FENSTER_KEY_U]: "u",
+  [FENSTER_KEY_V]: "v",
+  [FENSTER_KEY_W]: "w",
+  [FENSTER_KEY_X]: "x",
+  [FENSTER_KEY_Y]: "y",
+  [FENSTER_KEY_Z]: "z",
+  // Digits (0-9)
+  [FENSTER_KEY_0]: "0",
+  [FENSTER_KEY_1]: "1",
+  [FENSTER_KEY_2]: "2",
+  [FENSTER_KEY_3]: "3",
+  [FENSTER_KEY_4]: "4",
+  [FENSTER_KEY_5]: "5",
+  [FENSTER_KEY_6]: "6",
+  [FENSTER_KEY_7]: "7",
+  [FENSTER_KEY_8]: "8",
+  [FENSTER_KEY_9]: "9",
+  // Symbols (unshifted)
+  [FENSTER_KEY_APOSTROPHE]: "'",
+  [FENSTER_KEY_COMMA]: ",",
+  [FENSTER_KEY_MINUS]: "-",
+  [FENSTER_KEY_PERIOD]: ".",
+  [FENSTER_KEY_SLASH]: "/",
+  [FENSTER_KEY_SEMICOLON]: ";",
+  [FENSTER_KEY_EQUAL]: "=",
+  [FENSTER_KEY_BRACKET_LEFT]: "[",
+  [FENSTER_KEY_BACKSLASH]: "\\",
+  [FENSTER_KEY_BRACKET_RIGHT]: "]",
+  [FENSTER_KEY_GRAVE]: "`",
+  // Modifier keys (left/right)
+  [FENSTER_KEY_SHIFT_LEFT]: "Shift",
+  [FENSTER_KEY_SHIFT_RIGHT]: "Shift",
+  [FENSTER_KEY_CONTROL_LEFT]: "Control",
+  [FENSTER_KEY_CONTROL_RIGHT]: "Control",
+  [FENSTER_KEY_ALT_LEFT]: "Alt",
+  [FENSTER_KEY_ALT_RIGHT]: "Alt",
+  [FENSTER_KEY_META_LEFT]: "Meta",
+  [FENSTER_KEY_META_RIGHT]: "Meta"
+};
+var SHIFTED_KEY = {
+  // Letters (a-z → A-Z)
+  [FENSTER_KEY_A]: "A",
+  [FENSTER_KEY_B]: "B",
+  [FENSTER_KEY_C]: "C",
+  [FENSTER_KEY_D]: "D",
+  [FENSTER_KEY_E]: "E",
+  [FENSTER_KEY_F]: "F",
+  [FENSTER_KEY_G]: "G",
+  [FENSTER_KEY_H]: "H",
+  [FENSTER_KEY_I]: "I",
+  [FENSTER_KEY_J]: "J",
+  [FENSTER_KEY_K]: "K",
+  [FENSTER_KEY_L]: "L",
+  [FENSTER_KEY_M]: "M",
+  [FENSTER_KEY_N]: "N",
+  [FENSTER_KEY_O]: "O",
+  [FENSTER_KEY_P]: "P",
+  [FENSTER_KEY_Q]: "Q",
+  [FENSTER_KEY_R]: "R",
+  [FENSTER_KEY_S]: "S",
+  [FENSTER_KEY_T]: "T",
+  [FENSTER_KEY_U]: "U",
+  [FENSTER_KEY_V]: "V",
+  [FENSTER_KEY_W]: "W",
+  [FENSTER_KEY_X]: "X",
+  [FENSTER_KEY_Y]: "Y",
+  [FENSTER_KEY_Z]: "Z",
+  // Digits (0-9 → shifted symbols)
+  [FENSTER_KEY_0]: ")",
+  [FENSTER_KEY_1]: "!",
+  [FENSTER_KEY_2]: "@",
+  [FENSTER_KEY_3]: "#",
+  [FENSTER_KEY_4]: "$",
+  [FENSTER_KEY_5]: "%",
+  [FENSTER_KEY_6]: "^",
+  [FENSTER_KEY_7]: "&",
+  [FENSTER_KEY_8]: "*",
+  [FENSTER_KEY_9]: "(",
+  // Symbols (shifted)
+  [FENSTER_KEY_APOSTROPHE]: '"',
+  [FENSTER_KEY_COMMA]: "<",
+  [FENSTER_KEY_MINUS]: "_",
+  [FENSTER_KEY_PERIOD]: ">",
+  [FENSTER_KEY_SLASH]: "?",
+  [FENSTER_KEY_SEMICOLON]: ":",
+  [FENSTER_KEY_EQUAL]: "+",
+  [FENSTER_KEY_BRACKET_LEFT]: "{",
+  [FENSTER_KEY_BACKSLASH]: "|",
+  [FENSTER_KEY_BRACKET_RIGHT]: "}",
+  [FENSTER_KEY_GRAVE]: "~"
+};
+
+// src/KeyboardEvent/types.ts
+import { isBoolean, isPlainObject, isString } from "remeda";
+var isNativeKeyboardEvent = (value) => {
+  if (!isPlainObject(value)) {
+    return false;
+  }
+  return isString(value["key"]) && isString(value["code"]) && isBoolean(value["ctrlKey"]) && isBoolean(value["shiftKey"]) && isBoolean(value["altKey"]) && isBoolean(value["metaKey"]) && value["repeat"] === false && (value["type"] === "keydown" || value["type"] === "keyup");
+};
+
+// src/KeyboardEvent/index.ts
+var createKeyboardEvent = (event, mod) => {
+  const code = FENSTER_TO_CODE[event.keyIndex];
+  if (code === void 0) {
+    return null;
+  }
+  const shiftKey = (mod & FENSTER_MOD_SHIFT) !== 0;
+  const key = (shiftKey ? SHIFTED_KEY[event.keyIndex] : void 0) ?? FENSTER_TO_KEY[event.keyIndex];
+  if (key === void 0) {
+    return null;
+  }
+  return {
+    key,
+    code,
+    ctrlKey: (mod & FENSTER_MOD_CTRL) !== 0,
+    shiftKey,
+    altKey: (mod & FENSTER_MOD_ALT) !== 0,
+    metaKey: (mod & FENSTER_MOD_META) !== 0,
+    repeat: false,
+    type: event.pressed ? "keydown" : "keyup"
+  };
+};
+
 // src/OutputStream/index.ts
 import { Writable } from "stream";
-import { isString } from "remeda";
+import { isString as isString2 } from "remeda";
 
 // src/OutputStream/consts.ts
 var DEFAULT_COLUMNS = 80;
@@ -124178,7 +124475,7 @@ var OutputStream = class extends Writable {
    */
   _write(chunk, _encoding, callback) {
     try {
-      const text = isString(chunk) ? chunk : chunk.toString("utf8");
+      const text = isString2(chunk) ? chunk : chunk.toString("utf8");
       this.uiRenderer.processAnsi(text);
       this.uiRenderer.present();
       callback(null);
@@ -124233,9 +124530,53 @@ var FENSTER_REFRESH_RATE = 60;
 var ALPHA_MASK = 4278190080;
 var RED_SHIFT = 16;
 var GREEN_SHIFT = 8;
-var CTRL_KEY_OFFSET = 96;
+var CTRL_KEY_OFFSET = 64;
 var ASCII_PRINTABLE_START = 32;
 var ASCII_PRINTABLE_END = 126;
+var SHIFTED_SYMBOLS = {
+  48: ")",
+  // 0 → )
+  49: "!",
+  // 1 → !
+  50: "@",
+  // 2 → @
+  51: "#",
+  // 3 → #
+  52: "$",
+  // 4 → $
+  53: "%",
+  // 5 → %
+  54: "^",
+  // 6 → ^
+  55: "&",
+  // 7 → &
+  56: "*",
+  // 8 → *
+  57: "(",
+  // 9 → (
+  45: "_",
+  // - → _
+  61: "+",
+  // = → +
+  91: "{",
+  // [ → {
+  93: "}",
+  // ] → }
+  92: "|",
+  // \ → |
+  59: ":",
+  // ; → :
+  39: '"',
+  // ' → "
+  96: "~",
+  // ` → ~
+  44: "<",
+  // , → <
+  46: ">",
+  // . → >
+  47: "?"
+  // / → ?
+};
 
 // src/UiRenderer/index.ts
 var packColor = (r, g, b) => (ALPHA_MASK | r << RED_SHIFT | g << GREEN_SHIFT | b) >>> 0;
@@ -124471,6 +124812,8 @@ var UiRenderer = class {
         return shift ? "\x1B[Z" : "	";
       case FENSTER_KEY_DELETE:
         return "\x1B[3~";
+      case FENSTER_KEY_INSERT:
+        return "\x1B[2~";
       case FENSTER_KEY_SPACE:
         return ctrl ? "\0" : " ";
     }
@@ -124489,11 +124832,16 @@ var UiRenderer = class {
       }
     }
     if (key >= ASCII_PRINTABLE_START && key <= ASCII_PRINTABLE_END) {
-      let char = String.fromCharCode(key);
-      if (shift && key >= FENSTER_KEY_A && key <= FENSTER_KEY_Z) {
-        char = char.toUpperCase();
+      if (key >= FENSTER_KEY_A && key <= FENSTER_KEY_Z) {
+        return shift ? String.fromCharCode(key) : String.fromCharCode(key).toLowerCase();
+      }
+      if (shift) {
+        const shifted = SHIFTED_SYMBOLS[key];
+        if (shifted) {
+          return shifted;
+        }
       }
-      return char;
+      return String.fromCharCode(key);
     }
     return null;
   }
@@ -124771,22 +125119,36 @@ var Window = class extends EventEmitter {
     }
     const { keyEvents, mod, resized } = this.renderer.processEventsAndPresent();
     for (const event of keyEvents) {
-      const sequence = this.renderer.keyEventToSequence(event, mod);
-      if (sequence) {
-        if (sequence === "") {
-          if (this.listenerCount("sigint") > 0) {
-            this.emit("sigint");
-          } else {
-            process.kill(process.pid, "SIGINT");
+      const kbEvent = createKeyboardEvent(event, mod);
+      if (event.pressed) {
+        const sequence = this.renderer.keyEventToSequence(event, mod);
+        if (sequence) {
+          if (sequence === "") {
+            if (this.listenerCount("sigint") > 0) {
+              this.emit("sigint");
+            } else {
+              process.kill(process.pid, "SIGINT");
+            }
+            if (kbEvent) {
+              this.emit("keydown", kbEvent);
+            }
+            continue;
           }
-          continue;
+          if (!this.paused) {
+            this.inputStream.pushKey(sequence);
+          }
+        }
+        if (kbEvent) {
+          this.emit("keydown", kbEvent);
         }
-        this.inputStream.pushKey(sequence);
-        this.emit("key", event);
+      } else if (kbEvent) {
+        this.emit("keyup", kbEvent);
       }
     }
     if (resized) {
-      this.outputStream.notifyResize();
+      if (!this.paused) {
+        this.outputStream.notifyResize();
+      }
       this.emit("resize", this.renderer.getDimensions());
     }
     if (this.renderer.shouldClose()) {
@@ -124829,30 +125191,35 @@ var Window = class extends EventEmitter {
     return this.closed;
   }
   /**
-   * Pause the Ink event loop so the caller can take over rendering.
+   * Process pending events and present the framebuffer.
    *
-   * While paused, call `renderer.processEventsAndPresent()` manually
-   * in your own loop to poll events and present the framebuffer.
+   * Call this from your own render loop when the event loop is paused.
+   * Polls OS events, emits keydown/keyup, handles resize and close —
+   * equivalent to what the internal event loop does each iteration.
+   */
+  processEvents() {
+    this.runEventLoopIteration();
+  }
+  /**
+   * Pause Ink so the caller can take over rendering.
+   *
+   * The event loop keeps running — keydown, keyup, resize, and close
+   * events continue to fire. Only Ink's input stream is paused.
    */
   pause() {
     if (this.paused) {
       return;
     }
     this.paused = true;
-    if (this.eventLoopHandle) {
-      clearInterval(this.eventLoopHandle);
-      this.eventLoopHandle = null;
-    }
   }
   /**
-   * Resume the Ink event loop after pausing.
+   * Resume Ink after pausing.
    */
   resume() {
     if (!this.paused) {
       return;
     }
     this.paused = false;
-    this.startEventLoop();
   }
   /**
    * Check if the event loop is paused
@@ -124907,6 +125274,8 @@ export {
   getFenster,
   isFensterAvailable,
   InputStream,
+  isNativeKeyboardEvent,
+  createKeyboardEvent,
   OutputStream,
   packColor,
   UiRenderer,

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   createStreams
-} from "./chunk-3NCUBVFY.js";
+} from "./chunk-FE3HR4I4.js";
 
 // src/cli.tsx
 import { parseArgs } from "util";

package/dist/index.d.ts

@@ -324,6 +324,36 @@ declare class InputStream extends Readable {
     unref(): this;
 }
 
+/** Keyboard event from the native window */
+interface NativeKeyboardEvent {
+    /** Key value: "a", "A", "Enter", "ArrowUp", "!" */
+    readonly key: string;
+    /** Physical key code: "KeyA", "Digit1", "ArrowUp" */
+    readonly code: string;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly metaKey: boolean;
+    /** Always false — fenster only reports transitions, not held state */
+    readonly repeat: false;
+    readonly type: "keydown" | "keyup";
+}
+declare const isNativeKeyboardEvent: (value: unknown) => value is NativeKeyboardEvent;
+
+/**
+ * KeyboardEvent
+ *
+ * Converts fenster key events into NativeKeyboardEvent objects,
+ * providing keydown/keyup events for games and interactive apps.
+ */
+
+/**
+ * Create a NativeKeyboardEvent from a fenster key event and modifier bitmask.
+ *
+ * Returns null for unmapped key indices.
+ */
+declare const createKeyboardEvent: (event: FensterKeyEvent, mod: number) => NativeKeyboardEvent | null;
+
 /**
  * OutputStream Types
  */
@@ -659,14 +689,22 @@ declare class Window extends EventEmitter {
      */
     isClosed(): boolean;
     /**
-     * Pause the Ink event loop so the caller can take over rendering.
+     * Process pending events and present the framebuffer.
+     *
+     * Call this from your own render loop when the event loop is paused.
+     * Polls OS events, emits keydown/keyup, handles resize and close —
+     * equivalent to what the internal event loop does each iteration.
+     */
+    processEvents(): void;
+    /**
+     * Pause Ink so the caller can take over rendering.
      *
-     * While paused, call `renderer.processEventsAndPresent()` manually
-     * in your own loop to poll events and present the framebuffer.
+     * The event loop keeps running — keydown, keyup, resize, and close
+     * events continue to fire. Only Ink's input stream is paused.
      */
     pause(): void;
     /**
-     * Resume the Ink event loop after pausing.
+     * Resume Ink after pausing.
      */
     resume(): void;
     /**
@@ -711,4 +749,4 @@ declare class Window extends EventEmitter {
  */
 declare const createStreams: (options?: StreamsOptions) => Streams;
 
-export { AnsiParser, BitmapFontRenderer, type Color, type DrawCommand, Fenster, type FensterKeyEvent, type FensterPointer, type Framebuffer, InputStream, OutputStream, type ProcessEventsResult, type Streams, type StreamsOptions, UiRenderer, type UiRendererOptions, Window, createStreams, getFenster, isFensterAvailable, packColor };
+export { AnsiParser, BitmapFontRenderer, type Color, type DrawCommand, Fenster, type FensterKeyEvent, type FensterPointer, type Framebuffer, InputStream, type NativeKeyboardEvent, OutputStream, type ProcessEventsResult, type Streams, type StreamsOptions, UiRenderer, type UiRendererOptions, Window, createKeyboardEvent, createStreams, getFenster, isFensterAvailable, isNativeKeyboardEvent, packColor };

package/dist/index.js

@@ -6,11 +6,13 @@ import {
   OutputStream,
   UiRenderer,
   Window,
+  createKeyboardEvent,
   createStreams,
   getFenster,
   isFensterAvailable,
+  isNativeKeyboardEvent,
   packColor
-} from "./chunk-3NCUBVFY.js";
+} from "./chunk-FE3HR4I4.js";
 export {
   AnsiParser,
   BitmapFontRenderer,
@@ -19,8 +21,10 @@ export {
   OutputStream,
   UiRenderer,
   Window,
+  createKeyboardEvent,
   createStreams,
   getFenster,
   isFensterAvailable,
+  isNativeKeyboardEvent,
   packColor
 };

package/native/fenster.h

@@ -172,6 +172,24 @@ FENSTER_API int fenster_loop(struct fenster *f) {
     f->mod = (mod & 0xc) | ((mod & 1) << 1) | ((mod >> 1) & 1);
     return 0;
   }
+  case 12: { /* NSEventTypeFlagsChanged — modifier key press/release */
+    NSUInteger k = msg(NSUInteger, ev, "keyCode");
+    NSUInteger flags = msg(NSUInteger, ev, "modifierFlags");
+    NSUInteger mod = flags >> 17;
+    f->mod = (mod & 0xc) | ((mod & 1) << 1) | ((mod >> 1) & 1);
+    /* Device-dependent flags distinguish left/right modifiers */
+    switch (k) {
+    case 56: f->keys[128] = !!(flags & 0x00000002); break; /* Left Shift */
+    case 60: f->keys[129] = !!(flags & 0x00000004); break; /* Right Shift */
+    case 59: f->keys[130] = !!(flags & 0x00000001); break; /* Left Control */
+    case 62: f->keys[131] = !!(flags & 0x00002000); break; /* Right Control */
+    case 58: f->keys[132] = !!(flags & 0x00000020); break; /* Left Alt */
+    case 61: f->keys[133] = !!(flags & 0x00000040); break; /* Right Alt */
+    case 55: f->keys[134] = !!(flags & 0x00000008); break; /* Left Meta */
+    case 54: f->keys[135] = !!(flags & 0x00000010); break; /* Right Meta */
+    }
+    return 0;
+  }
   }
   msg1(void, NSApp, "sendEvent:", id, ev);
   /* Poll content view frame for resize */
@@ -240,7 +258,17 @@ static LRESULT CALLBACK fenster_wndproc(HWND hwnd, UINT msg, WPARAM wParam,
              ((GetKeyState(VK_SHIFT) & 0x8000) >> 14) |
              ((GetKeyState(VK_MENU) & 0x8000) >> 13) |
              (((GetKeyState(VK_LWIN) | GetKeyState(VK_RWIN)) & 0x8000) >> 12);
-    f->keys[FENSTER_KEYCODES[HIWORD(lParam) & 0x1ff]] = !((lParam >> 31) & 1);
+    int pressed = !((lParam >> 31) & 1);
+    f->keys[FENSTER_KEYCODES[HIWORD(lParam) & 0x1ff]] = pressed;
+    /* Left/right modifier key tracking */
+    f->keys[128] = !!(GetKeyState(VK_LSHIFT) & 0x8000);
+    f->keys[129] = !!(GetKeyState(VK_RSHIFT) & 0x8000);
+    f->keys[130] = !!(GetKeyState(VK_LCONTROL) & 0x8000);
+    f->keys[131] = !!(GetKeyState(VK_RCONTROL) & 0x8000);
+    f->keys[132] = !!(GetKeyState(VK_LMENU) & 0x8000);
+    f->keys[133] = !!(GetKeyState(VK_RMENU) & 0x8000);
+    f->keys[134] = !!(GetKeyState(VK_LWIN) & 0x8000);
+    f->keys[135] = !!(GetKeyState(VK_RWIN) & 0x8000);
   } break;
   case WM_SIZE:
     f->width = LOWORD(lParam);
@@ -320,7 +348,7 @@ FENSTER_API int fenster_loop(struct fenster *f) {
 }
 #else
 // clang-format off
-static int FENSTER_KEYCODES[124] = {XK_BackSpace,8,XK_Delete,127,XK_Down,18,XK_End,5,XK_Escape,27,XK_Home,2,XK_Insert,26,XK_Left,20,XK_Page_Down,4,XK_Page_Up,3,XK_Return,10,XK_Right,19,XK_Tab,9,XK_Up,17,XK_apostrophe,39,XK_backslash,92,XK_bracketleft,91,XK_bracketright,93,XK_comma,44,XK_equal,61,XK_grave,96,XK_minus,45,XK_period,46,XK_semicolon,59,XK_slash,47,XK_space,32,XK_a,65,XK_b,66,XK_c,67,XK_d,68,XK_e,69,XK_f,70,XK_g,71,XK_h,72,XK_i,73,XK_j,74,XK_k,75,XK_l,76,XK_m,77,XK_n,78,XK_o,79,XK_p,80,XK_q,81,XK_r,82,XK_s,83,XK_t,84,XK_u,85,XK_v,86,XK_w,87,XK_x,88,XK_y,89,XK_z,90,XK_0,48,XK_1,49,XK_2,50,XK_3,51,XK_4,52,XK_5,53,XK_6,54,XK_7,55,XK_8,56,XK_9,57};
+static int FENSTER_KEYCODES[140] = {XK_BackSpace,8,XK_Delete,127,XK_Down,18,XK_End,5,XK_Escape,27,XK_Home,2,XK_Insert,26,XK_Left,20,XK_Page_Down,4,XK_Page_Up,3,XK_Return,10,XK_Right,19,XK_Tab,9,XK_Up,17,XK_apostrophe,39,XK_backslash,92,XK_bracketleft,91,XK_bracketright,93,XK_comma,44,XK_equal,61,XK_grave,96,XK_minus,45,XK_period,46,XK_semicolon,59,XK_slash,47,XK_space,32,XK_a,65,XK_b,66,XK_c,67,XK_d,68,XK_e,69,XK_f,70,XK_g,71,XK_h,72,XK_i,73,XK_j,74,XK_k,75,XK_l,76,XK_m,77,XK_n,78,XK_o,79,XK_p,80,XK_q,81,XK_r,82,XK_s,83,XK_t,84,XK_u,85,XK_v,86,XK_w,87,XK_x,88,XK_y,89,XK_z,90,XK_0,48,XK_1,49,XK_2,50,XK_3,51,XK_4,52,XK_5,53,XK_6,54,XK_7,55,XK_8,56,XK_9,57,XK_Shift_L,128,XK_Shift_R,129,XK_Control_L,130,XK_Control_R,131,XK_Alt_L,132,XK_Alt_R,133,XK_Super_L,134,XK_Super_R,135};
 // clang-format on
 FENSTER_API int fenster_open(struct fenster *f) {
   f->dpy = XOpenDisplay(NULL);
@@ -363,7 +391,7 @@ FENSTER_API int fenster_loop(struct fenster *f) {
     case KeyRelease: {
       int m = ev.xkey.state;
       int k = XkbKeycodeToKeysym(f->dpy, ev.xkey.keycode, 0, 0);
-      for (unsigned int i = 0; i < 124; i += 2) {
+      for (unsigned int i = 0; i < 140; i += 2) {
         if (FENSTER_KEYCODES[i] == k) {
           f->keys[FENSTER_KEYCODES[i + 1]] = (ev.type == KeyPress);
           break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ink-native",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Render Ink terminal apps in a native window",
   "type": "module",
   "main": "dist/index.js",
@@ -9,7 +9,8 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    }
+    },
+    "./native/*": "./native/*"
   },
   "bin": {
     "ink-native": "./dist/cli.js"