@heliohq/helio 0.1.2

package/dist/pty/clipboard.js

@@ -0,0 +1,39 @@
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
+
+// src/pty/clipboard.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+function readClipboardImage() {
+  if (os.platform() !== "darwin") {
+    return "";
+  }
+  try {
+    return readClipboardImageDarwin();
+  } catch {
+    return "";
+  }
+}
+function readClipboardImageDarwin() {
+  const tmpFile = "/tmp/.ship-clipboard-local.png";
+  try {
+    execSync("osascript -e 'the clipboard as \xABclass PNGf\xBB'", {
+      stdio: "pipe"
+    });
+    execSync(
+      `osascript -e 'set png_data to (the clipboard as \xABclass PNGf\xBB)' -e 'set fp to open for access POSIX file "${tmpFile}" with write permission' -e 'write png_data to fp' -e 'close access fp'`,
+      { stdio: "pipe" }
+    );
+    const data = fs.readFileSync(tmpFile);
+    return data.toString("base64");
+  } finally {
+    try {
+      fs.unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+export {
+  readClipboardImage
+};
+//# sourceMappingURL=clipboard.js.map

package/dist/pty/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/pty/clipboard.ts"],"sourcesContent":["import { execSync } from 'node:child_process';\nimport * as fs from 'node:fs';\nimport * as os from 'node:os';\n\n/**\n * Read an image from the system clipboard.\n * Returns base64-encoded PNG data, or empty string if no image is available.\n * Only supported on macOS.\n */\nexport function readClipboardImage(): string {\n  if (os.platform() !== 'darwin') {\n    return '';\n  }\n\n  try {\n    return readClipboardImageDarwin();\n  } catch {\n    return '';\n  }\n}\n\nfunction readClipboardImageDarwin(): string {\n  const tmpFile = '/tmp/.ship-clipboard-local.png';\n\n  try {\n    // Check if clipboard has an image\n    execSync(\"osascript -e 'the clipboard as «class PNGf»'\", {\n      stdio: 'pipe',\n    });\n\n    // Save clipboard image to temp file\n    execSync(\n      `osascript -e 'set png_data to (the clipboard as «class PNGf»)' -e 'set fp to open for access POSIX file \"${tmpFile}\" with write permission' -e 'write png_data to fp' -e 'close access fp'`,\n      { stdio: 'pipe' },\n    );\n\n    const data = fs.readFileSync(tmpFile);\n    return data.toString('base64');\n  } finally {\n    try {\n      fs.unlinkSync(tmpFile);\n    } catch {\n      // ignore\n    }\n  }\n}\n"],"mappings":";;;AAAA,SAAS,gBAAgB;AACzB,YAAY,QAAQ;AACpB,YAAY,QAAQ;AAOb,SAAS,qBAA6B;AAC3C,MAAO,YAAS,MAAM,UAAU;AAC9B,WAAO;AAAA,EACT;AAEA,MAAI;AACF,WAAO,yBAAyB;AAAA,EAClC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,2BAAmC;AAC1C,QAAM,UAAU;AAEhB,MAAI;AAEF,aAAS,sDAAgD;AAAA,MACvD,OAAO;AAAA,IACT,CAAC;AAGD;AAAA,MACE,kHAA4G,OAAO;AAAA,MACnH,EAAE,OAAO,OAAO;AAAA,IAClB;AAEA,UAAM,OAAU,gBAAa,OAAO;AACpC,WAAO,KAAK,SAAS,QAAQ;AAAA,EAC/B,UAAE;AACA,QAAI;AACF,MAAG,cAAW,OAAO;AAAA,IACvB,QAAQ;AAAA,IAER;AAAA,EACF;AACF;","names":[]}

package/dist/pty/errors.js

@@ -0,0 +1,57 @@
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
+
+// src/pty/errors.ts
+var PTYAPIError = class extends Error {
+  statusCode;
+  operation;
+  body;
+  hint;
+  constructor(statusCode, operation, body, hint) {
+    const msg = body ? `${operation} (${statusCode}) ${body}` : `${operation} (${statusCode})`;
+    super(msg);
+    this.name = "PTYAPIError";
+    this.statusCode = statusCode;
+    this.operation = operation;
+    this.body = body;
+    this.hint = hint ?? "";
+  }
+};
+function hintForStatus(code) {
+  switch (code) {
+    case 401:
+      return "run `helio auth login` to re-authenticate";
+    case 403:
+      return "you may not have permission for this operation";
+    case 404:
+      return "the resource was not found";
+    case 429:
+      return "rate limited \u2014 try again shortly";
+    case 500:
+    case 502:
+    case 503:
+      return "the backend may be temporarily unavailable, try again shortly";
+    default:
+      return "";
+  }
+}
+function newPTYAPIError(statusCode, operation, body) {
+  const hint = hintForStatus(statusCode);
+  return new PTYAPIError(statusCode, operation, body, hint);
+}
+function formatError(err) {
+  if (err instanceof PTYAPIError) {
+    let msg = `helio: ${err.message}`;
+    if (err.hint) {
+      msg += `
+  Tip: ${err.hint}`;
+    }
+    return msg;
+  }
+  return `helio: ${err.message}`;
+}
+export {
+  PTYAPIError,
+  formatError,
+  newPTYAPIError
+};
+//# sourceMappingURL=errors.js.map

package/dist/pty/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/pty/errors.ts"],"sourcesContent":["/**\n * APIError wraps an HTTP API error with a user-facing hint.\n */\nexport class PTYAPIError extends Error {\n  statusCode: number;\n  operation: string;\n  body: string;\n  hint: string;\n\n  constructor(statusCode: number, operation: string, body: string, hint?: string) {\n    const msg = body ? `${operation} (${statusCode}) ${body}` : `${operation} (${statusCode})`;\n    super(msg);\n    this.name = 'PTYAPIError';\n    this.statusCode = statusCode;\n    this.operation = operation;\n    this.body = body;\n    this.hint = hint ?? '';\n  }\n}\n\nfunction hintForStatus(code: number): string {\n  switch (code) {\n    case 401:\n      return 'run `helio auth login` to re-authenticate';\n    case 403:\n      return 'you may not have permission for this operation';\n    case 404:\n      return 'the resource was not found';\n    case 429:\n      return 'rate limited — try again shortly';\n    case 500:\n    case 502:\n    case 503:\n      return 'the backend may be temporarily unavailable, try again shortly';\n    default:\n      return '';\n  }\n}\n\n/**\n * Create a PTYAPIError with an appropriate hint based on status code.\n */\nexport function newPTYAPIError(\n  statusCode: number,\n  operation: string,\n  body: string,\n): PTYAPIError {\n  const hint = hintForStatus(statusCode);\n  return new PTYAPIError(statusCode, operation, body, hint);\n}\n\n/**\n * Format an error for display on stderr, including any hint.\n */\nexport function formatError(err: Error): string {\n  if (err instanceof PTYAPIError) {\n    let msg = `helio: ${err.message}`;\n    if (err.hint) {\n      msg += `\\n  Tip: ${err.hint}`;\n    }\n    return msg;\n  }\n  return `helio: ${err.message}`;\n}\n"],"mappings":";;;AAGO,IAAM,cAAN,cAA0B,MAAM;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,YAAoB,WAAmB,MAAc,MAAe;AAC9E,UAAM,MAAM,OAAO,GAAG,SAAS,KAAK,UAAU,KAAK,IAAI,KAAK,GAAG,SAAS,KAAK,UAAU;AACvF,UAAM,GAAG;AACT,SAAK,OAAO;AACZ,SAAK,aAAa;AAClB,SAAK,YAAY;AACjB,SAAK,OAAO;AACZ,SAAK,OAAO,QAAQ;AAAA,EACtB;AACF;AAEA,SAAS,cAAc,MAAsB;AAC3C,UAAQ,MAAM;AAAA,IACZ,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT;AACE,aAAO;AAAA,EACX;AACF;AAKO,SAAS,eACd,YACA,WACA,MACa;AACb,QAAM,OAAO,cAAc,UAAU;AACrC,SAAO,IAAI,YAAY,YAAY,WAAW,MAAM,IAAI;AAC1D;AAKO,SAAS,YAAY,KAAoB;AAC9C,MAAI,eAAe,aAAa;AAC9B,QAAI,MAAM,UAAU,IAAI,OAAO;AAC/B,QAAI,IAAI,MAAM;AACZ,aAAO;AAAA,SAAY,IAAI,IAAI;AAAA,IAC7B;AACA,WAAO;AAAA,EACT;AACA,SAAO,UAAU,IAAI,OAAO;AAC9B;","names":[]}

package/dist/pty/protocol.js

@@ -0,0 +1,18 @@
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
+
+// src/pty/protocol.ts
+var CONTROL_EXIT = "exit";
+var CONTROL_CLIPBOARD = "clipboard";
+var CONTROL_ROLE = "role";
+var CONTROL_PRIMARY_DISCONNECTED = "primary_disconnected";
+var CONTROL_TAKEOVER = "takeover";
+var CONTROL_TAKEOVER_DENIED = "takeover_denied";
+export {
+  CONTROL_CLIPBOARD,
+  CONTROL_EXIT,
+  CONTROL_PRIMARY_DISCONNECTED,
+  CONTROL_ROLE,
+  CONTROL_TAKEOVER,
+  CONTROL_TAKEOVER_DENIED
+};
+//# sourceMappingURL=protocol.js.map

package/dist/pty/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/pty/protocol.ts"],"sourcesContent":["/**\n * Control message type constants used by PTYClient to handle\n * inbound control messages from the PTY bridge.\n */\nexport const CONTROL_EXIT = 'exit';\nexport const CONTROL_CLIPBOARD = 'clipboard';\nexport const CONTROL_ROLE = 'role';\nexport const CONTROL_PRIMARY_DISCONNECTED = 'primary_disconnected';\nexport const CONTROL_TAKEOVER = 'takeover';\nexport const CONTROL_TAKEOVER_DENIED = 'takeover_denied';\n"],"mappings":";;;AAIO,IAAM,eAAe;AACrB,IAAM,oBAAoB;AAC1B,IAAM,eAAe;AACrB,IAAM,+BAA+B;AACrC,IAAM,mBAAmB;AACzB,IAAM,0BAA0B;","names":[]}

package/dist/pty/screen-renderer.js

@@ -0,0 +1,492 @@
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
+
+// src/pty/screen-renderer.ts
+import xtermHeadless from "@xterm/headless";
+var Terminal = xtermHeadless.Terminal;
+var ScreenRenderer = class _ScreenRenderer {
+  term;
+  writeBuffer;
+  // xterm internal API — depends on @xterm/headless ^5.5.0 internals
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  core;
+  overlayTimer = null;
+  pendingOverlay = "";
+  incompleteEsc = false;
+  vterm;
+  lastFrame = [];
+  cols;
+  rows;
+  renderTimer = null;
+  /** Render batch delay in ms — matches Ink's 16ms (60fps) throttle to prevent
+   *  partial-frame rendering when TUI frameworks send rapid incremental updates. */
+  static RENDER_BATCH_MS = 16;
+  /** Last seen baseY — when it changes the viewport shifted and lastFrame must be invalidated. */
+  lastBaseY = 0;
+  /** Last observed content height (last non-blank row + 1). Used to detect
+   *  dialog dismiss events where content shrinks significantly. */
+  lastContentHeight = 0;
+  /** Callback fired when content height drops significantly (e.g., dialog dismissed).
+   *  The PTYClient uses this to send a resize trick to force Ink to relayout. */
+  onContentShrink = null;
+  scrollOffset = 0;
+  // 0 = bottom (live), >0 = scrolled up
+  scrollCursorY = 0;
+  // cursor row within viewport (0-indexed)
+  scrollCursorX = 0;
+  // actual display col (clamped to content)
+  scrollDesiredX = 0;
+  // remembered col for up/down navigation
+  constructor(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+    this.vterm = !process.env["HELIO_PASSTHROUGH"];
+    this.term = new Terminal({ cols, rows, scrollback: 1e4, allowProposedApi: true });
+    this.core = this.term["_core"];
+    this.writeBuffer = this.core._writeBuffer;
+    this.term.parser.registerCsiHandler({ prefix: "?", final: "h" }, (params) => {
+      if (params[0] === 1049) this.lastFrame = [];
+      return false;
+    });
+    this.term.parser.registerCsiHandler({ prefix: "?", final: "l" }, (params) => {
+      if (params[0] === 1049) this.lastFrame = [];
+      return false;
+    });
+  }
+  /**
+   * Relay terminal query responses from xterm to the agent PTY.
+   * Also intercepts queries xterm can't answer (OSC 10 foreground color)
+   * and provides default responses to prevent agent startup delays.
+   */
+  setupResponseRelay(sendToAgent) {
+    this.term.onData((data) => {
+      sendToAgent(data);
+    });
+    this.term.parser.registerOscHandler(10, (data) => {
+      if (data === "?") {
+        sendToAgent("\x1B]10;rgb:ffff/ffff/ffff\x1B\\");
+      }
+      return false;
+    });
+  }
+  write(data, statusBarEsc) {
+    const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+    this.writeBuffer.writeSync(str, false);
+    if (this.scrollOffset > 0) {
+      this.scrollOffset = 0;
+      this.lastFrame = [];
+    }
+    if (this.vterm) {
+      this.pendingOverlay = statusBarEsc;
+      if (!this.renderTimer) {
+        this.renderTimer = setTimeout(() => {
+          this.renderTimer = null;
+          this.vtermRender();
+        }, _ScreenRenderer.RENDER_BATCH_MS);
+      }
+    } else {
+      process.stdout.write(data);
+      this.incompleteEsc = this.endsWithIncompleteEsc(str);
+      if (statusBarEsc) {
+        this.pendingOverlay = statusBarEsc;
+        if (!this.overlayTimer) {
+          this.overlayTimer = setImmediate(() => {
+            this.overlayTimer = null;
+            if (!this.incompleteEsc) {
+              this.flushOverlay();
+            }
+          });
+        }
+      }
+    }
+  }
+  /** Vterm render (legacy, no scroll). */
+  vtermRender() {
+    const buf = this.term.buffer.active;
+    let output = "";
+    if (buf.baseY !== this.lastBaseY) {
+      this.lastFrame = [];
+      this.lastBaseY = buf.baseY;
+    }
+    for (let y = 0; y < this.rows; y++) {
+      const line = buf.getLine(buf.baseY + y);
+      if (!line) {
+        if (this.lastFrame[y] !== void 0) {
+          output += `\x1B[${y + 1};1H\x1B[2K`;
+          delete this.lastFrame[y];
+        }
+        continue;
+      }
+      const rendered = this.renderLine(line);
+      if (this.lastFrame[y] === rendered) continue;
+      this.lastFrame[y] = rendered;
+      output += `\x1B[${y + 1};1H\x1B[2K${rendered}`;
+    }
+    let contentHeight = 0;
+    for (let y = this.rows - 1; y >= 0; y--) {
+      const line = buf.getLine(buf.baseY + y);
+      if (line && line.translateToString(true).length > 0) {
+        contentHeight = y + 1;
+        break;
+      }
+    }
+    const prevHeight = this.lastContentHeight;
+    this.lastContentHeight = contentHeight;
+    const shrinkThreshold = this.rows * 0.6;
+    const shrunkTo = this.rows * 0.4;
+    if (prevHeight > shrinkThreshold && contentHeight < shrunkTo && this.onContentShrink) {
+      setTimeout(() => this.onContentShrink?.(), 50);
+    }
+    const cx = buf.cursorX;
+    const cy = buf.cursorY;
+    const cursorHidden = this.core?.coreService?.isCursorHidden ?? false;
+    const cursorSuffix = cursorHidden ? "\x1B[?25l" : "\x1B[?25h";
+    output += this.pendingOverlay;
+    output += `\x1B[${cy + 1};${cx + 1}H${cursorSuffix}`;
+    if (output) {
+      process.stdout.write(output);
+    }
+  }
+  renderLine(line) {
+    let result = "";
+    let prevSgr = "";
+    const cell = line.getCell(0);
+    if (!cell) return line.translateToString(true);
+    for (let x = 0; x < this.cols; x++) {
+      line.getCell(x, cell);
+      if (!cell) break;
+      if (cell.getWidth() === 0) continue;
+      const sgr = this.cellSGR(cell);
+      if (sgr !== prevSgr) {
+        result += "\x1B[0m" + sgr;
+        prevSgr = sgr;
+      }
+      result += cell.getChars() || " ";
+    }
+    result += "\x1B[0m";
+    return result;
+  }
+  cellSGR(cell) {
+    let sgr = "";
+    if (cell.isBold()) sgr += "\x1B[1m";
+    if (cell.isDim()) sgr += "\x1B[2m";
+    if (cell.isItalic()) sgr += "\x1B[3m";
+    if (cell.isUnderline()) sgr += "\x1B[4m";
+    if (cell.isInverse()) sgr += "\x1B[7m";
+    if (cell.isStrikethrough()) sgr += "\x1B[9m";
+    if (cell.isFgPalette()) {
+      const fg = cell.getFgColor();
+      if (fg < 8) sgr += `\x1B[${30 + fg}m`;
+      else if (fg < 16) sgr += `\x1B[${90 + fg - 8}m`;
+      else sgr += `\x1B[38;5;${fg}m`;
+    } else if (cell.isFgRGB()) {
+      const fg = cell.getFgColor();
+      sgr += `\x1B[38;2;${fg >> 16 & 255};${fg >> 8 & 255};${fg & 255}m`;
+    }
+    if (cell.isBgPalette()) {
+      const bg = cell.getBgColor();
+      if (bg < 8) sgr += `\x1B[${40 + bg}m`;
+      else if (bg < 16) sgr += `\x1B[${100 + bg - 8}m`;
+      else sgr += `\x1B[48;5;${bg}m`;
+    } else if (cell.isBgRGB()) {
+      const bg = cell.getBgColor();
+      sgr += `\x1B[48;2;${bg >> 16 & 255};${bg >> 8 & 255};${bg & 255}m`;
+    }
+    return sgr;
+  }
+  flushOverlay() {
+    if (!this.pendingOverlay) return;
+    const buf = this.term.buffer.active;
+    const cx = buf.cursorX;
+    const cy = buf.cursorY;
+    const cursorHidden = this.core?.coreService?.isCursorHidden ?? false;
+    const cursorSuffix = cursorHidden ? "\x1B[?25l" : "\x1B[?25h";
+    process.stdout.write(
+      `\x1B[?25l${this.pendingOverlay}\x1B[${cy + 1};${cx + 1}H${cursorSuffix}`
+    );
+  }
+  writeSilent(data) {
+    const str = typeof data === "string" ? data : new TextDecoder().decode(data);
+    this.writeBuffer.writeSync(str, false);
+  }
+  renderStatusBar(statusBarEsc) {
+    const buf = this.term.buffer.active;
+    const cx = buf.cursorX;
+    const cy = buf.cursorY;
+    const cursorHidden = this.core?.coreService?.isCursorHidden ?? false;
+    const cursorSuffix = cursorHidden ? "\x1B[?25l" : "\x1B[?25h";
+    process.stdout.write(
+      `\x1B[?25l${statusBarEsc}\x1B[${cy + 1};${cx + 1}H${cursorSuffix}`
+    );
+  }
+  endsWithIncompleteEsc(str) {
+    const lastEsc = str.lastIndexOf("\x1B");
+    if (lastEsc === -1) return false;
+    const tail = str.substring(lastEsc);
+    if (tail.length === 1) return true;
+    if (tail[1] === "[") {
+      for (let i = 2; i < tail.length; i++) {
+        const c = tail.charCodeAt(i);
+        if (c >= 64 && c <= 126) return false;
+      }
+      return true;
+    }
+    if (tail[1] === "]") {
+      if (tail.includes("\x1B\\") || tail.includes("\x07")) return false;
+      return true;
+    }
+    return false;
+  }
+  /** Enter scroll mode: freeze viewport at current position, show cursor. */
+  enterScrollMode() {
+    const buf = this.term.buffer.active;
+    this.scrollOffset = 0;
+    this.scrollCursorY = buf.cursorY;
+    this.scrollCursorX = buf.cursorX;
+    this.scrollDesiredX = buf.cursorX;
+    const totalLines = buf.baseY + this.rows;
+    const currentLine = buf.baseY + this.scrollCursorY + 1;
+    const pos = `${currentLine}/${totalLines}`;
+    const sep = "\u2500".repeat(this.cols);
+    let output = "";
+    const pad = " ".repeat(this.cols);
+    output += `\x1B[${this.rows + 1};1H${pad}\x1B[${this.rows + 1};1H\x1B[90m${sep}\x1B[0m`;
+    output += `\x1B[${this.rows + 2};1H${pad}\x1B[${this.rows + 2};1H\x1B[7m [\u2191\u2193/hjkl] move  [w/b] word  [0/$] line  [g/G] top/end  [q/Esc] exit \x1B[0m`;
+    output += `\x1B[${this.rows + 2};${this.cols - pos.length - 1}H\x1B[43;30m ${pos} \x1B[0m`;
+    output += `\x1B[${this.scrollCursorY + 1};${this.scrollCursorX + 1}H\x1B[?25h`;
+    process.stdout.write(output);
+  }
+  /** Scroll up by n lines. Returns true if scrolled. */
+  scrollUp(n) {
+    const buf = this.term.buffer.active;
+    const maxScroll = buf.baseY;
+    const newOffset = Math.min(this.scrollOffset + n, maxScroll);
+    if (newOffset === this.scrollOffset) return false;
+    this.scrollOffset = newOffset;
+    this.lastFrame = [];
+    this.renderScrolled();
+    return true;
+  }
+  /** Scroll down by n lines. Returns true if scrolled. */
+  scrollDown(n) {
+    const newOffset = Math.max(this.scrollOffset - n, 0);
+    if (newOffset === this.scrollOffset) return false;
+    this.scrollOffset = newOffset;
+    this.lastFrame = [];
+    if (this.scrollOffset === 0) {
+      return true;
+    }
+    this.renderScrolled();
+    return true;
+  }
+  /** Move cursor up in scroll mode. Scrolls viewport if needed. */
+  moveCursorUp(n) {
+    this.scrollCursorY -= n;
+    if (this.scrollCursorY < 0) {
+      const overflow = -this.scrollCursorY;
+      this.scrollUp(overflow);
+      this.scrollCursorY = 0;
+    }
+    const lineLen = this.getScrollLineLength(this.scrollCursorY);
+    this.scrollCursorX = Math.min(this.scrollDesiredX, Math.max(lineLen - 1, 0));
+    this.renderScrolled();
+  }
+  /** Move cursor left. Wraps to end of previous line at col 0. */
+  moveCursorLeft(n) {
+    for (let i = 0; i < n; i++) {
+      if (this.scrollCursorX > 0) {
+        this.scrollCursorX--;
+      } else if (this.scrollCursorY > 0 || this.scrollOffset > 0) {
+        this.scrollCursorY--;
+        if (this.scrollCursorY < 0) {
+          this.scrollOffset = Math.min(this.scrollOffset + 1, this.term.buffer.active.baseY);
+          this.scrollCursorY = 0;
+          this.lastFrame = [];
+        }
+        const lineLen = this.getScrollLineLength(this.scrollCursorY);
+        this.scrollCursorX = Math.max(lineLen - 1, 0);
+      }
+    }
+    this.scrollDesiredX = this.scrollCursorX;
+    this.renderScrolled();
+  }
+  /** Move cursor right. Wraps to start of next line at end of content. */
+  moveCursorRight(n) {
+    for (let i = 0; i < n; i++) {
+      const lineLen = this.getScrollLineLength(this.scrollCursorY);
+      if (this.scrollCursorX < lineLen - 1) {
+        this.scrollCursorX++;
+      } else {
+        this.scrollCursorY++;
+        if (this.scrollCursorY >= this.rows) {
+          const overflow = this.scrollCursorY - this.rows + 1;
+          this.scrollOffset = Math.max(this.scrollOffset - overflow, 0);
+          this.scrollCursorY = this.rows - 1;
+          this.lastFrame = [];
+        }
+        this.scrollCursorX = 0;
+      }
+    }
+    this.scrollDesiredX = this.scrollCursorX;
+    this.renderScrolled();
+  }
+  /** Move cursor down in scroll mode. Scrolls viewport if needed. */
+  moveCursorDown(n) {
+    this.scrollCursorY += n;
+    if (this.scrollCursorY >= this.rows) {
+      const overflow = this.scrollCursorY - this.rows + 1;
+      this.scrollDown(overflow);
+      this.scrollCursorY = this.rows - 1;
+    }
+    const lineLen = this.getScrollLineLength(this.scrollCursorY);
+    this.scrollCursorX = Math.min(this.scrollDesiredX, Math.max(lineLen - 1, 0));
+    this.renderScrolled();
+  }
+  /** Get content length of a viewport row in scroll mode. */
+  getScrollLineLength(viewportY) {
+    const buf = this.term.buffer.active;
+    const viewStart = buf.baseY - this.scrollOffset;
+    const line = buf.getLine(viewStart + viewportY);
+    if (!line) return 0;
+    return line.translateToString(true).length;
+  }
+  /** Get text content of a viewport row in scroll mode. */
+  getScrollLineText(viewportY) {
+    const buf = this.term.buffer.active;
+    const viewStart = buf.baseY - this.scrollOffset;
+    const line = buf.getLine(viewStart + viewportY);
+    if (!line) return "";
+    return line.translateToString(true);
+  }
+  static WORD_SEPARATORS = new Set(
+    " 	`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?".split("")
+  );
+  /** Move cursor to the start of the previous word (vim b / Alt+Left). */
+  moveCursorPrevWord() {
+    const seps = _ScreenRenderer.WORD_SEPARATORS;
+    let x = this.scrollCursorX;
+    let y = this.scrollCursorY;
+    let text = this.getScrollLineText(y);
+    x--;
+    if (x < 0) {
+      if (y > 0 || this.scrollOffset > 0) {
+        y--;
+        if (y < 0) {
+          this.scrollUp(1);
+          y = 0;
+        }
+        text = this.getScrollLineText(y);
+        x = Math.max(text.length - 1, 0);
+      } else {
+        x = 0;
+      }
+    }
+    while (x >= 0 && seps.has(text[x] ?? " ")) {
+      x--;
+      if (x < 0) {
+        if (y > 0 || this.scrollOffset > 0) {
+          y--;
+          if (y < 0) {
+            this.scrollUp(1);
+            y = 0;
+          }
+          text = this.getScrollLineText(y);
+          x = Math.max(text.length - 1, 0);
+        } else {
+          x = 0;
+          break;
+        }
+      }
+    }
+    while (x > 0 && !seps.has(text[x - 1] ?? " ")) {
+      x--;
+    }
+    this.scrollCursorX = Math.max(x, 0);
+    this.scrollCursorY = y;
+    this.scrollDesiredX = this.scrollCursorX;
+    this.renderScrolled();
+  }
+  /** Move cursor to the start of the next word (vim w / Alt+Right). */
+  moveCursorNextWord() {
+    const seps = _ScreenRenderer.WORD_SEPARATORS;
+    let x = this.scrollCursorX;
+    let y = this.scrollCursorY;
+    let text = this.getScrollLineText(y);
+    const maxY = this.rows - 1;
+    while (x < text.length && !seps.has(text[x] ?? " ")) {
+      x++;
+    }
+    while (true) {
+      if (x < text.length && !seps.has(text[x] ?? " ")) break;
+      if (x >= text.length) {
+        y++;
+        if (y > maxY) {
+          this.scrollDown(1);
+          y = maxY;
+        }
+        text = this.getScrollLineText(y);
+        x = 0;
+        if (text.length === 0) continue;
+        if (!seps.has(text[0] ?? " ")) break;
+      }
+      x++;
+    }
+    this.scrollCursorX = Math.min(x, Math.max(text.length - 1, 0));
+    this.scrollCursorY = y;
+    this.scrollDesiredX = this.scrollCursorX;
+    this.renderScrolled();
+  }
+  /** Whether there's content in scrollback to view. */
+  hasScrollback() {
+    return this.term.buffer.active.baseY > 0;
+  }
+  /** Whether we're scrolled back (not showing live content). */
+  get isScrolledBack() {
+    return this.scrollOffset > 0;
+  }
+  /** Render from scrollback buffer at current offset. */
+  renderScrolled() {
+    const buf = this.term.buffer.active;
+    const viewStart = buf.baseY - this.scrollOffset;
+    const totalLines = buf.baseY + this.rows;
+    const currentLine = viewStart + this.scrollCursorY + 1;
+    let output = "";
+    const pad = " ".repeat(this.cols);
+    for (let y = 0; y < this.rows; y++) {
+      const line = buf.getLine(viewStart + y);
+      const rendered = line ? this.renderLine(line) : "";
+      output += `\x1B[${y + 1};1H${pad}\x1B[${y + 1};1H${rendered}`;
+    }
+    const pos = `${currentLine}/${totalLines}`;
+    const sep = "\u2500".repeat(this.cols);
+    output += `\x1B[${this.rows + 1};1H${pad}\x1B[${this.rows + 1};1H\x1B[90m${sep}\x1B[0m`;
+    output += `\x1B[${this.rows + 2};1H${pad}\x1B[${this.rows + 2};1H\x1B[7m [\u2191\u2193/hjkl] move  [w/b] word  [0/$] line  [g/G] top/end  [q/Esc] exit \x1B[0m`;
+    output += `\x1B[${this.rows + 2};${this.cols - pos.length - 1}H\x1B[43;30m ${pos} \x1B[0m`;
+    output += `\x1B[${this.scrollCursorY + 1};${this.scrollCursorX + 1}H\x1B[?25h`;
+    process.stdout.write(output);
+  }
+  /** Force full redraw on next render (e.g. after sidebar toggle). */
+  invalidate() {
+    this.lastFrame = [];
+    let clear = "";
+    for (let y = 0; y < this.rows; y++) {
+      clear += `\x1B[${y + 1};1H\x1B[2K`;
+    }
+    process.stdout.write(clear);
+  }
+  resize(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+    this.term.resize(cols, rows);
+    this.lastFrame = [];
+  }
+  dispose() {
+    if (this.overlayTimer) clearImmediate(this.overlayTimer);
+    if (this.renderTimer) clearTimeout(this.renderTimer);
+    process.stdout.write("\x1B[?25h");
+    this.term.dispose();
+  }
+};
+export {
+  ScreenRenderer
+};
+//# sourceMappingURL=screen-renderer.js.map