ink-sdl 0.2.1 → 0.3.0

package/dist/chunk-BOQYTA3S.js

@@ -0,0 +1,2822 @@
+// src/SdlWindow/index.ts
+import { EventEmitter } from "events";
+import { pickBy, isDefined } from "remeda";
+
+// src/Sdl2/index.ts
+import koffi from "koffi";
+import { platform } from "os";
+import { existsSync } from "fs";
+import { find, last } from "remeda";
+
+// src/Sdl2/consts.ts
+var SDL_INIT_VIDEO = 32;
+var SDL_INIT_EVENTS = 16384;
+var SDL_WINDOW_FULLSCREEN = 1;
+var SDL_WINDOW_SHOWN = 4;
+var SDL_WINDOW_BORDERLESS = 16;
+var SDL_WINDOW_RESIZABLE = 32;
+var SDL_WINDOW_ALLOW_HIGHDPI = 8192;
+var SDL_WINDOW_FULLSCREEN_DESKTOP_MODIFIER = 4096;
+var SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | SDL_WINDOW_FULLSCREEN_DESKTOP_MODIFIER;
+var SDL_WINDOWPOS_CENTERED = 805240832;
+var SDL_RENDERER_ACCELERATED = 2;
+var SDL_RENDERER_PRESENTVSYNC = 4;
+var SDL_RENDERER_SOFTWARE = 1;
+var SDL_TEXTUREACCESS_TARGET = 2;
+var SDL_BLENDMODE_BLEND = 1;
+var SDL_PIXELFORMAT_ARGB8888 = 372645892;
+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_FOCUS_LOST = 13;
+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/Sdl2/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 isSystemPath = (p) => !p.includes("/") && !p.includes("\\");
+var findLibrary = (pathMap) => {
+  const plat = platform();
+  const paths = pathMap[plat] ?? [];
+  const foundPath = find(paths, (p) => isSystemPath(p) || existsSync(p));
+  return foundPath ?? last(paths) ?? null;
+};
+var findSDLLibrary = () => {
+  return findLibrary(SDL_LIB_PATHS);
+};
+var Sdl2 = class {
+  lib;
+  initialized = false;
+  // Core functions
+  _SDL_Init;
+  _SDL_Quit;
+  _SDL_GetError;
+  // Window functions
+  _SDL_CreateWindow;
+  _SDL_DestroyWindow;
+  _SDL_SetWindowTitle;
+  _SDL_GetWindowSize;
+  _SDL_RaiseWindow;
+  _SDL_SetWindowMinimumSize;
+  _SDL_SetWindowMaximumSize;
+  // 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_SetWindowMinimumSize = this.lib.func(
+      "void SDL_SetWindowMinimumSize(void* window, int min_w, int min_h)"
+    );
+    this._SDL_SetWindowMaximumSize = this.lib.func(
+      "void SDL_SetWindowMaximumSize(void* window, int max_w, int max_h)"
+    );
+    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);
+  }
+  /**
+   * Set the minimum size of a window
+   */
+  setWindowMinimumSize(window, minW, minH) {
+    this._SDL_SetWindowMinimumSize(window, minW, minH);
+  }
+  /**
+   * Set the maximum size of a window
+   */
+  setWindowMaximumSize(window, maxW, maxH) {
+    this._SDL_SetWindowMaximumSize(window, maxW, maxH);
+  }
+  /**
+   * 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 Sdl2();
+  }
+  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;
+};
+
+// src/consts.ts
+var COLOR_CHANNEL_MAX = 255;
+var DEFAULT_FONT_SIZE = 16;
+var SCALE_FACTOR_EPSILON = 0.01;
+
+// src/AnsiParser/consts.ts
+var ANSI_STANDARD_COLOR_COUNT = 8;
+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;
+
+// src/AnsiParser/index.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_ITALIC = 3;
+var SGR_UNDERLINE = 4;
+var SGR_REVERSE = 7;
+var SGR_STRIKETHROUGH = 9;
+var SGR_NORMAL_INTENSITY = 22;
+var SGR_NO_ITALIC = 23;
+var SGR_NO_UNDERLINE = 24;
+var SGR_NO_REVERSE = 27;
+var SGR_NO_STRIKETHROUGH = 29;
+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_ITALIC) {
+        commands.push({ type: "set_italic", enabled: true });
+      } else if (code === SGR_UNDERLINE) {
+        commands.push({ type: "set_underline", enabled: true });
+      } else if (code === SGR_REVERSE) {
+        commands.push({ type: "set_reverse", enabled: true });
+      } else if (code === SGR_STRIKETHROUGH) {
+        commands.push({ type: "set_strikethrough", 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_ITALIC) {
+        commands.push({ type: "set_italic", enabled: false });
+      } else if (code === SGR_NO_UNDERLINE) {
+        commands.push({ type: "set_underline", enabled: false });
+      } else if (code === SGR_NO_REVERSE) {
+        commands.push({ type: "set_reverse", enabled: false });
+      } else if (code === SGR_NO_STRIKETHROUGH) {
+        commands.push({ type: "set_strikethrough", 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/TextRenderer/index.ts
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync3 } from "fs";
+import { platform as platform3, homedir } from "os";
+import { sortBy, take } from "remeda";
+
+// src/SdlTtf/index.ts
+import koffi2 from "koffi";
+import { platform as platform2 } from "os";
+import { existsSync as existsSync2 } from "fs";
+import { find as find2, last as last2 } from "remeda";
+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 isSystemPath2 = (p) => !p.includes("/") && !p.includes("\\");
+var findLibrary2 = (pathMap) => {
+  const plat = platform2();
+  const paths = pathMap[plat] ?? [];
+  const foundPath = find2(paths, (p) => isSystemPath2(p) || existsSync2(p));
+  return foundPath ?? last2(paths) ?? null;
+};
+var findSDLTtfLibrary = () => {
+  return findLibrary2(SDL_TTF_LIB_PATHS);
+};
+var SdlTtf = class {
+  lib;
+  initialized = false;
+  // TTF functions
+  _TTF_Init;
+  _TTF_Quit;
+  _TTF_OpenFont;
+  _TTF_CloseFont;
+  _TTF_RenderUTF8_Blended;
+  _TTF_SizeUTF8;
+  _TTF_SetFontStyle;
+  _TTF_GetFontStyle;
+  _TTF_GlyphIsProvided32;
+  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 = koffi2.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)");
+    koffi2.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)"
+    );
+    this._TTF_SetFontStyle = this.lib.func(
+      "void TTF_SetFontStyle(void* font, int style)"
+    );
+    this._TTF_GetFontStyle = this.lib.func("int TTF_GetFontStyle(void* font)");
+    this._TTF_GlyphIsProvided32 = this.lib.func(
+      "int TTF_GlyphIsProvided32(void* font, uint32_t ch)"
+    );
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Set font style (bold, italic, underline, strikethrough)
+   */
+  setFontStyle(font, style) {
+    this._TTF_SetFontStyle(font, style);
+  }
+  /**
+   * Get current font style
+   */
+  getFontStyle(font) {
+    return this._TTF_GetFontStyle(font);
+  }
+  /**
+   * Check if a font provides a glyph for the given Unicode codepoint
+   */
+  glyphIsProvided(font, codepoint) {
+    return this._TTF_GlyphIsProvided32(font, codepoint) !== 0;
+  }
+};
+var TTF_STYLE_NORMAL = 0;
+var TTF_STYLE_ITALIC = 2;
+var ttfInstance = null;
+var getSdlTtf = () => {
+  if (!ttfInstance) {
+    ttfInstance = new SdlTtf();
+  }
+  return ttfInstance;
+};
+var isSdlTtfAvailable = () => {
+  try {
+    getSdlTtf();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// src/TextRenderer/consts.ts
+var DEFAULT_FONT_FILENAME = "CozetteVector.ttf";
+var MAX_GLYPH_CACHE_SIZE = 1e3;
+var GLYPH_CACHE_EVICT_DIVISOR = 4;
+var PACK_RED_SHIFT = 16;
+var PACK_GREEN_SHIFT = 8;
+var FALLBACK_FONTS = {
+  darwin: [
+    "/System/Library/Fonts/Menlo.ttc",
+    "/System/Library/Fonts/Monaco.ttf",
+    "/System/Library/Fonts/Courier.dfont"
+  ],
+  linux: [
+    "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf",
+    "/usr/share/fonts/TTF/DejaVuSansMono.ttf",
+    "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf",
+    "/usr/share/fonts/truetype/freefont/FreeMono.ttf"
+  ],
+  win32: [
+    "C:\\Windows\\Fonts\\consola.ttf",
+    "C:\\Windows\\Fonts\\cour.ttf",
+    "C:\\Windows\\Fonts\\lucon.ttf"
+  ]
+};
+var EMOJI_FONTS = {
+  darwin: ["/System/Library/Fonts/Apple Color Emoji.ttc"],
+  linux: [
+    "/usr/share/fonts/truetype/noto/NotoColorEmoji.ttf",
+    "/usr/share/fonts/noto-emoji/NotoColorEmoji.ttf",
+    "/usr/share/fonts/truetype/twitter-color-emoji/TwitterColorEmoji-SVGinOT.ttf",
+    "/usr/share/fonts/google-noto-emoji/NotoColorEmoji.ttf"
+  ],
+  win32: ["C:\\Windows\\Fonts\\seguiemj.ttf"]
+};
+var EMOJI_FONT_SCALE = 0.75;
+
+// src/TextRenderer/index.ts
+var TextRenderer = class {
+  sdl = getSdl2();
+  ttf = getSdlTtf();
+  font = null;
+  fallbackFont = null;
+  renderer;
+  baseFontSize;
+  scaleFactor;
+  glyphCache = /* @__PURE__ */ new Map();
+  accessCounter = 0;
+  charWidth = 0;
+  charHeight = 0;
+  currentFontPath = null;
+  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();
+    }
+    let fontPath;
+    if (options.fontPath) {
+      fontPath = options.fontPath;
+    } else if (options.fontName) {
+      fontPath = this.findFontByName(options.fontName);
+    } else if (options.systemFont) {
+      fontPath = this.findSystemFont();
+    } else {
+      fontPath = this.findAvailableFont();
+    }
+    this.loadFont(fontPath);
+    this.loadFallbackFont();
+  }
+  /**
+   * Get system font directories for the current platform
+   */
+  getSystemFontDirectories() {
+    const home = homedir();
+    const plat = platform3();
+    if (plat === "darwin") {
+      return [
+        join(home, "Library/Fonts"),
+        "/Library/Fonts",
+        "/System/Library/Fonts",
+        "/System/Library/Fonts/Supplemental"
+      ];
+    }
+    if (plat === "linux") {
+      return [
+        join(home, ".fonts"),
+        join(home, ".local/share/fonts"),
+        "/usr/share/fonts/truetype",
+        "/usr/share/fonts/TTF",
+        "/usr/local/share/fonts"
+      ];
+    }
+    if (plat === "win32") {
+      return ["C:\\Windows\\Fonts"];
+    }
+    return [];
+  }
+  /**
+   * Get system font paths for the default font filename
+   */
+  getSystemFontPaths() {
+    return this.getSystemFontDirectories().map(
+      (dir) => join(dir, DEFAULT_FONT_FILENAME)
+    );
+  }
+  /**
+   * Find a font by name in system font directories
+   *
+   * Searches for common font file extensions (.ttf, .ttc, .otf)
+   */
+  findFontByName(fontName) {
+    const extensions = [".ttf", ".ttc", ".otf", ".TTC", ".TTF", ".OTF"];
+    const directories = this.getSystemFontDirectories();
+    for (const dir of directories) {
+      for (const ext of extensions) {
+        const fontPath = join(dir, `${fontName}${ext}`);
+        try {
+          if (existsSync3(fontPath)) {
+            return fontPath;
+          }
+        } catch {
+        }
+      }
+    }
+    throw new Error(
+      `Font "${fontName}" not found in system font directories.
+Searched directories:
+  - ${directories.join("\n  - ")}
+Tried extensions: ${extensions.join(", ")}`
+    );
+  }
+  /**
+   * Get the path to the Cozette font (system or bundled)
+   */
+  getDefaultFontPath() {
+    for (const p of this.getSystemFontPaths()) {
+      try {
+        if (existsSync3(p)) {
+          return p;
+        }
+      } catch {
+      }
+    }
+    const currentFilename = fileURLToPath(import.meta.url);
+    const currentDirname = dirname(currentFilename);
+    const bundledPaths = [
+      resolve(currentDirname, "../../fonts", DEFAULT_FONT_FILENAME),
+      // Dev path
+      resolve(currentDirname, "./fonts", DEFAULT_FONT_FILENAME),
+      // Bundled (dist)
+      resolve(currentDirname, "../fonts", DEFAULT_FONT_FILENAME)
+      // Alternate
+    ];
+    for (const p of bundledPaths) {
+      try {
+        if (existsSync3(p)) {
+          return p;
+        }
+      } catch {
+      }
+    }
+    return bundledPaths[0];
+  }
+  /**
+   * Get fallback fonts for the current platform
+   */
+  getFallbackFontPaths() {
+    const plat = platform3();
+    if (plat === "darwin") {
+      return [...FALLBACK_FONTS.darwin];
+    }
+    if (plat === "linux") {
+      return [...FALLBACK_FONTS.linux];
+    }
+    if (plat === "win32") {
+      return [...FALLBACK_FONTS.win32];
+    }
+    return [];
+  }
+  /**
+   * Find an available font, trying default first then fallbacks
+   */
+  findAvailableFont() {
+    const defaultPath = this.getDefaultFontPath();
+    try {
+      if (existsSync3(defaultPath)) {
+        return defaultPath;
+      }
+    } catch {
+    }
+    for (const fallbackPath of this.getFallbackFontPaths()) {
+      try {
+        if (existsSync3(fallbackPath)) {
+          return fallbackPath;
+        }
+      } catch {
+      }
+    }
+    return defaultPath;
+  }
+  /**
+   * Find a system font, skipping the default bundled font
+   */
+  findSystemFont() {
+    for (const fallbackPath of this.getFallbackFontPaths()) {
+      try {
+        if (existsSync3(fallbackPath)) {
+          return fallbackPath;
+        }
+      } catch {
+      }
+    }
+    return this.getDefaultFontPath();
+  }
+  /**
+   * Get emoji font paths for the current platform
+   */
+  getEmojiFontPaths() {
+    const plat = platform3();
+    if (plat === "darwin") {
+      return [...EMOJI_FONTS.darwin];
+    }
+    if (plat === "linux") {
+      return [...EMOJI_FONTS.linux];
+    }
+    if (plat === "win32") {
+      return [...EMOJI_FONTS.win32];
+    }
+    return [];
+  }
+  /**
+   * Find an available emoji font
+   */
+  findEmojiFont() {
+    for (const fontPath of this.getEmojiFontPaths()) {
+      try {
+        if (existsSync3(fontPath)) {
+          return fontPath;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  /**
+   * Load the fallback emoji font if available
+   */
+  loadFallbackFont() {
+    if (this.fallbackFont) {
+      this.ttf.closeFont(this.fallbackFont);
+      this.fallbackFont = null;
+    }
+    const emojiFontPath = this.findEmojiFont();
+    if (!emojiFontPath) {
+      return;
+    }
+    const physicalSize = Math.round(
+      this.baseFontSize * this.scaleFactor * EMOJI_FONT_SCALE
+    );
+    try {
+      this.fallbackFont = this.ttf.openFont(emojiFontPath, physicalSize);
+    } catch {
+      this.fallbackFont = null;
+    }
+  }
+  /**
+   * 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);
+    try {
+      this.font = this.ttf.openFont(fontPath, physicalSize);
+      this.currentFontPath = fontPath;
+    } catch (error) {
+      const fallbackPaths = this.getFallbackFontPaths();
+      const triedPaths = [fontPath, ...fallbackPaths].join("\n  - ");
+      throw new Error(
+        `Failed to load font: ${fontPath}
+Tried paths:
+  - ${triedPaths}
+Original error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    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.currentFontPath ?? this.findAvailableFont();
+    this.loadFont(fontPath);
+    this.loadFallbackFont();
+  }
+  /**
+   * Get character dimensions
+   */
+  getCharDimensions() {
+    return { width: this.charWidth, height: this.charHeight };
+  }
+  /**
+   * Generate cache key for a glyph
+   */
+  getCacheKey(char, r, g, b, italic) {
+    const packedColor = r << PACK_RED_SHIFT | g << PACK_GREEN_SHIFT | b;
+    return `${char}:${packedColor}:${italic ? "i" : "n"}`;
+  }
+  /**
+   * Get or create a cached glyph texture
+   */
+  getGlyph(char, r, g, b, italic = false) {
+    const key = this.getCacheKey(char, r, g, b, italic);
+    const cached = this.glyphCache.get(key);
+    if (cached) {
+      cached.lastUsed = this.accessCounter++;
+      return cached;
+    }
+    if (!this.font) {
+      return null;
+    }
+    try {
+      const codepoint = char.codePointAt(0) ?? 0;
+      let fontToUse = this.font;
+      if (this.fallbackFont && !this.ttf.glyphIsProvided(this.font, codepoint) && this.ttf.glyphIsProvided(this.fallbackFont, codepoint)) {
+        fontToUse = this.fallbackFont;
+      }
+      if (fontToUse === this.font) {
+        const currentStyle = this.ttf.getFontStyle(this.font);
+        const targetStyle = italic ? TTF_STYLE_ITALIC : TTF_STYLE_NORMAL;
+        if (currentStyle !== targetStyle) {
+          this.ttf.setFontStyle(this.font, targetStyle);
+        }
+      }
+      const surface = this.ttf.renderTextBlended(
+        fontToUse,
+        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(fontToUse, 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 = sortBy(
+      [...this.glyphCache.entries()],
+      ([, glyph]) => glyph.lastUsed
+    );
+    const removeCount = Math.floor(
+      MAX_GLYPH_CACHE_SIZE / GLYPH_CACHE_EVICT_DIVISOR
+    );
+    for (const [key, glyph] of take(entries, removeCount)) {
+      this.sdl.destroyTexture(glyph.texture);
+      this.glyphCache.delete(key);
+    }
+  }
+  /**
+   * Render a single character at the specified position
+   */
+  renderChar(char, x, y, color, italic = false) {
+    const glyph = this.getGlyph(char, color.r, color.g, color.b, italic);
+    if (!glyph) {
+      return;
+    }
+    let destWidth = glyph.width;
+    let destHeight = glyph.height;
+    let destX = x;
+    const destY = y;
+    if (glyph.height > this.charHeight) {
+      const scale = this.charHeight / glyph.height;
+      destWidth = Math.round(glyph.width * scale);
+      destHeight = this.charHeight;
+      destX = x + Math.round((this.charWidth - destWidth) / 2);
+    }
+    const destRect = createSDLRect(destX, destY, destWidth, destHeight);
+    this.sdl.renderCopy(this.renderer, glyph.texture, null, destRect);
+  }
+  /**
+   * Render a string of text at the specified position
+   */
+  renderText(text, x, y, color, italic = false) {
+    let cursorX = x;
+    for (const char of text) {
+      if (char === " ") {
+        cursorX += this.charWidth;
+        continue;
+      }
+      this.renderChar(char, cursorX, y, color, italic);
+      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;
+    }
+    if (this.fallbackFont) {
+      this.ttf.closeFont(this.fallbackFont);
+      this.fallbackFont = null;
+    }
+  }
+};
+
+// src/InputBridge/index.ts
+import { isNonNullish } from "remeda";
+
+// src/InputBridge/consts.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;
+
+// src/InputBridge/index.ts
+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 (isNonNullish(specialSequence)) {
+      return specialSequence;
+    }
+    if (this.modifiers.ctrl) {
+      const ctrlSequence = this.getCtrlSequence(keycode);
+      if (isNonNullish(ctrlSequence)) {
+        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 (!isNonNullish(sequence)) {
+      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/SdlUiRenderer/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 BOLD_BRIGHTNESS_MULTIPLIER = 1.3;
+var DIM_BRIGHTNESS_MULTIPLIER = 0.5;
+var UNDERLINE_POSITION = 0.9;
+var STRIKETHROUGH_POSITION = 0.5;
+var TEXT_DECORATION_THICKNESS = 0.08;
+
+// src/SdlUiRenderer/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 HEX_COLOR_LENGTH = 6;
+var HEX_R_END = 2;
+var HEX_G_END = 4;
+var parseBackgroundColor = (color) => {
+  if (!color) {
+    return { ...DEFAULT_BG2 };
+  }
+  if (Array.isArray(color)) {
+    return { r: color[0], g: color[1], b: color[2] };
+  }
+  const hex = color.startsWith("#") ? color.slice(1) : color;
+  if (hex.length === HEX_COLOR_LENGTH) {
+    const r = parseInt(hex.slice(0, HEX_R_END), 16);
+    const g = parseInt(hex.slice(HEX_R_END, HEX_G_END), 16);
+    const b = parseInt(hex.slice(HEX_G_END), 16);
+    if (!isNaN(r) && !isNaN(g) && !isNaN(b)) {
+      return { r, g, b };
+    }
+  }
+  return { ...DEFAULT_BG2 };
+};
+var SdlUiRenderer = class {
+  sdl = getSdl2();
+  window = null;
+  renderer = null;
+  textRenderer = null;
+  renderTarget = null;
+  ansiParser;
+  inputBridge;
+  windowWidth;
+  windowHeight;
+  columns;
+  rows;
+  charWidth = 0;
+  charHeight = 0;
+  fgColor = { ...DEFAULT_FG2 };
+  bgColor = { ...DEFAULT_BG2 };
+  defaultBgColor = { ...DEFAULT_BG2 };
+  bold = false;
+  dim = false;
+  italic = false;
+  underline = false;
+  strikethrough = 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.defaultBgColor = parseBackgroundColor(options.backgroundColor);
+    this.bgColor = { ...this.defaultBgColor };
+    let windowFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI;
+    if (!options.fullscreen) {
+      windowFlags |= SDL_WINDOW_RESIZABLE;
+    }
+    if (options.fullscreen === "desktop") {
+      windowFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+    } else if (options.fullscreen === true) {
+      windowFlags |= SDL_WINDOW_FULLSCREEN;
+    }
+    if (options.borderless && !options.fullscreen) {
+      windowFlags |= SDL_WINDOW_BORDERLESS;
+    }
+    this.window = this.sdl.createWindow(
+      options.title ?? "ink-sdl",
+      SDL_WINDOWPOS_CENTERED,
+      SDL_WINDOWPOS_CENTERED,
+      this.windowWidth,
+      this.windowHeight,
+      windowFlags
+    );
+    if (options.minWidth !== void 0 || options.minHeight !== void 0) {
+      const minW = options.minWidth ?? 1;
+      const minH = options.minHeight ?? 1;
+      this.sdl.setWindowMinimumSize(this.window, minW, minH);
+    }
+    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,
+      ...options.systemFont && { systemFont: true },
+      ...options.fontPath && { fontPath: options.fontPath },
+      ...options.fontName && { fontName: options.fontName }
+    });
+    const charDims = this.textRenderer.getCharDimensions();
+    this.charWidth = charDims.width;
+    this.charHeight = charDims.height;
+    this.updateTerminalDimensions();
+    this.createRenderTarget();
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      this.defaultBgColor.r,
+      this.defaultBgColor.g,
+      this.defaultBgColor.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.setRenderTarget(this.renderer, this.renderTarget);
+    this.sdl.renderClear(this.renderer);
+    this.sdl.setRenderTarget(this.renderer, null);
+    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
+    };
+  }
+  /**
+   * Create or recreate the render target texture
+   */
+  createRenderTarget() {
+    if (!this.renderer) {
+      return;
+    }
+    if (this.renderTarget) {
+      this.sdl.destroyTexture(this.renderTarget);
+      this.renderTarget = null;
+    }
+    const drawable = this.sdl.getDrawableSize(this.window);
+    this.renderTarget = this.sdl.createTexture(
+      this.renderer,
+      SDL_PIXELFORMAT_ARGB8888,
+      SDL_TEXTUREACCESS_TARGET,
+      drawable.width,
+      drawable.height
+    );
+    this.sdl.setTextureBlendMode(this.renderTarget, SDL_BLENDMODE_BLEND);
+  }
+  /**
+   * 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 || !this.renderTarget) {
+      return;
+    }
+    this.sdl.setRenderTarget(this.renderer, this.renderTarget);
+    for (const cmd of this.pendingCommands) {
+      this.executeCommand(cmd);
+    }
+    this.pendingCommands = [];
+    this.sdl.setRenderTarget(this.renderer, null);
+    this.sdl.renderCopy(this.renderer, this.renderTarget, null, null);
+    this.sdl.renderPresent(this.renderer);
+  }
+  /**
+   * Refresh the display by copying the render target to the screen
+   *
+   * Call this periodically to keep the display updated even when no new
+   * content is being rendered. Required for SDL's double-buffering to work
+   * correctly - without continuous presents, the window can go black.
+   */
+  refreshDisplay() {
+    if (!this.renderer || !this.renderTarget) {
+      return;
+    }
+    this.sdl.setRenderTarget(this.renderer, null);
+    this.sdl.renderCopy(this.renderer, this.renderTarget, null, null);
+    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.sdl.setRenderDrawColor(
+          this.renderer,
+          this.defaultBgColor.r,
+          this.defaultBgColor.g,
+          this.defaultBgColor.b,
+          COLOR_CHANNEL_MAX
+        );
+        this.sdl.renderClear(this.renderer);
+        this.ansiParser.reset();
+        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 = { ...this.defaultBgColor };
+        this.bold = false;
+        this.dim = false;
+        this.italic = false;
+        this.underline = false;
+        this.strikethrough = 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_italic":
+        this.italic = cmd.enabled ?? false;
+        break;
+      case "set_underline":
+        this.underline = cmd.enabled ?? false;
+        break;
+      case "set_strikethrough":
+        this.strikethrough = 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 textWidth = text.length * this.charWidth;
+    const bgRect = createSDLRect(x, y, textWidth, 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, this.italic);
+    if (this.underline || this.strikethrough) {
+      const lineThickness = Math.max(
+        1,
+        Math.round(this.charHeight * TEXT_DECORATION_THICKNESS)
+      );
+      this.sdl.setRenderDrawColor(
+        this.renderer,
+        fg.r,
+        fg.g,
+        fg.b,
+        COLOR_CHANNEL_MAX
+      );
+      if (this.underline) {
+        const underlineY = y + Math.round(this.charHeight * UNDERLINE_POSITION);
+        const underlineRect = createSDLRect(
+          x,
+          underlineY,
+          textWidth,
+          lineThickness
+        );
+        this.sdl.renderFillRect(this.renderer, underlineRect);
+      }
+      if (this.strikethrough) {
+        const strikeY = y + Math.round(this.charHeight * STRIKETHROUGH_POSITION);
+        const strikeRect = createSDLRect(x, strikeY, textWidth, lineThickness);
+        this.sdl.renderFillRect(this.renderer, strikeRect);
+      }
+    }
+  }
+  /**
+   * Clear the entire screen
+   */
+  clear() {
+    if (!this.renderer || !this.renderTarget) {
+      return;
+    }
+    this.sdl.setRenderTarget(this.renderer, this.renderTarget);
+    this.sdl.setRenderDrawColor(
+      this.renderer,
+      this.defaultBgColor.r,
+      this.defaultBgColor.g,
+      this.defaultBgColor.b,
+      COLOR_CHANNEL_MAX
+    );
+    this.sdl.renderClear(this.renderer);
+    this.sdl.setRenderTarget(this.renderer, null);
+    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 resized = false;
+    let focusLost = false;
+    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();
+          resized = true;
+        } else if (event.windowEvent === SDL_WINDOWEVENT_FOCUS_LOST) {
+          focusLost = true;
+        }
+      } 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, resized, focusLost };
+  }
+  /**
+   * 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.createRenderTarget();
+    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.createRenderTarget();
+    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.renderTarget) {
+      this.sdl.destroyTexture(this.renderTarget);
+      this.renderTarget = 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 = { ...this.defaultBgColor };
+    this.bold = false;
+    this.dim = false;
+    this.italic = false;
+    this.underline = false;
+    this.strikethrough = 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();
+    }
+  }
+  /**
+   * Reset input state (modifier keys)
+   *
+   * Call this when focus is lost to prevent "stuck" modifier keys.
+   */
+  resetInputState() {
+    this.inputBridge.reset();
+  }
+  /**
+   * Get glyph cache statistics
+   *
+   * Useful for profiling and tuning cache size.
+   */
+  getCacheStats() {
+    return this.textRenderer?.getCacheStats() ?? null;
+  }
+};
+
+// src/SdlOutputStream/index.ts
+import { Writable } from "stream";
+import { isString } from "remeda";
+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_COLUMNS;
+  }
+  /**
+   * Get terminal rows
+   */
+  get rows() {
+    const dims = this.uiRenderer.getDimensions();
+    return dims.rows || DEFAULT_ROWS;
+  }
+  /**
+   * Notify Ink of resize
+   */
+  notifyResize() {
+    this.emit("resize");
+  }
+  /**
+   * Implement Writable._write
+   */
+  _write(chunk, _encoding, callback) {
+    try {
+      const text = isString(chunk) ? 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/SdlInputStream/index.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/SdlWindow/consts.ts
+var EVENT_LOOP_INTERVAL_MS = 16;
+
+// src/SdlWindow/index.ts
+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, resized, focusLost } = this.renderer.processEvents();
+      if (resized) {
+        this.outputStream.notifyResize();
+        this.emit("resize", this.renderer.getDimensions());
+      }
+      if (focusLost) {
+        this.renderer.resetInputState();
+        this.emit("blur");
+      }
+      for (const event of keyEvents) {
+        const sequence = this.renderer.keyEventToSequence(event);
+        if (sequence) {
+          if (sequence === "") {
+            if (this.listenerCount("sigint") > 0) {
+              this.emit("sigint");
+            } else {
+              process.kill(process.pid, "SIGINT");
+            }
+            continue;
+          }
+          this.inputStream.pushKey(sequence);
+          this.emit("key", event);
+        }
+      }
+      this.renderer.refreshDisplay();
+      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;
+  }
+  /**
+   * Get glyph cache statistics
+   *
+   * Useful for profiling and tuning cache performance.
+   *
+   * @example
+   * ```typescript
+   * const stats = window.getCacheStats();
+   * if (stats) {
+   *   console.log(`Cache: ${stats.size}/${stats.maxSize} glyphs`);
+   * }
+   * ```
+   */
+  getCacheStats() {
+    return this.renderer.getCacheStats();
+  }
+};
+var createSdlStreams = (options = {}) => {
+  if (process.env["FORCE_COLOR"] === void 0) {
+    process.env["FORCE_COLOR"] = "3";
+  }
+  const rendererOptions = pickBy(options, isDefined);
+  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,
+    renderer
+  };
+};
+
+// src/index.ts
+if (process.env["FORCE_COLOR"] === void 0) {
+  process.env["FORCE_COLOR"] = "3";
+}
+var isSdlAvailable = () => {
+  try {
+    return isSdl2Available() && isSdlTtfAvailable();
+  } catch {
+    return false;
+  }
+};
+
+export {
+  Sdl2,
+  getSdl2,
+  isSdl2Available,
+  createSDLRect,
+  AnsiParser,
+  SdlTtf,
+  getSdlTtf,
+  isSdlTtfAvailable,
+  TextRenderer,
+  InputBridge,
+  SdlUiRenderer,
+  SdlOutputStream,
+  SdlInputStream,
+  SdlWindow,
+  createSdlStreams,
+  isSdlAvailable
+};