ink-sdl 0.1.0

package/dist/index.js

@@ -0,0 +1,2280 @@
+// src/streams/index.ts
+import { EventEmitter } from "events";
+
+// src/sdl/index.ts
+import koffi from "koffi";
+import { platform } from "os";
+import { existsSync } from "fs";
+
+// src/sdl/consts.ts
+var SDL_INIT_VIDEO = 32;
+var SDL_INIT_EVENTS = 16384;
+var SDL_WINDOW_SHOWN = 4;
+var SDL_WINDOW_RESIZABLE = 32;
+var SDL_WINDOW_ALLOW_HIGHDPI = 8192;
+var SDL_WINDOWPOS_CENTERED = 805240832;
+var SDL_RENDERER_ACCELERATED = 2;
+var SDL_RENDERER_PRESENTVSYNC = 4;
+var SDL_RENDERER_SOFTWARE = 1;
+var SDL_BLENDMODE_BLEND = 1;
+var SDL_QUIT = 256;
+var SDL_WINDOWEVENT = 512;
+var SDL_KEYDOWN = 768;
+var SDL_KEYUP = 769;
+var SDL_WINDOWEVENT_SIZE_CHANGED = 6;
+var SDL_WINDOWEVENT_CLOSE = 14;
+var SDLK_RETURN = 13;
+var SDLK_ESCAPE = 27;
+var SDLK_SPACE = 32;
+var SDLK_BACKSPACE = 8;
+var SDLK_TAB = 9;
+var SDLK_DELETE = 127;
+var SDLK_RIGHT = 1073741903;
+var SDLK_LEFT = 1073741904;
+var SDLK_DOWN = 1073741905;
+var SDLK_UP = 1073741906;
+var SDLK_HOME = 1073741898;
+var SDLK_END = 1073741901;
+var SDLK_PAGEUP = 1073741899;
+var SDLK_PAGEDOWN = 1073741902;
+var SDLK_F1 = 1073741882;
+var SDLK_F12 = 1073741893;
+var SDLK_LSHIFT = 1073742049;
+var SDLK_RSHIFT = 1073742053;
+var SDLK_LCTRL = 1073742048;
+var SDLK_RCTRL = 1073742052;
+var SDLK_LALT = 1073742050;
+var SDLK_RALT = 1073742054;
+var INT32_BYTES = 4;
+var SDL_RECT_SIZE = 16;
+var SDL_RECT_X_OFFSET = 0;
+var SDL_RECT_Y_OFFSET = 4;
+var SDL_RECT_W_OFFSET = 8;
+var SDL_RECT_H_OFFSET = 12;
+var SDL_EVENT_SIZE = 56;
+var SDL_WINDOW_EVENT_OFFSET = 12;
+var SDL_KEY_STATE_OFFSET = 12;
+var SDL_KEY_REPEAT_OFFSET = 13;
+var SDL_KEYSYM_SYM_OFFSET = 20;
+var ASCII_A_LOWER = 97;
+var ASCII_Z_LOWER = 122;
+
+// src/sdl/index.ts
+var SDL_LIB_PATHS = {
+  darwin: [
+    "/opt/homebrew/lib/libSDL2.dylib",
+    // Homebrew ARM
+    "/usr/local/lib/libSDL2.dylib",
+    // Homebrew Intel
+    "/opt/local/lib/libSDL2.dylib",
+    // MacPorts
+    "libSDL2.dylib"
+    // System path
+  ],
+  linux: [
+    "/usr/lib/x86_64-linux-gnu/libSDL2-2.0.so.0",
+    // Debian/Ubuntu x64
+    "/usr/lib/aarch64-linux-gnu/libSDL2-2.0.so.0",
+    // Debian/Ubuntu ARM64
+    "/usr/lib64/libSDL2-2.0.so.0",
+    // Fedora/RHEL
+    "/usr/lib/libSDL2-2.0.so.0",
+    // Arch
+    "libSDL2-2.0.so.0"
+    // System path
+  ],
+  win32: ["SDL2.dll", "C:\\Windows\\System32\\SDL2.dll"]
+};
+var SDL_TTF_LIB_PATHS = {
+  darwin: [
+    "/opt/homebrew/lib/libSDL2_ttf.dylib",
+    // Homebrew ARM
+    "/usr/local/lib/libSDL2_ttf.dylib",
+    // Homebrew Intel
+    "/opt/local/lib/libSDL2_ttf.dylib",
+    // MacPorts
+    "libSDL2_ttf.dylib"
+    // System path
+  ],
+  linux: [
+    "/usr/lib/x86_64-linux-gnu/libSDL2_ttf-2.0.so.0",
+    // Debian/Ubuntu x64
+    "/usr/lib/aarch64-linux-gnu/libSDL2_ttf-2.0.so.0",
+    // Debian/Ubuntu ARM64
+    "/usr/lib64/libSDL2_ttf-2.0.so.0",
+    // Fedora/RHEL
+    "/usr/lib/libSDL2_ttf-2.0.so.0",
+    // Arch
+    "libSDL2_ttf-2.0.so.0"
+    // System path
+  ],
+  win32: ["SDL2_ttf.dll", "C:\\Windows\\System32\\SDL2_ttf.dll"]
+};
+var findLibrary = (pathMap) => {
+  const plat = platform();
+  const paths = pathMap[plat] ?? [];
+  for (const path of paths) {
+    if (!path.includes("/") && !path.includes("\\")) {
+      return path;
+    }
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return paths[paths.length - 1] ?? null;
+};
+var findSDLLibrary = () => {
+  return findLibrary(SDL_LIB_PATHS);
+};
+var findSDLTtfLibrary = () => {
+  return findLibrary(SDL_TTF_LIB_PATHS);
+};
+var SDL2API = class {
+  lib;
+  initialized = false;
+  // Core functions
+  _SDL_Init;
+  _SDL_Quit;
+  _SDL_GetError;
+  // Window functions
+  _SDL_CreateWindow;
+  _SDL_DestroyWindow;
+  _SDL_SetWindowTitle;
+  _SDL_GetWindowSize;
+  _SDL_RaiseWindow;
+  // Renderer functions
+  _SDL_CreateRenderer;
+  _SDL_DestroyRenderer;
+  _SDL_RenderClear;
+  _SDL_RenderPresent;
+  _SDL_RenderCopy;
+  _SDL_SetRenderDrawColor;
+  // Texture functions
+  _SDL_CreateTexture;
+  _SDL_DestroyTexture;
+  _SDL_UpdateTexture;
+  _SDL_CreateTextureFromSurface;
+  _SDL_SetTextureBlendMode;
+  _SDL_SetTextureColorMod;
+  // Surface functions
+  _SDL_FreeSurface;
+  // Additional renderer functions
+  _SDL_GetRendererOutputSize;
+  _SDL_RenderFillRect;
+  _SDL_SetRenderTarget;
+  // HiDPI functions
+  _SDL_GL_GetDrawableSize;
+  // Event functions
+  _SDL_PollEvent;
+  constructor() {
+    const libPath = findSDLLibrary();
+    if (!libPath) {
+      throw new Error(
+        "SDL2 library not found. Please install SDL2:\n  macOS: brew install sdl2\n  Linux: apt install libsdl2-2.0-0 (or equivalent)\n  Windows: Download SDL2.dll from libsdl.org"
+      );
+    }
+    try {
+      this.lib = koffi.load(libPath);
+      this.bindFunctions();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Failed to load SDL2 library from ${libPath}: ${message}`
+      );
+    }
+  }
+  bindFunctions() {
+    this._SDL_Init = this.lib.func("int SDL_Init(uint32_t flags)");
+    this._SDL_Quit = this.lib.func("void SDL_Quit()");
+    this._SDL_GetError = this.lib.func("const char* SDL_GetError()");
+    this._SDL_CreateWindow = this.lib.func(
+      "void* SDL_CreateWindow(const char* title, int x, int y, int w, int h, uint32_t flags)"
+    );
+    this._SDL_DestroyWindow = this.lib.func(
+      "void SDL_DestroyWindow(void* window)"
+    );
+    this._SDL_SetWindowTitle = this.lib.func(
+      "void SDL_SetWindowTitle(void* window, const char* title)"
+    );
+    this._SDL_GetWindowSize = this.lib.func(
+      "void SDL_GetWindowSize(void* window, int* w, int* h)"
+    );
+    this._SDL_RaiseWindow = this.lib.func("void SDL_RaiseWindow(void* window)");
+    this._SDL_CreateRenderer = this.lib.func(
+      "void* SDL_CreateRenderer(void* window, int index, uint32_t flags)"
+    );
+    this._SDL_DestroyRenderer = this.lib.func(
+      "void SDL_DestroyRenderer(void* renderer)"
+    );
+    this._SDL_RenderClear = this.lib.func(
+      "int SDL_RenderClear(void* renderer)"
+    );
+    this._SDL_RenderPresent = this.lib.func(
+      "void SDL_RenderPresent(void* renderer)"
+    );
+    this._SDL_RenderCopy = this.lib.func(
+      "int SDL_RenderCopy(void* renderer, void* texture, void* srcrect, void* dstrect)"
+    );
+    this._SDL_SetRenderDrawColor = this.lib.func(
+      "int SDL_SetRenderDrawColor(void* renderer, uint8_t r, uint8_t g, uint8_t b, uint8_t a)"
+    );
+    this._SDL_CreateTexture = this.lib.func(
+      "void* SDL_CreateTexture(void* renderer, uint32_t format, int access, int w, int h)"
+    );
+    this._SDL_DestroyTexture = this.lib.func(
+      "void SDL_DestroyTexture(void* texture)"
+    );
+    this._SDL_UpdateTexture = this.lib.func(
+      "int SDL_UpdateTexture(void* texture, void* rect, const void* pixels, int pitch)"
+    );
+    this._SDL_CreateTextureFromSurface = this.lib.func(
+      "void* SDL_CreateTextureFromSurface(void* renderer, void* surface)"
+    );
+    this._SDL_SetTextureBlendMode = this.lib.func(
+      "int SDL_SetTextureBlendMode(void* texture, int blendMode)"
+    );
+    this._SDL_SetTextureColorMod = this.lib.func(
+      "int SDL_SetTextureColorMod(void* texture, uint8_t r, uint8_t g, uint8_t b)"
+    );
+    this._SDL_FreeSurface = this.lib.func(
+      "void SDL_FreeSurface(void* surface)"
+    );
+    this._SDL_GetRendererOutputSize = this.lib.func(
+      "int SDL_GetRendererOutputSize(void* renderer, int* w, int* h)"
+    );
+    this._SDL_RenderFillRect = this.lib.func(
+      "int SDL_RenderFillRect(void* renderer, void* rect)"
+    );
+    this._SDL_SetRenderTarget = this.lib.func(
+      "int SDL_SetRenderTarget(void* renderer, void* texture)"
+    );
+    this._SDL_GL_GetDrawableSize = this.lib.func(
+      "void SDL_GL_GetDrawableSize(void* window, int* w, int* h)"
+    );
+    this._SDL_PollEvent = this.lib.func("int SDL_PollEvent(void* event)");
+  }
+  /**
+   * Initialize SDL with the given subsystems
+   */
+  init(flags = SDL_INIT_VIDEO | SDL_INIT_EVENTS) {
+    if (this.initialized) {
+      return true;
+    }
+    const result = this._SDL_Init(flags);
+    if (result !== 0) {
+      return false;
+    }
+    this.initialized = true;
+    return true;
+  }
+  /**
+   * Shutdown SDL
+   */
+  quit() {
+    if (this.initialized) {
+      this._SDL_Quit();
+      this.initialized = false;
+    }
+  }
+  /**
+   * Get the last SDL error message
+   */
+  getError() {
+    return this._SDL_GetError();
+  }
+  /**
+   * Create a window
+   */
+  createWindow(title, x, y, width, height, flags) {
+    const window = this._SDL_CreateWindow(title, x, y, width, height, flags);
+    if (!window) {
+      throw new Error(`SDL_CreateWindow failed: ${this._SDL_GetError()}`);
+    }
+    return window;
+  }
+  /**
+   * Destroy a window
+   */
+  destroyWindow(window) {
+    this._SDL_DestroyWindow(window);
+  }
+  /**
+   * Set window title
+   */
+  setWindowTitle(window, title) {
+    this._SDL_SetWindowTitle(window, title);
+  }
+  /**
+   * Get window size
+   */
+  getWindowSize(window) {
+    const wBuf = Buffer.alloc(INT32_BYTES);
+    const hBuf = Buffer.alloc(INT32_BYTES);
+    this._SDL_GetWindowSize(window, wBuf, hBuf);
+    return {
+      width: wBuf.readInt32LE(0),
+      height: hBuf.readInt32LE(0)
+    };
+  }
+  /**
+   * Raise window to front and give it keyboard focus
+   */
+  raiseWindow(window) {
+    this._SDL_RaiseWindow(window);
+  }
+  /**
+   * Create a renderer for a window
+   */
+  createRenderer(window, index = -1, flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC) {
+    const renderer = this._SDL_CreateRenderer(window, index, flags);
+    if (!renderer) {
+      const softwareRenderer = this._SDL_CreateRenderer(
+        window,
+        -1,
+        SDL_RENDERER_SOFTWARE
+      );
+      if (!softwareRenderer) {
+        throw new Error(`SDL_CreateRenderer failed: ${this._SDL_GetError()}`);
+      }
+      return softwareRenderer;
+    }
+    return renderer;
+  }
+  /**
+   * Destroy a renderer
+   */
+  destroyRenderer(renderer) {
+    this._SDL_DestroyRenderer(renderer);
+  }
+  /**
+   * Clear the renderer
+   */
+  renderClear(renderer) {
+    this._SDL_RenderClear(renderer);
+  }
+  /**
+   * Present the renderer (flip buffers)
+   */
+  renderPresent(renderer) {
+    this._SDL_RenderPresent(renderer);
+  }
+  /**
+   * Copy texture to renderer
+   */
+  renderCopy(renderer, texture, srcRect = null, dstRect = null) {
+    this._SDL_RenderCopy(renderer, texture, srcRect, dstRect);
+  }
+  /**
+   * Set render draw color
+   */
+  setRenderDrawColor(renderer, r, g, b, a = 255) {
+    this._SDL_SetRenderDrawColor(renderer, r, g, b, a);
+  }
+  /**
+   * Create a texture
+   */
+  createTexture(renderer, format, access, width, height) {
+    const texture = this._SDL_CreateTexture(
+      renderer,
+      format,
+      access,
+      width,
+      height
+    );
+    if (!texture) {
+      throw new Error(`SDL_CreateTexture failed: ${this._SDL_GetError()}`);
+    }
+    return texture;
+  }
+  /**
+   * Destroy a texture
+   */
+  destroyTexture(texture) {
+    this._SDL_DestroyTexture(texture);
+  }
+  /**
+   * Update texture with pixel data
+   */
+  updateTexture(texture, pixels, pitch) {
+    this._SDL_UpdateTexture(texture, null, pixels, pitch);
+  }
+  /**
+   * Create a texture from an SDL surface
+   */
+  createTextureFromSurface(renderer, surface) {
+    const texture = this._SDL_CreateTextureFromSurface(renderer, surface);
+    if (!texture) {
+      throw new Error(
+        `SDL_CreateTextureFromSurface failed: ${this._SDL_GetError()}`
+      );
+    }
+    return texture;
+  }
+  /**
+   * Set texture blend mode
+   */
+  setTextureBlendMode(texture, blendMode) {
+    this._SDL_SetTextureBlendMode(texture, blendMode);
+  }
+  /**
+   * Set texture color modulation (tint)
+   */
+  setTextureColorMod(texture, r, g, b) {
+    this._SDL_SetTextureColorMod(texture, r, g, b);
+  }
+  /**
+   * Free an SDL surface
+   */
+  freeSurface(surface) {
+    this._SDL_FreeSurface(surface);
+  }
+  /**
+   * Get the output size of a renderer (physical pixels)
+   */
+  getRendererOutputSize(renderer) {
+    const wBuf = Buffer.alloc(INT32_BYTES);
+    const hBuf = Buffer.alloc(INT32_BYTES);
+    const result = this._SDL_GetRendererOutputSize(renderer, wBuf, hBuf);
+    if (result !== 0) {
+      return { width: 0, height: 0 };
+    }
+    return {
+      width: wBuf.readInt32LE(0),
+      height: hBuf.readInt32LE(0)
+    };
+  }
+  /**
+   * Fill a rectangle with the current draw color
+   */
+  renderFillRect(renderer, rect) {
+    this._SDL_RenderFillRect(renderer, rect);
+  }
+  /**
+   * Set the render target (null for default window)
+   */
+  setRenderTarget(renderer, texture) {
+    this._SDL_SetRenderTarget(renderer, texture);
+  }
+  /**
+   * Get drawable size (physical pixels) for HiDPI windows
+   */
+  getDrawableSize(window) {
+    const wBuf = Buffer.alloc(INT32_BYTES);
+    const hBuf = Buffer.alloc(INT32_BYTES);
+    this._SDL_GL_GetDrawableSize(window, wBuf, hBuf);
+    return {
+      width: wBuf.readInt32LE(0),
+      height: hBuf.readInt32LE(0)
+    };
+  }
+  /**
+   * Get the scale factor between logical and physical pixels
+   */
+  getScaleFactor(window) {
+    const logical = this.getWindowSize(window);
+    const physical = this.getDrawableSize(window);
+    if (logical.width === 0) {
+      return 1;
+    }
+    return physical.width / logical.width;
+  }
+  /**
+   * Get the scale factor using renderer output size (more reliable for non-GL windows)
+   */
+  getScaleFactorFromRenderer(window, renderer) {
+    const logical = this.getWindowSize(window);
+    const physical = this.getRendererOutputSize(renderer);
+    if (logical.width === 0 || physical.width === 0) {
+      return 1;
+    }
+    return physical.width / logical.width;
+  }
+  /**
+   * Poll for pending events
+   */
+  pollEvent() {
+    const eventBuf = Buffer.alloc(SDL_EVENT_SIZE);
+    const hasEvent = this._SDL_PollEvent(eventBuf);
+    if (!hasEvent) {
+      return null;
+    }
+    const type = eventBuf.readUInt32LE(0);
+    if (type === SDL_WINDOWEVENT) {
+      const windowEvent = eventBuf.readUInt8(SDL_WINDOW_EVENT_OFFSET);
+      return { type, windowEvent };
+    }
+    if (type === SDL_KEYDOWN || type === SDL_KEYUP) {
+      const pressed = eventBuf.readUInt8(SDL_KEY_STATE_OFFSET) === 1;
+      const repeat = eventBuf.readUInt8(SDL_KEY_REPEAT_OFFSET) !== 0;
+      const keycode = eventBuf.readInt32LE(SDL_KEYSYM_SYM_OFFSET);
+      return { type, keycode, pressed, repeat };
+    }
+    return { type };
+  }
+  /**
+   * Check if SDL is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+var sdlInstance = null;
+var getSDL2 = () => {
+  if (!sdlInstance) {
+    sdlInstance = new SDL2API();
+  }
+  return sdlInstance;
+};
+var isSDL2Available = () => {
+  try {
+    getSDL2();
+    return true;
+  } catch {
+    return false;
+  }
+};
+var createSDLRect = (x, y, w, h) => {
+  const buf = Buffer.alloc(SDL_RECT_SIZE);
+  buf.writeInt32LE(x, SDL_RECT_X_OFFSET);
+  buf.writeInt32LE(y, SDL_RECT_Y_OFFSET);
+  buf.writeInt32LE(w, SDL_RECT_W_OFFSET);
+  buf.writeInt32LE(h, SDL_RECT_H_OFFSET);
+  return buf;
+};
+var SDL_ttfAPI = class {
+  lib;
+  initialized = false;
+  // TTF functions
+  _TTF_Init;
+  _TTF_Quit;
+  _TTF_OpenFont;
+  _TTF_CloseFont;
+  _TTF_RenderUTF8_Blended;
+  _TTF_SizeUTF8;
+  constructor() {
+    const libPath = findSDLTtfLibrary();
+    if (!libPath) {
+      throw new Error(
+        "SDL2_ttf library not found. Please install SDL2_ttf:\n  macOS: brew install sdl2_ttf\n  Linux: apt install libsdl2-ttf-2.0-0 (or equivalent)\n  Windows: Download SDL2_ttf.dll from libsdl.org"
+      );
+    }
+    try {
+      this.lib = koffi.load(libPath);
+      this.bindFunctions();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Failed to load SDL2_ttf library from ${libPath}: ${message}`
+      );
+    }
+  }
+  bindFunctions() {
+    this._TTF_Init = this.lib.func("int TTF_Init()");
+    this._TTF_Quit = this.lib.func("void TTF_Quit()");
+    this._TTF_OpenFont = this.lib.func(
+      "void* TTF_OpenFont(const char* file, int ptsize)"
+    );
+    this._TTF_CloseFont = this.lib.func("void TTF_CloseFont(void* font)");
+    koffi.struct("SDL_Color", {
+      r: "uint8_t",
+      g: "uint8_t",
+      b: "uint8_t",
+      a: "uint8_t"
+    });
+    this._TTF_RenderUTF8_Blended = this.lib.func(
+      "void* TTF_RenderUTF8_Blended(void* font, const char* text, SDL_Color fg)"
+    );
+    this._TTF_SizeUTF8 = this.lib.func(
+      "int TTF_SizeUTF8(void* font, const char* text, int* w, int* h)"
+    );
+  }
+  /**
+   * Initialize SDL_ttf
+   */
+  init() {
+    if (this.initialized) {
+      return true;
+    }
+    const result = this._TTF_Init();
+    if (result !== 0) {
+      return false;
+    }
+    this.initialized = true;
+    return true;
+  }
+  /**
+   * Shutdown SDL_ttf
+   */
+  quit() {
+    if (this.initialized) {
+      this._TTF_Quit();
+      this.initialized = false;
+    }
+  }
+  /**
+   * Get the last SDL_ttf error message
+   */
+  getError() {
+    return getSDL2().getError();
+  }
+  /**
+   * Open a TrueType font file
+   */
+  openFont(file, ptsize) {
+    const font = this._TTF_OpenFont(file, ptsize);
+    if (!font) {
+      throw new Error(`TTF_OpenFont failed: ${getSDL2().getError()}`);
+    }
+    return font;
+  }
+  /**
+   * Close a font
+   */
+  closeFont(font) {
+    this._TTF_CloseFont(font);
+  }
+  /**
+   * Render UTF-8 text to a surface with blended (anti-aliased) rendering
+   */
+  renderTextBlended(font, text, r, g, b, a = 255) {
+    const color = { r, g, b, a };
+    const surface = this._TTF_RenderUTF8_Blended(font, text, color);
+    if (!surface) {
+      throw new Error(`TTF_RenderUTF8_Blended failed: ${getSDL2().getError()}`);
+    }
+    return surface;
+  }
+  /**
+   * Get the dimensions of rendered text without actually rendering
+   */
+  sizeText(font, text) {
+    const wBuf = Buffer.alloc(INT32_BYTES);
+    const hBuf = Buffer.alloc(INT32_BYTES);
+    const result = this._TTF_SizeUTF8(font, text, wBuf, hBuf);
+    if (result !== 0) {
+      return { width: 0, height: 0 };
+    }
+    return {
+      width: wBuf.readInt32LE(0),
+      height: hBuf.readInt32LE(0)
+    };
+  }
+  /**
+   * Check if SDL_ttf is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+};
+var ttfInstance = null;
+var getSDL_ttf = () => {
+  if (!ttfInstance) {
+    ttfInstance = new SDL_ttfAPI();
+  }
+  return ttfInstance;
+};
+var isSDL_ttfAvailable = () => {
+  try {
+    getSDL_ttf();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/renderer/consts.ts
+var DEFAULT_WINDOW_WIDTH = 800;
+var DEFAULT_WINDOW_HEIGHT = 600;
+var DEFAULT_COLUMNS = 80;
+var DEFAULT_ROWS = 24;
+var MIN_COLUMNS = 40;
+var MIN_ROWS = 10;
+var DEFAULT_FONT_SIZE = 13;
+var MAX_GLYPH_CACHE_SIZE = 1e3;
+var GLYPH_CACHE_EVICT_DIVISOR = 4;
+var COLOR_CHANNEL_MAX = 255;
+var ANSI_STANDARD_COLOR_COUNT = 8;
+var BOLD_BRIGHTNESS_MULTIPLIER = 1.3;
+var DIM_BRIGHTNESS_MULTIPLIER = 0.5;
+var SCALE_FACTOR_EPSILON = 0.01;
+var ANSI_TAB_WIDTH = 8;
+var ANSI_ERASE_ENTIRE_SCREEN = 2;
+var ANSI_ERASE_TO_END_AND_BEYOND = 3;
+var ANSI_EXTENDED_COLOR_OFFSET_256 = 2;
+var ANSI_EXTENDED_RGB_MIN_PARAMS = 3;
+var ANSI_EXTENDED_COLOR_OFFSET_RGB = 4;
+var ANSI_RGB_R_OFFSET = 1;
+var ANSI_RGB_G_OFFSET = 2;
+var ANSI_RGB_B_OFFSET = 3;
+var ANSI_CUBE_RED_MULTIPLIER = 36;
+var ANSI_256_COLOR_LEVELS = 6;
+var ANSI_CUBE_STEP = 40;
+var ANSI_CUBE_BASE = 55;
+var PACK_RED_SHIFT = 16;
+var PACK_GREEN_SHIFT = 8;
+
+// src/renderer/ansi-parser.ts
+var DEFAULT_FG = { r: 255, g: 255, b: 255 };
+var DEFAULT_BG = { r: 0, g: 0, b: 0 };
+var ANSI_COLORS_NORMAL = [
+  { r: 0, g: 0, b: 0 },
+  // 0: Black
+  { r: 187, g: 0, b: 0 },
+  // 1: Red
+  { r: 0, g: 187, b: 0 },
+  // 2: Green
+  { r: 187, g: 187, b: 0 },
+  // 3: Yellow
+  { r: 0, g: 0, b: 187 },
+  // 4: Blue
+  { r: 187, g: 0, b: 187 },
+  // 5: Magenta
+  { r: 0, g: 187, b: 187 },
+  // 6: Cyan
+  { r: 187, g: 187, b: 187 }
+  // 7: White
+];
+var ANSI_COLORS_BRIGHT = [
+  { r: 85, g: 85, b: 85 },
+  // 8: Bright Black (Gray)
+  { r: 255, g: 85, b: 85 },
+  // 9: Bright Red
+  { r: 85, g: 255, b: 85 },
+  // 10: Bright Green
+  { r: 255, g: 255, b: 85 },
+  // 11: Bright Yellow
+  { r: 85, g: 85, b: 255 },
+  // 12: Bright Blue
+  { r: 255, g: 85, b: 255 },
+  // 13: Bright Magenta
+  { r: 85, g: 255, b: 255 },
+  // 14: Bright Cyan
+  { r: 255, g: 255, b: 255 }
+  // 15: Bright White
+];
+var SGR_RESET = 0;
+var SGR_BOLD = 1;
+var SGR_DIM = 2;
+var SGR_REVERSE = 7;
+var SGR_NORMAL_INTENSITY = 22;
+var SGR_NO_REVERSE = 27;
+var SGR_FG_BASE = 30;
+var SGR_FG_END = 37;
+var SGR_FG_DEFAULT = 39;
+var SGR_BG_BASE = 40;
+var SGR_BG_END = 47;
+var SGR_BG_DEFAULT = 49;
+var SGR_FG_BRIGHT_BASE = 90;
+var SGR_FG_BRIGHT_END = 97;
+var SGR_BG_BRIGHT_BASE = 100;
+var SGR_BG_BRIGHT_END = 107;
+var SGR_EXTENDED = 38;
+var SGR_EXTENDED_BG = 48;
+var EXTENDED_256 = 5;
+var EXTENDED_RGB = 2;
+var COLOR_CUBE_START = 16;
+var COLOR_CUBE_END = 231;
+var GRAYSCALE_START = 232;
+var GRAYSCALE_END = 255;
+var GRAYSCALE_STEP = 10;
+var GRAYSCALE_BASE = 8;
+var ansi256ToRgb = (index) => {
+  if (index < COLOR_CUBE_START) {
+    if (index < ANSI_STANDARD_COLOR_COUNT) {
+      return ANSI_COLORS_NORMAL[index];
+    }
+    return ANSI_COLORS_BRIGHT[index - ANSI_STANDARD_COLOR_COUNT];
+  }
+  if (index <= COLOR_CUBE_END) {
+    const cubeIndex = index - COLOR_CUBE_START;
+    const r = Math.floor(cubeIndex / ANSI_CUBE_RED_MULTIPLIER);
+    const g = Math.floor(
+      cubeIndex % ANSI_CUBE_RED_MULTIPLIER / ANSI_256_COLOR_LEVELS
+    );
+    const b = cubeIndex % ANSI_256_COLOR_LEVELS;
+    return {
+      r: r > 0 ? r * ANSI_CUBE_STEP + ANSI_CUBE_BASE : 0,
+      g: g > 0 ? g * ANSI_CUBE_STEP + ANSI_CUBE_BASE : 0,
+      b: b > 0 ? b * ANSI_CUBE_STEP + ANSI_CUBE_BASE : 0
+    };
+  }
+  if (index <= GRAYSCALE_END) {
+    const gray = (index - GRAYSCALE_START) * GRAYSCALE_STEP + GRAYSCALE_BASE;
+    return { r: gray, g: gray, b: gray };
+  }
+  return DEFAULT_FG;
+};
+var AnsiParser = class {
+  cursorRow = 1;
+  cursorCol = 1;
+  fgColor = { ...DEFAULT_FG };
+  bgColor = { ...DEFAULT_BG };
+  bold = false;
+  /**
+   * Parse an ANSI string and return draw commands
+   */
+  parse(input) {
+    const commands = [];
+    let i = 0;
+    let textBuffer = "";
+    const flushText = () => {
+      if (textBuffer.length > 0) {
+        commands.push({
+          type: "text",
+          text: textBuffer,
+          row: this.cursorRow,
+          col: this.cursorCol
+        });
+        this.cursorCol += textBuffer.length;
+        textBuffer = "";
+      }
+    };
+    while (i < input.length) {
+      const char = input[i];
+      if (char === "\x1B" && input[i + 1] === "[") {
+        flushText();
+        let j = i + 2;
+        while (j < input.length && !/[A-Za-z]/.test(input[j])) {
+          j++;
+        }
+        if (j < input.length) {
+          const sequence = input.substring(i + 2, j);
+          const command = input[j];
+          this.processEscapeSequence(sequence, command, commands);
+          i = j + 1;
+        } else {
+          i++;
+        }
+        continue;
+      }
+      if (char === "\n") {
+        flushText();
+        this.cursorRow++;
+        this.cursorCol = 1;
+        i++;
+        continue;
+      }
+      if (char === "\r") {
+        flushText();
+        this.cursorCol = 1;
+        i++;
+        continue;
+      }
+      if (char === "	") {
+        flushText();
+        const nextTab = Math.ceil(this.cursorCol / ANSI_TAB_WIDTH) * ANSI_TAB_WIDTH + 1;
+        const spaces = nextTab - this.cursorCol;
+        textBuffer = " ".repeat(spaces);
+        flushText();
+        i++;
+        continue;
+      }
+      textBuffer += char;
+      i++;
+    }
+    flushText();
+    return commands;
+  }
+  /**
+   * Process an escape sequence and emit draw commands
+   */
+  processEscapeSequence(params, command, commands) {
+    switch (command) {
+      case "H":
+      // Cursor Position (CUP)
+      case "f":
+        this.processCursorPosition(params, commands);
+        break;
+      case "J":
+        this.processEraseDisplay(params, commands);
+        break;
+      case "K":
+        this.processEraseLine(params, commands);
+        break;
+      case "m":
+        this.processSGR(params, commands);
+        break;
+      case "A":
+        this.cursorRow = Math.max(1, this.cursorRow - (parseInt(params) || 1));
+        break;
+      case "B":
+        this.cursorRow += parseInt(params) || 1;
+        break;
+      case "C":
+        this.cursorCol += parseInt(params) || 1;
+        break;
+      case "D":
+        this.cursorCol = Math.max(1, this.cursorCol - (parseInt(params) || 1));
+        break;
+      case "G":
+        this.cursorCol = parseInt(params) || 1;
+        break;
+      case "s":
+      // Save Cursor Position
+      case "u":
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   * Process cursor position sequence
+   */
+  processCursorPosition(params, commands) {
+    const parts = params.split(";");
+    this.cursorRow = parseInt(parts[0] ?? "1") || 1;
+    this.cursorCol = parseInt(parts[1] ?? "1") || 1;
+    commands.push({
+      type: "cursor_move",
+      row: this.cursorRow,
+      col: this.cursorCol
+    });
+  }
+  /**
+   * Process erase display sequence
+   */
+  processEraseDisplay(params, commands) {
+    const mode = parseInt(params) || 0;
+    if (mode === ANSI_ERASE_ENTIRE_SCREEN || mode === ANSI_ERASE_TO_END_AND_BEYOND) {
+      commands.push({ type: "clear_screen" });
+      this.cursorRow = 1;
+      this.cursorCol = 1;
+    }
+  }
+  /**
+   * Process erase line sequence
+   */
+  processEraseLine(params, commands) {
+    const mode = parseInt(params) || 0;
+    commands.push({
+      type: "clear_line",
+      row: this.cursorRow,
+      col: mode === 0 ? this.cursorCol : 1
+    });
+  }
+  /**
+   * Process SGR (Select Graphic Rendition) sequence
+   */
+  processSGR(params, commands) {
+    if (params === "" || params === "0") {
+      this.resetStyle(commands);
+      return;
+    }
+    const codes = params.split(";").map((s) => parseInt(s) || 0);
+    let i = 0;
+    while (i < codes.length) {
+      const code = codes[i];
+      if (code === SGR_RESET) {
+        this.resetStyle(commands);
+      } else if (code === SGR_BOLD) {
+        this.bold = true;
+        commands.push({ type: "set_bold", enabled: true });
+      } else if (code === SGR_DIM) {
+        commands.push({ type: "set_dim", enabled: true });
+      } else if (code === SGR_REVERSE) {
+        commands.push({ type: "set_reverse", enabled: true });
+      } else if (code === SGR_NORMAL_INTENSITY) {
+        this.bold = false;
+        commands.push({ type: "set_bold", enabled: false });
+        commands.push({ type: "set_dim", enabled: false });
+      } else if (code === SGR_NO_REVERSE) {
+        commands.push({ type: "set_reverse", enabled: false });
+      } else if (code >= SGR_FG_BASE && code <= SGR_FG_END) {
+        const colorIndex = code - SGR_FG_BASE;
+        this.fgColor = this.bold ? { ...ANSI_COLORS_BRIGHT[colorIndex] } : { ...ANSI_COLORS_NORMAL[colorIndex] };
+        commands.push({ type: "set_fg", color: { ...this.fgColor } });
+      } else if (code === SGR_FG_DEFAULT) {
+        this.fgColor = { ...DEFAULT_FG };
+        commands.push({ type: "set_fg", color: { ...this.fgColor } });
+      } else if (code >= SGR_BG_BASE && code <= SGR_BG_END) {
+        const colorIndex = code - SGR_BG_BASE;
+        this.bgColor = { ...ANSI_COLORS_NORMAL[colorIndex] };
+        commands.push({ type: "set_bg", color: { ...this.bgColor } });
+      } else if (code === SGR_BG_DEFAULT) {
+        this.bgColor = { ...DEFAULT_BG };
+        commands.push({ type: "set_bg", color: { ...this.bgColor } });
+      } else if (code >= SGR_FG_BRIGHT_BASE && code <= SGR_FG_BRIGHT_END) {
+        const colorIndex = code - SGR_FG_BRIGHT_BASE;
+        this.fgColor = { ...ANSI_COLORS_BRIGHT[colorIndex] };
+        commands.push({ type: "set_fg", color: { ...this.fgColor } });
+      } else if (code >= SGR_BG_BRIGHT_BASE && code <= SGR_BG_BRIGHT_END) {
+        const colorIndex = code - SGR_BG_BRIGHT_BASE;
+        this.bgColor = { ...ANSI_COLORS_BRIGHT[colorIndex] };
+        commands.push({ type: "set_bg", color: { ...this.bgColor } });
+      } else if (code === SGR_EXTENDED) {
+        const result = this.parseExtendedColor(codes, i + 1);
+        if (result.color) {
+          this.fgColor = result.color;
+          commands.push({ type: "set_fg", color: { ...this.fgColor } });
+        }
+        i = result.nextIndex - 1;
+      } else if (code === SGR_EXTENDED_BG) {
+        const result = this.parseExtendedColor(codes, i + 1);
+        if (result.color) {
+          this.bgColor = result.color;
+          commands.push({ type: "set_bg", color: { ...this.bgColor } });
+        }
+        i = result.nextIndex - 1;
+      }
+      i++;
+    }
+  }
+  /**
+   * Parse extended color (256-color or 24-bit)
+   */
+  parseExtendedColor(codes, startIndex) {
+    if (startIndex >= codes.length) {
+      return { color: null, nextIndex: startIndex };
+    }
+    const mode = codes[startIndex];
+    if (mode === EXTENDED_256 && startIndex + ANSI_RGB_R_OFFSET < codes.length) {
+      const colorIndex = codes[startIndex + ANSI_RGB_R_OFFSET];
+      return {
+        color: ansi256ToRgb(colorIndex),
+        nextIndex: startIndex + ANSI_EXTENDED_COLOR_OFFSET_256
+      };
+    }
+    if (mode === EXTENDED_RGB && startIndex + ANSI_EXTENDED_RGB_MIN_PARAMS < codes.length) {
+      return {
+        color: {
+          r: Math.min(
+            COLOR_CHANNEL_MAX,
+            Math.max(0, codes[startIndex + ANSI_RGB_R_OFFSET])
+          ),
+          g: Math.min(
+            COLOR_CHANNEL_MAX,
+            Math.max(0, codes[startIndex + ANSI_RGB_G_OFFSET])
+          ),
+          b: Math.min(
+            COLOR_CHANNEL_MAX,
+            Math.max(0, codes[startIndex + ANSI_RGB_B_OFFSET])
+          )
+        },
+        nextIndex: startIndex + ANSI_EXTENDED_COLOR_OFFSET_RGB
+      };
+    }
+    return { color: null, nextIndex: startIndex + 1 };
+  }
+  /**
+   * Reset all styles to default
+   */
+  resetStyle(commands) {
+    this.fgColor = { ...DEFAULT_FG };
+    this.bgColor = { ...DEFAULT_BG };
+    this.bold = false;
+    commands.push({ type: "reset_style" });
+    commands.push({ type: "set_fg", color: { ...this.fgColor } });
+    commands.push({ type: "set_bg", color: { ...this.bgColor } });
+  }
+  /**
+   * Get current cursor position
+   */
+  getCursor() {
+    return { row: this.cursorRow, col: this.cursorCol };
+  }
+  /**
+   * Get current foreground color
+   */
+  getFgColor() {
+    return { ...this.fgColor };
+  }
+  /**
+   * Get current background color
+   */
+  getBgColor() {
+    return { ...this.bgColor };
+  }
+  /**
+   * Reset parser state
+   */
+  reset() {
+    this.cursorRow = 1;
+    this.cursorCol = 1;
+    this.fgColor = { ...DEFAULT_FG };
+    this.bgColor = { ...DEFAULT_BG };
+    this.bold = false;
+  }
+};
+
+// src/renderer/text-renderer.ts
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+var TextRenderer = class {
+  sdl = getSDL2();
+  ttf = getSDL_ttf();
+  font = null;
+  renderer;
+  baseFontSize;
+  scaleFactor;
+  glyphCache = /* @__PURE__ */ new Map();
+  accessCounter = 0;
+  charWidth = 0;
+  charHeight = 0;
+  constructor(renderer, options = {}) {
+    this.renderer = renderer;
+    this.baseFontSize = options.fontSize ?? DEFAULT_FONT_SIZE;
+    this.scaleFactor = options.scaleFactor ?? 1;
+    if (!this.ttf.isInitialized()) {
+      this.ttf.init();
+    }
+    const fontPath = options.fontPath ?? this.getDefaultFontPath();
+    this.loadFont(fontPath);
+  }
+  /**
+   * Get the path to the bundled Cozette font
+   */
+  getDefaultFontPath() {
+    const currentFilename = fileURLToPath(import.meta.url);
+    const currentDirname = dirname(currentFilename);
+    const paths = [
+      resolve(currentDirname, "../fonts/CozetteVector.ttf"),
+      // Dev path
+      resolve(currentDirname, "./fonts/CozetteVector.ttf"),
+      // Bundled (dist)
+      resolve(currentDirname, "../../src/fonts/CozetteVector.ttf")
+      // Alternate
+    ];
+    for (const p of paths) {
+      try {
+        if (existsSync2(p)) {
+          return p;
+        }
+      } catch {
+      }
+    }
+    return paths[0];
+  }
+  /**
+   * Load a TTF font at the current scaled size
+   */
+  loadFont(fontPath) {
+    if (this.font) {
+      this.ttf.closeFont(this.font);
+      this.font = null;
+    }
+    this.clearCache();
+    const physicalSize = Math.round(
+      this.baseFontSize * this.scaleFactor * this.scaleFactor
+    );
+    this.font = this.ttf.openFont(fontPath, physicalSize);
+    const dims = this.ttf.sizeText(this.font, "M");
+    this.charWidth = dims.width;
+    this.charHeight = dims.height;
+  }
+  /**
+   * Update scale factor (for HiDPI display changes)
+   */
+  updateScaleFactor(scaleFactor) {
+    if (Math.abs(scaleFactor - this.scaleFactor) < SCALE_FACTOR_EPSILON) {
+      return;
+    }
+    this.scaleFactor = scaleFactor;
+    const fontPath = this.getDefaultFontPath();
+    this.loadFont(fontPath);
+  }
+  /**
+   * Get character dimensions
+   */
+  getCharDimensions() {
+    return { width: this.charWidth, height: this.charHeight };
+  }
+  /**
+   * Generate cache key for a glyph
+   */
+  getCacheKey(char, r, g, b) {
+    const packedColor = r << PACK_RED_SHIFT | g << PACK_GREEN_SHIFT | b;
+    return `${char}:${packedColor}`;
+  }
+  /**
+   * Get or create a cached glyph texture
+   */
+  getGlyph(char, r, g, b) {
+    const key = this.getCacheKey(char, r, g, b);
+    const cached = this.glyphCache.get(key);
+    if (cached) {
+      cached.lastUsed = this.accessCounter++;
+      return cached;
+    }
+    if (!this.font) {
+      return null;
+    }
+    try {
+      const surface = this.ttf.renderTextBlended(
+        this.font,
+        char,
+        COLOR_CHANNEL_MAX,
+        // White
+        COLOR_CHANNEL_MAX,
+        COLOR_CHANNEL_MAX,
+        COLOR_CHANNEL_MAX
+      );
+      const texture = this.sdl.createTextureFromSurface(this.renderer, surface);
+      this.sdl.setTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
+      this.sdl.setTextureColorMod(texture, r, g, b);
+      const dims = this.ttf.sizeText(this.font, char);
+      this.sdl.freeSurface(surface);
+      const glyph = {
+        texture,
+        width: dims.width,
+        height: dims.height,
+        lastUsed: this.accessCounter++
+      };
+      if (this.glyphCache.size >= MAX_GLYPH_CACHE_SIZE) {
+        this.evictOldGlyphs();
+      }
+      this.glyphCache.set(key, glyph);
+      return glyph;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Evict least recently used glyphs
+   */
+  evictOldGlyphs() {
+    const entries = [...this.glyphCache.entries()];
+    entries.sort((a, b) => a[1].lastUsed - b[1].lastUsed);
+    const removeCount = Math.floor(
+      MAX_GLYPH_CACHE_SIZE / GLYPH_CACHE_EVICT_DIVISOR
+    );
+    for (let i = 0; i < removeCount && i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry) {
+        const [key, glyph] = entry;
+        this.sdl.destroyTexture(glyph.texture);
+        this.glyphCache.delete(key);
+      }
+    }
+  }
+  /**
+   * Render a single character at the specified position
+   */
+  renderChar(char, x, y, color) {
+    const glyph = this.getGlyph(char, color.r, color.g, color.b);
+    if (!glyph) {
+      return;
+    }
+    const destRect = createSDLRect(x, y, glyph.width, glyph.height);
+    this.sdl.renderCopy(this.renderer, glyph.texture, null, destRect);
+  }
+  /**
+   * Render a string of text at the specified position
+   */
+  renderText(text, x, y, color) {
+    let cursorX = x;
+    for (const char of text) {
+      if (char === " ") {
+        cursorX += this.charWidth;
+        continue;
+      }
+      this.renderChar(char, cursorX, y, color);
+      cursorX += this.charWidth;
+    }
+  }
+  /**
+   * Get text dimensions
+   */
+  measureText(text) {
+    if (!this.font) {
+      return { width: 0, height: 0 };
+    }
+    return this.ttf.sizeText(this.font, text);
+  }
+  /**
+   * Clear the glyph cache
+   */
+  clearCache() {
+    for (const glyph of this.glyphCache.values()) {
+      this.sdl.destroyTexture(glyph.texture);
+    }
+    this.glyphCache.clear();
+    this.accessCounter = 0;
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.glyphCache.size,
+      maxSize: MAX_GLYPH_CACHE_SIZE
+    };
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    this.clearCache();
+    if (this.font) {
+      this.ttf.closeFont(this.font);
+      this.font = null;
+    }
+  }
+};
+
+// src/input/input-bridge.ts
+var ASCII_PRINTABLE_START = 32;
+var ASCII_PRINTABLE_END = 126;
+var CTRL_KEY_OFFSET = 96;
+var ASCII_BRACKET_OPEN = 91;
+var ASCII_BACKSLASH = 92;
+var ASCII_BRACKET_CLOSE = 93;
+var ASCII_CARET = 94;
+var ASCII_UNDERSCORE = 95;
+var FUNCTION_KEY_OFFSET_3 = 3;
+var FUNCTION_KEY_OFFSET_4 = 4;
+var FUNCTION_KEY_OFFSET_5 = 5;
+var FUNCTION_KEY_OFFSET_6 = 6;
+var FUNCTION_KEY_OFFSET_7 = 7;
+var FUNCTION_KEY_OFFSET_8 = 8;
+var FUNCTION_KEY_OFFSET_9 = 9;
+var FUNCTION_KEY_OFFSET_10 = 10;
+var InputBridge = class {
+  modifiers = {
+    shift: false,
+    ctrl: false,
+    alt: false
+  };
+  /**
+   * Process an SDL key event and return terminal sequence
+   */
+  processKeyEvent(event) {
+    const { keycode, pressed } = event;
+    if (this.isModifierKey(keycode)) {
+      this.updateModifierState(keycode, pressed);
+      return null;
+    }
+    if (!pressed) {
+      return null;
+    }
+    const specialSequence = this.getSpecialKeySequence(keycode);
+    if (specialSequence !== null) {
+      return specialSequence;
+    }
+    if (this.modifiers.ctrl) {
+      const ctrlSequence = this.getCtrlSequence(keycode);
+      if (ctrlSequence !== null) {
+        return ctrlSequence;
+      }
+    }
+    if (keycode >= ASCII_PRINTABLE_START && keycode <= ASCII_PRINTABLE_END) {
+      let char = String.fromCharCode(keycode);
+      if (this.modifiers.shift && keycode >= ASCII_A_LOWER && keycode <= ASCII_Z_LOWER) {
+        char = char.toUpperCase();
+      }
+      return char;
+    }
+    return null;
+  }
+  /**
+   * Check if a keycode is a modifier key
+   */
+  isModifierKey(keycode) {
+    return keycode === SDLK_LSHIFT || keycode === SDLK_RSHIFT || keycode === SDLK_LCTRL || keycode === SDLK_RCTRL || keycode === SDLK_LALT || keycode === SDLK_RALT;
+  }
+  /**
+   * Update modifier key state
+   */
+  updateModifierState(keycode, pressed) {
+    if (keycode === SDLK_LSHIFT || keycode === SDLK_RSHIFT) {
+      this.modifiers.shift = pressed;
+    } else if (keycode === SDLK_LCTRL || keycode === SDLK_RCTRL) {
+      this.modifiers.ctrl = pressed;
+    } else if (keycode === SDLK_LALT || keycode === SDLK_RALT) {
+      this.modifiers.alt = pressed;
+    }
+  }
+  /**
+   * Get terminal escape sequence for special keys
+   */
+  getSpecialKeySequence(keycode) {
+    switch (keycode) {
+      // Navigation keys
+      case SDLK_UP:
+        return "\x1B[A";
+      case SDLK_DOWN:
+        return "\x1B[B";
+      case SDLK_RIGHT:
+        return "\x1B[C";
+      case SDLK_LEFT:
+        return "\x1B[D";
+      case SDLK_HOME:
+        return "\x1B[H";
+      case SDLK_END:
+        return "\x1B[F";
+      case SDLK_PAGEUP:
+        return "\x1B[5~";
+      case SDLK_PAGEDOWN:
+        return "\x1B[6~";
+      // Control keys
+      case SDLK_RETURN:
+        return "\r";
+      case SDLK_ESCAPE:
+        return "\x1B";
+      case SDLK_BACKSPACE:
+        return "\x7F";
+      case SDLK_TAB:
+        return this.modifiers.shift ? "\x1B[Z" : "	";
+      case SDLK_DELETE:
+        return "\x1B[3~";
+      case SDLK_SPACE:
+        return " ";
+      // Function keys
+      case SDLK_F1:
+        return "\x1BOP";
+      case SDLK_F1 + 1:
+        return "\x1BOQ";
+      case SDLK_F1 + 2:
+        return "\x1BOR";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_3:
+        return "\x1BOS";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_4:
+        return "\x1B[15~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_5:
+        return "\x1B[17~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_6:
+        return "\x1B[18~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_7:
+        return "\x1B[19~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_8:
+        return "\x1B[20~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_9:
+        return "\x1B[21~";
+      case SDLK_F1 + FUNCTION_KEY_OFFSET_10:
+        return "\x1B[23~";
+      case SDLK_F12:
+        return "\x1B[24~";
+      default:
+        return null;
+    }
+  }
+  /**
+   * Get Ctrl+key sequence
+   */
+  getCtrlSequence(keycode) {
+    if (keycode >= ASCII_A_LOWER && keycode <= ASCII_Z_LOWER) {
+      const ctrlCode = keycode - CTRL_KEY_OFFSET;
+      return String.fromCharCode(ctrlCode);
+    }
+    switch (keycode) {
+      case SDLK_SPACE:
+        return "\0";
+      // Ctrl+Space = NUL
+      case ASCII_BRACKET_OPEN:
+        return "\x1B";
+      // Ctrl+[ = Escape
+      case ASCII_BACKSLASH:
+        return "";
+      // Ctrl+\ = FS
+      case ASCII_BRACKET_CLOSE:
+        return "";
+      // Ctrl+] = GS
+      case ASCII_CARET:
+        return "";
+      // Ctrl+^ = RS
+      case ASCII_UNDERSCORE:
+        return "";
+      // Ctrl+_ = US
+      default:
+        return null;
+    }
+  }
+  /**
+   * Convert SDL key event to Ink-style key event
+   */
+  toInkKeyEvent(event) {
+    const sequence = this.processKeyEvent(event);
+    if (sequence === null) {
+      return null;
+    }
+    let name = "";
+    if (sequence.length === 1 && sequence >= " " && sequence <= "~") {
+      name = sequence;
+    } else {
+      name = this.getKeyName(event.keycode);
+    }
+    return {
+      sequence,
+      name,
+      ctrl: this.modifiers.ctrl,
+      meta: this.modifiers.alt,
+      shift: this.modifiers.shift
+    };
+  }
+  /**
+   * Get human-readable key name
+   */
+  getKeyName(keycode) {
+    switch (keycode) {
+      case SDLK_UP:
+        return "up";
+      case SDLK_DOWN:
+        return "down";
+      case SDLK_LEFT:
+        return "left";
+      case SDLK_RIGHT:
+        return "right";
+      case SDLK_RETURN:
+        return "return";
+      case SDLK_ESCAPE:
+        return "escape";
+      case SDLK_BACKSPACE:
+        return "backspace";
+      case SDLK_TAB:
+        return "tab";
+      case SDLK_DELETE:
+        return "delete";
+      case SDLK_HOME:
+        return "home";
+      case SDLK_END:
+        return "end";
+      case SDLK_PAGEUP:
+        return "pageup";
+      case SDLK_PAGEDOWN:
+        return "pagedown";
+      default:
+        if (keycode >= SDLK_F1 && keycode <= SDLK_F12) {
+          return `f${keycode - SDLK_F1 + 1}`;
+        }
+        return "unknown";
+    }
+  }
+  /**
+   * Reset modifier state
+   */
+  reset() {
+    this.modifiers = {
+      shift: false,
+      ctrl: false,
+      alt: false
+    };
+  }
+  /**
+   * Get current modifier state
+   */
+  getModifiers() {
+    return { ...this.modifiers };
+  }
+};
+
+// src/renderer/index.ts
+var DEFAULT_BG2 = { r: 0, g: 0, b: 0 };
+var DEFAULT_FG2 = { r: 255, g: 255, b: 255 };
+var MIN_BRIGHTNESS = 100;
+var SdlUiRenderer = class {
+  sdl = getSDL2();
+  window = null;
+  renderer = null;
+  textRenderer = null;
+  ansiParser;
+  inputBridge;
+  windowWidth;
+  windowHeight;
+  columns;
+  rows;
+  charWidth = 0;
+  charHeight = 0;
+  fgColor = { ...DEFAULT_FG2 };
+  bgColor = { ...DEFAULT_BG2 };
+  bold = false;
+  dim = false;
+  reverse = false;
+  shouldQuit = false;
+  pendingCommands = [];
+  scaleFactor = 1;
+  userScaleFactor = null;
+  constructor(options = {}) {
+    this.windowWidth = options.width ?? DEFAULT_WINDOW_WIDTH;
+    this.windowHeight = options.height ?? DEFAULT_WINDOW_HEIGHT;
+    this.columns = DEFAULT_COLUMNS;
+    this.rows = DEFAULT_ROWS;
+    this.ansiParser = new AnsiParser();
+    this.inputBridge = new InputBridge();
+    this.initSDL(options);
+  }
+  /**
+   * Initialize SDL window and renderer
+   */
+  initSDL(options) {
+    if (!this.sdl.init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) {
+      throw new Error("Failed to initialize SDL2 for UI rendering");
+    }
+    this.window = this.sdl.createWindow(
+      options.title ?? "ink-sdl",
+      SDL_WINDOWPOS_CENTERED,
+      SDL_WINDOWPOS_CENTERED,
+      this.windowWidth,
+      this.windowHeight,
+      SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI
+    );
+    const rendererFlags = options.vsync !== false ? SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC : SDL_RENDERER_ACCELERATED;
+    this.renderer = this.sdl.createRenderer(this.window, -1, rendererFlags);
+    this.userScaleFactor = options.scaleFactor === void 0 ? null : options.scaleFactor;
+    if (this.userScaleFactor !== null) {
+      this.scaleFactor = this.userScaleFactor;
+    } else {
+      this.scaleFactor = this.sdl.getScaleFactorFromRenderer(
+        this.window,
+        this.renderer
+      );
+    }
+    this.textRenderer = new TextRenderer(this.renderer, {
+      fontSize: options.fontSize ?? DEFAULT_FONT_SIZE,
+      scaleFactor: this.scaleFactor
+    });
+    const charDims = this.textRenderer.getCharDimensions();
+    this.charWidth = charDims.width;
+    this.charHeight = charDims.height;
+    this.updateTerminalDimensions();
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      DEFAULT_BG2.r,
+      DEFAULT_BG2.g,
+      DEFAULT_BG2.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.renderClear(this.renderer);
+    this.sdl.renderPresent(this.renderer);
+    this.sdl.raiseWindow(this.window);
+  }
+  /**
+   * Update terminal dimensions based on window size
+   */
+  updateTerminalDimensions() {
+    if (!this.window || this.charWidth === 0 || this.charHeight === 0) {
+      return;
+    }
+    const drawable = this.sdl.getDrawableSize(this.window);
+    this.columns = Math.floor(drawable.width / this.charWidth);
+    this.rows = Math.floor(drawable.height / this.charHeight);
+    this.columns = Math.max(this.columns, MIN_COLUMNS);
+    this.rows = Math.max(this.rows, MIN_ROWS);
+  }
+  /**
+   * Get terminal dimensions
+   */
+  getDimensions() {
+    return {
+      columns: this.columns,
+      rows: this.rows
+    };
+  }
+  /**
+   * Process ANSI output from Ink
+   */
+  processAnsi(output) {
+    const commands = this.ansiParser.parse(output);
+    this.pendingCommands.push(...commands);
+  }
+  /**
+   * Render pending commands and present
+   */
+  present() {
+    if (!this.renderer || !this.textRenderer) {
+      return;
+    }
+    for (const cmd of this.pendingCommands) {
+      this.executeCommand(cmd);
+    }
+    this.pendingCommands = [];
+    this.sdl.renderPresent(this.renderer);
+  }
+  /**
+   * Execute a single draw command
+   */
+  executeCommand(cmd) {
+    switch (cmd.type) {
+      case "text":
+        this.renderText(cmd);
+        break;
+      case "clear_screen":
+        this.clear();
+        break;
+      case "clear_line":
+        this.clearLine(cmd.row ?? 1, cmd.col ?? 1);
+        break;
+      case "cursor_move":
+        break;
+      case "set_fg":
+        if (cmd.color) {
+          this.fgColor = cmd.color;
+        }
+        break;
+      case "set_bg":
+        if (cmd.color) {
+          this.bgColor = cmd.color;
+        }
+        break;
+      case "reset_style":
+        this.fgColor = { ...DEFAULT_FG2 };
+        this.bgColor = { ...DEFAULT_BG2 };
+        this.bold = false;
+        this.dim = false;
+        this.reverse = false;
+        break;
+      case "set_bold":
+        this.bold = cmd.enabled ?? false;
+        break;
+      case "set_dim":
+        this.dim = cmd.enabled ?? false;
+        break;
+      case "set_reverse":
+        this.reverse = cmd.enabled ?? false;
+        break;
+    }
+  }
+  /**
+   * Render text at position
+   */
+  renderText(cmd) {
+    if (!cmd.text || !this.renderer || !this.textRenderer) {
+      return;
+    }
+    const text = cmd.text;
+    const row = cmd.row ?? 1;
+    const col = cmd.col ?? 1;
+    const x = (col - 1) * this.charWidth;
+    const y = (row - 1) * this.charHeight;
+    let fg = this.reverse ? this.bgColor : this.fgColor;
+    const bg = this.reverse ? this.fgColor : this.bgColor;
+    if (this.bold) {
+      fg = {
+        r: Math.min(
+          COLOR_CHANNEL_MAX,
+          Math.floor(fg.r * BOLD_BRIGHTNESS_MULTIPLIER)
+        ),
+        g: Math.min(
+          COLOR_CHANNEL_MAX,
+          Math.floor(fg.g * BOLD_BRIGHTNESS_MULTIPLIER)
+        ),
+        b: Math.min(
+          COLOR_CHANNEL_MAX,
+          Math.floor(fg.b * BOLD_BRIGHTNESS_MULTIPLIER)
+        )
+      };
+    }
+    if (this.dim) {
+      fg = {
+        r: Math.floor(fg.r * DIM_BRIGHTNESS_MULTIPLIER),
+        g: Math.floor(fg.g * DIM_BRIGHTNESS_MULTIPLIER),
+        b: Math.floor(fg.b * DIM_BRIGHTNESS_MULTIPLIER)
+      };
+    }
+    const brightness = Math.max(fg.r, fg.g, fg.b);
+    if (brightness < MIN_BRIGHTNESS) {
+      if (brightness === 0) {
+        fg = { r: MIN_BRIGHTNESS, g: MIN_BRIGHTNESS, b: MIN_BRIGHTNESS };
+      } else {
+        const scale = MIN_BRIGHTNESS / brightness;
+        fg = {
+          r: Math.min(COLOR_CHANNEL_MAX, Math.floor(fg.r * scale)),
+          g: Math.min(COLOR_CHANNEL_MAX, Math.floor(fg.g * scale)),
+          b: Math.min(COLOR_CHANNEL_MAX, Math.floor(fg.b * scale))
+        };
+      }
+    }
+    const bgRect = createSDLRect(
+      x,
+      y,
+      text.length * this.charWidth,
+      this.charHeight
+    );
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      bg.r,
+      bg.g,
+      bg.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.renderFillRect(this.renderer, bgRect);
+    this.textRenderer.renderText(text, x, y, fg);
+  }
+  /**
+   * Clear the entire screen
+   */
+  clear() {
+    if (!this.renderer) {
+      return;
+    }
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      DEFAULT_BG2.r,
+      DEFAULT_BG2.g,
+      DEFAULT_BG2.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.renderClear(this.renderer);
+    this.ansiParser.reset();
+  }
+  /**
+   * Clear a line from a specific position
+   */
+  clearLine(row, fromCol) {
+    if (!this.renderer) {
+      return;
+    }
+    const x = (fromCol - 1) * this.charWidth;
+    const y = (row - 1) * this.charHeight;
+    const drawable = this.sdl.getDrawableSize(this.window);
+    const clearWidth = drawable.width - x;
+    const rect = createSDLRect(x, y, clearWidth, this.charHeight);
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      this.bgColor.r,
+      this.bgColor.g,
+      this.bgColor.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.renderFillRect(this.renderer, rect);
+  }
+  /**
+   * Process SDL events
+   */
+  processEvents() {
+    const keyEvents = [];
+    let event = this.sdl.pollEvent();
+    while (event) {
+      if (event.type === SDL_QUIT) {
+        this.shouldQuit = true;
+      } else if (event.type === SDL_WINDOWEVENT) {
+        if (event.windowEvent === SDL_WINDOWEVENT_CLOSE) {
+          this.shouldQuit = true;
+        } else if (event.windowEvent === SDL_WINDOWEVENT_SIZE_CHANGED) {
+          this.handleResize();
+        }
+      } else if (event.type === SDL_KEYDOWN || event.type === SDL_KEYUP) {
+        if (event.keycode !== void 0 && event.pressed !== void 0) {
+          keyEvents.push({
+            keycode: event.keycode,
+            pressed: event.pressed,
+            repeat: event.repeat ?? false
+          });
+        }
+      }
+      event = this.sdl.pollEvent();
+    }
+    return keyEvents;
+  }
+  /**
+   * Convert SDL key event to terminal sequence
+   */
+  keyEventToSequence(event) {
+    return this.inputBridge.processKeyEvent(event);
+  }
+  /**
+   * Handle window resize
+   */
+  handleResize() {
+    if (!this.window) {
+      return;
+    }
+    const size = this.sdl.getWindowSize(this.window);
+    this.windowWidth = size.width;
+    this.windowHeight = size.height;
+    if (this.userScaleFactor === null) {
+      const newScale = this.sdl.getScaleFactor(this.window);
+      if (Math.abs(newScale - this.scaleFactor) > SCALE_FACTOR_EPSILON) {
+        this.scaleFactor = newScale;
+        this.textRenderer?.updateScaleFactor(newScale);
+        if (this.textRenderer) {
+          const charDims = this.textRenderer.getCharDimensions();
+          this.charWidth = charDims.width;
+          this.charHeight = charDims.height;
+        }
+      }
+    }
+    this.updateTerminalDimensions();
+    this.clear();
+  }
+  /**
+   * Check if quit was requested
+   */
+  shouldClose() {
+    return this.shouldQuit;
+  }
+  /**
+   * Get cursor position
+   */
+  getCursorPos() {
+    const cursor = this.ansiParser.getCursor();
+    return { x: cursor.col, y: cursor.row };
+  }
+  /**
+   * Get the SDL window
+   */
+  getWindow() {
+    return this.window;
+  }
+  /**
+   * Get the SDL renderer
+   */
+  getRenderer() {
+    return this.renderer;
+  }
+  /**
+   * Set the scale factor
+   */
+  setScaleFactor(scaleFactor) {
+    this.userScaleFactor = scaleFactor;
+    let newScale;
+    if (scaleFactor !== null) {
+      newScale = scaleFactor;
+    } else if (this.window && this.renderer) {
+      newScale = this.sdl.getScaleFactorFromRenderer(
+        this.window,
+        this.renderer
+      );
+    } else {
+      newScale = 1;
+    }
+    if (Math.abs(newScale - this.scaleFactor) < SCALE_FACTOR_EPSILON) {
+      return;
+    }
+    this.scaleFactor = newScale;
+    if (this.textRenderer) {
+      this.textRenderer.updateScaleFactor(newScale);
+      const charDims = this.textRenderer.getCharDimensions();
+      this.charWidth = charDims.width;
+      this.charHeight = charDims.height;
+    }
+    this.updateTerminalDimensions();
+    this.clear();
+  }
+  /**
+   * Get current scale factor
+   */
+  getScaleFactor() {
+    return this.scaleFactor;
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.textRenderer) {
+      this.textRenderer.destroy();
+      this.textRenderer = null;
+    }
+    if (this.renderer) {
+      this.sdl.destroyRenderer(this.renderer);
+      this.renderer = null;
+    }
+    if (this.window) {
+      this.sdl.destroyWindow(this.window);
+      this.window = null;
+    }
+  }
+  /**
+   * Reset state for reuse
+   */
+  reset() {
+    this.shouldQuit = false;
+    this.pendingCommands = [];
+    this.fgColor = { ...DEFAULT_FG2 };
+    this.bgColor = { ...DEFAULT_BG2 };
+    this.bold = false;
+    this.dim = false;
+    this.reverse = false;
+    this.ansiParser.reset();
+    if (this.window) {
+      const size = this.sdl.getWindowSize(this.window);
+      this.windowWidth = size.width;
+      this.windowHeight = size.height;
+      this.updateTerminalDimensions();
+    }
+  }
+};
+
+// src/streams/output-stream.ts
+import { Writable } from "stream";
+var DEFAULT_COLUMNS2 = 80;
+var DEFAULT_ROWS2 = 24;
+var SdlOutputStream = class extends Writable {
+  /** TTY interface property expected by Ink */
+  isTTY = true;
+  uiRenderer;
+  constructor(uiRenderer) {
+    super({
+      decodeStrings: false
+    });
+    this.uiRenderer = uiRenderer;
+  }
+  /**
+   * Get terminal columns
+   */
+  get columns() {
+    const dims = this.uiRenderer.getDimensions();
+    return dims.columns || DEFAULT_COLUMNS2;
+  }
+  /**
+   * Get terminal rows
+   */
+  get rows() {
+    const dims = this.uiRenderer.getDimensions();
+    return dims.rows || DEFAULT_ROWS2;
+  }
+  /**
+   * Notify Ink of resize
+   */
+  notifyResize() {
+    this.emit("resize");
+  }
+  /**
+   * Implement Writable._write
+   */
+  _write(chunk, _encoding, callback) {
+    try {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      this.uiRenderer.processAnsi(text);
+      this.uiRenderer.present();
+      callback(null);
+    } catch (error) {
+      callback(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Get the underlying renderer
+   */
+  getRenderer() {
+    return this.uiRenderer;
+  }
+  /**
+   * Clear the screen
+   */
+  clear() {
+    this.uiRenderer.clear();
+  }
+  /**
+   * Write a string directly (bypasses Writable buffering)
+   */
+  writeSync(text) {
+    this.uiRenderer.processAnsi(text);
+    this.uiRenderer.present();
+  }
+  /**
+   * Get cursor position
+   */
+  getCursorPos() {
+    return this.uiRenderer.getCursorPos();
+  }
+};
+
+// src/streams/input-stream.ts
+import { Readable } from "stream";
+var SdlInputStream = class extends Readable {
+  /** TTY interface properties expected by Ink */
+  isTTY = true;
+  isRaw = true;
+  buffer = [];
+  waiting = false;
+  constructor() {
+    super({
+      encoding: "utf8"
+    });
+  }
+  /**
+   * Push a key sequence into the stream
+   */
+  pushKey(sequence) {
+    this.buffer.push(sequence);
+    if (this.waiting) {
+      this.waiting = false;
+      this._read();
+    }
+  }
+  /**
+   * Implement Readable._read
+   */
+  _read() {
+    if (this.buffer.length > 0) {
+      while (this.buffer.length > 0) {
+        const sequence = this.buffer.shift();
+        if (sequence !== void 0) {
+          this.push(sequence);
+        }
+      }
+    } else {
+      this.waiting = true;
+    }
+  }
+  /**
+   * Set raw mode (no-op for SDL, we're always raw)
+   */
+  setRawMode(_mode) {
+    return this;
+  }
+  /**
+   * Check if stream has buffered data
+   */
+  hasData() {
+    return this.buffer.length > 0;
+  }
+  /**
+   * Clear the input buffer
+   */
+  clear() {
+    this.buffer = [];
+  }
+  /**
+   * Close the stream
+   */
+  close() {
+    this.push(null);
+  }
+  /**
+   * Keep the event loop alive (no-op for SDL)
+   */
+  ref() {
+    return this;
+  }
+  /**
+   * Allow event loop to exit (no-op for SDL)
+   */
+  unref() {
+    return this;
+  }
+};
+
+// src/streams/index.ts
+var EVENT_LOOP_INTERVAL_MS = 16;
+var SdlWindow = class extends EventEmitter {
+  renderer;
+  eventLoopHandle = null;
+  inputStream;
+  outputStream;
+  closed = false;
+  constructor(renderer, inputStream, outputStream) {
+    super();
+    this.renderer = renderer;
+    this.inputStream = inputStream;
+    this.outputStream = outputStream;
+    this.startEventLoop();
+  }
+  /**
+   * Start the SDL event loop
+   */
+  startEventLoop() {
+    this.eventLoopHandle = setInterval(() => {
+      if (this.closed) {
+        return;
+      }
+      const keyEvents = this.renderer.processEvents();
+      for (const event of keyEvents) {
+        const sequence = this.renderer.keyEventToSequence(event);
+        if (sequence) {
+          this.inputStream.pushKey(sequence);
+          this.emit("key", event);
+        }
+      }
+      if (this.renderer.shouldClose()) {
+        this.emit("close");
+        this.close();
+      }
+    }, EVENT_LOOP_INTERVAL_MS);
+  }
+  /**
+   * Get terminal dimensions
+   */
+  getDimensions() {
+    return this.renderer.getDimensions();
+  }
+  /**
+   * Set window title
+   */
+  setTitle(title) {
+    const window = this.renderer.getWindow();
+    if (window) {
+      getSDL2().setWindowTitle(window, title);
+    }
+  }
+  /**
+   * Clear the screen
+   */
+  clear() {
+    this.renderer.clear();
+    this.renderer.present();
+  }
+  /**
+   * Close the window
+   */
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (this.eventLoopHandle) {
+      clearInterval(this.eventLoopHandle);
+      this.eventLoopHandle = null;
+    }
+    this.inputStream.close();
+    this.renderer.destroy();
+  }
+  /**
+   * Check if window is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * Get the output stream
+   */
+  getOutputStream() {
+    return this.outputStream;
+  }
+};
+var createSdlStreams = (options = {}) => {
+  const rendererOptions = {};
+  if (options.title !== void 0) {
+    rendererOptions.title = options.title;
+  }
+  if (options.width !== void 0) {
+    rendererOptions.width = options.width;
+  }
+  if (options.height !== void 0) {
+    rendererOptions.height = options.height;
+  }
+  if (options.vsync !== void 0) {
+    rendererOptions.vsync = options.vsync;
+  }
+  if (options.fontSize !== void 0) {
+    rendererOptions.fontSize = options.fontSize;
+  }
+  if (options.scaleFactor !== void 0) {
+    rendererOptions.scaleFactor = options.scaleFactor;
+  }
+  const renderer = new SdlUiRenderer(rendererOptions);
+  const inputStream = new SdlInputStream();
+  const outputStream = new SdlOutputStream(renderer);
+  const window = new SdlWindow(renderer, inputStream, outputStream);
+  return {
+    stdin: inputStream,
+    stdout: outputStream,
+    window
+  };
+};
+
+// src/index.ts
+var isSdlAvailable = () => {
+  try {
+    return isSDL2Available() && isSDL_ttfAvailable();
+  } catch {
+    return false;
+  }
+};
+export {
+  AnsiParser,
+  InputBridge,
+  SDL2API,
+  SDL_ttfAPI,
+  SdlInputStream,
+  SdlOutputStream,
+  SdlUiRenderer,
+  SdlWindow,
+  TextRenderer,
+  createSDLRect,
+  createSdlStreams,
+  getSDL2,
+  getSDL_ttf,
+  isSDL2Available,
+  isSDL_ttfAvailable,
+  isSdlAvailable
+};