@jx0/jmux 0.1.0

package/src/__tests__/renderer.test.ts

@@ -0,0 +1,112 @@
+import { describe, test, expect } from "bun:test";
+import { sgrForCell, compositeGrids, BORDER_CHAR } from "../renderer";
+import { createGrid, writeString } from "../cell-grid";
+import { ColorMode } from "../types";
+import type { Cell } from "../types";
+
+describe("sgrForCell", () => {
+  test("returns reset only for default cell", () => {
+    const cell: Cell = {
+      char: " ",
+      fg: 0, bg: 0,
+      fgMode: ColorMode.Default, bgMode: ColorMode.Default,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0m");
+  });
+
+  test("includes bold attribute", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 0, bg: 0,
+      fgMode: ColorMode.Default, bgMode: ColorMode.Default,
+      bold: true, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;1m");
+  });
+
+  test("encodes standard ANSI foreground color 0-7", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 1, bg: 0,
+      fgMode: ColorMode.Palette, bgMode: ColorMode.Default,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;31m");
+  });
+
+  test("encodes bright ANSI foreground color 8-15", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 9, bg: 0,
+      fgMode: ColorMode.Palette, bgMode: ColorMode.Default,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;91m");
+  });
+
+  test("encodes 256-color foreground", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 200, bg: 0,
+      fgMode: ColorMode.Palette, bgMode: ColorMode.Default,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;38;5;200m");
+  });
+
+  test("encodes RGB foreground", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 0xFF8800, bg: 0,
+      fgMode: ColorMode.RGB, bgMode: ColorMode.Default,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;38;2;255;136;0m");
+  });
+
+  test("encodes background color", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 0, bg: 4,
+      fgMode: ColorMode.Default, bgMode: ColorMode.Palette,
+      bold: false, italic: false, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;44m");
+  });
+
+  test("encodes combined attributes and colors", () => {
+    const cell: Cell = {
+      char: "x",
+      fg: 2, bg: 0,
+      fgMode: ColorMode.Palette, bgMode: ColorMode.Default,
+      bold: true, italic: true, underline: false, dim: false,
+    };
+    expect(sgrForCell(cell)).toBe("\x1b[0;1;3;32m");
+  });
+});
+
+describe("compositeGrids", () => {
+  test("returns main grid only when no sidebar", () => {
+    const main = createGrid(10, 3);
+    writeString(main, 0, 0, "hello");
+    const result = compositeGrids(main, null);
+    expect(result.cols).toBe(10);
+    expect(result.cells[0][0].char).toBe("h");
+  });
+
+  test("composites sidebar + border + main", () => {
+    const sidebar = createGrid(4, 2);
+    writeString(sidebar, 0, 0, "side");
+    const main = createGrid(6, 2);
+    writeString(main, 0, 0, "main!!");
+    const result = compositeGrids(main, sidebar);
+    // sidebar: 4 cols + border: 1 col + main: 6 cols = 11 cols
+    expect(result.cols).toBe(11);
+    expect(result.cells[0][0].char).toBe("s");
+    expect(result.cells[0][3].char).toBe("e");
+    expect(result.cells[0][4].char).toBe(BORDER_CHAR);
+    expect(result.cells[0][5].char).toBe("m");
+    expect(result.cells[0][10].char).toBe("!");
+  });
+});

package/src/__tests__/screen-bridge.test.ts

@@ -0,0 +1,61 @@
+import { describe, test, expect } from "bun:test";
+import { ScreenBridge } from "../screen-bridge";
+import { ColorMode } from "../types";
+
+describe("ScreenBridge", () => {
+  test("returns empty grid with spaces before any writes", () => {
+    const bridge = new ScreenBridge(10, 5);
+    const grid = bridge.getGrid();
+    expect(grid.cols).toBe(10);
+    expect(grid.rows).toBe(5);
+    expect(grid.cells[0][0].char).toBe(" ");
+  });
+
+  test("captures plain text written to terminal", async () => {
+    const bridge = new ScreenBridge(10, 3);
+    await bridge.write("Hello");
+    const grid = bridge.getGrid();
+    expect(grid.cells[0][0].char).toBe("H");
+    expect(grid.cells[0][1].char).toBe("e");
+    expect(grid.cells[0][2].char).toBe("l");
+    expect(grid.cells[0][3].char).toBe("l");
+    expect(grid.cells[0][4].char).toBe("o");
+    expect(grid.cells[0][5].char).toBe(" ");
+  });
+
+  test("captures bold SGR attribute", async () => {
+    const bridge = new ScreenBridge(10, 3);
+    await bridge.write("\x1b[1mBold\x1b[0m");
+    const grid = bridge.getGrid();
+    expect(grid.cells[0][0].char).toBe("B");
+    expect(grid.cells[0][0].bold).toBe(true);
+    expect(grid.cells[0][3].char).toBe("d");
+    expect(grid.cells[0][3].bold).toBe(true);
+  });
+
+  test("captures foreground palette color", async () => {
+    const bridge = new ScreenBridge(10, 3);
+    // SGR 31 = red foreground (ANSI color 1)
+    await bridge.write("\x1b[31mRed\x1b[0m");
+    const grid = bridge.getGrid();
+    expect(grid.cells[0][0].char).toBe("R");
+    expect(grid.cells[0][0].fg).toBe(1);
+    expect(grid.cells[0][0].fgMode).toBe(ColorMode.Palette);
+  });
+
+  test("reports cursor position", async () => {
+    const bridge = new ScreenBridge(10, 3);
+    await bridge.write("Hi");
+    const cursor = bridge.getCursor();
+    expect(cursor.x).toBe(2);
+    expect(cursor.y).toBe(0);
+  });
+
+  test("handles resize", async () => {
+    const bridge = new ScreenBridge(10, 3);
+    bridge.resize(20, 5);
+    const grid = bridge.getGrid();
+    expect(grid.cols).toBe(20);
+    expect(grid.rows).toBe(5);
+  });
+});

package/src/__tests__/sidebar.test.ts

@@ -0,0 +1,237 @@
+import { describe, test, expect } from "bun:test";
+import { Sidebar } from "../sidebar";
+import type { SessionInfo } from "../types";
+
+const SIDEBAR_WIDTH = 24;
+
+function makeSessions(
+  entries: Array<{ name: string; directory?: string; gitBranch?: string }>,
+): SessionInfo[] {
+  return entries.map((e, i) => ({
+    id: `$${i}`,
+    name: e.name,
+    attached: i === 0,
+    activity: 0,
+    attention: false,
+    windowCount: 1,
+    directory: e.directory,
+    gitBranch: e.gitBranch,
+  }));
+}
+
+describe("Sidebar", () => {
+  test("renders header row", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(makeSessions([{ name: "main" }]));
+    const grid = sidebar.getGrid();
+    const headerText = Array.from(
+      { length: 4 },
+      (_, i) => grid.cells[0][1 + i].char,
+    ).join("");
+    expect(headerText).toBe("jmux");
+  });
+
+  test("renders ungrouped sessions without a group header", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "alpha", directory: "~/one" },
+        { name: "beta", directory: "~/two" },
+      ]),
+    );
+    const grid = sidebar.getGrid();
+    // No shared parent → ungrouped, sessions start at row 2
+    const row2 = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[2][i].char,
+    ).join("");
+    expect(row2).toContain("alpha");
+  });
+
+  test("groups sessions sharing a parent directory", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "api", directory: "~/Code/work/api" },
+        { name: "frontend", directory: "~/Code/work/frontend" },
+        { name: "scratch", directory: "/tmp" },
+      ]),
+    );
+    const grid = sidebar.getGrid();
+    // Row 2: group header "Code/work"
+    const headerRow = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[2][i].char,
+    ).join("");
+    expect(headerRow).toContain("Code/work");
+    // Row 3: first session in group "api"
+    const apiRow = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[3][i].char,
+    ).join("");
+    expect(apiRow).toContain("api");
+  });
+
+  test("solo sessions in a directory are ungrouped", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "only-one", directory: "~/Code/work/only-one" },
+        { name: "other", directory: "~/somewhere/other" },
+      ]),
+    );
+    const grid = sidebar.getGrid();
+    // Neither has a sibling → no group headers, just sessions
+    const row2 = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[2][i].char,
+    ).join("");
+    // Should contain a session name, not a group header
+    expect(row2).toContain("only-one");
+  });
+
+  test("grouped sessions show branch but not directory on detail line", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        {
+          name: "api",
+          directory: "~/Code/work/api",
+          gitBranch: "main",
+        },
+        {
+          name: "web",
+          directory: "~/Code/work/web",
+          gitBranch: "feat/x",
+        },
+      ]),
+    );
+    const grid = sidebar.getGrid();
+    // Find the detail row for "api" (row after "api" name row)
+    // Row 2: group header, Row 3: api name, Row 4: api detail
+    const detailRow = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[4][i].char,
+    ).join("");
+    expect(detailRow).toContain("main");
+    expect(detailRow).not.toContain("Code/work");
+  });
+
+  test("ungrouped sessions show directory on detail line", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "solo", directory: "~/mydir", gitBranch: "dev" },
+      ]),
+    );
+    const grid = sidebar.getGrid();
+    // Row 2: session name, Row 3: detail
+    const detailRow = Array.from(
+      { length: SIDEBAR_WIDTH },
+      (_, i) => grid.cells[3][i].char,
+    ).join("");
+    expect(detailRow).toContain("~/mydir");
+    expect(detailRow).toContain("dev");
+  });
+
+  test("highlights active session with green marker", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([{ name: "main" }, { name: "dev" }]),
+    );
+    sidebar.setActiveSession("$0");
+    const grid = sidebar.getGrid();
+    // Find the active session's name row and check for marker
+    let foundMarker = false;
+    for (let r = 2; r < 20; r++) {
+      if (grid.cells[r][0].char === "\u258e") {
+        foundMarker = true;
+        break;
+      }
+    }
+    expect(foundMarker).toBe(true);
+  });
+
+  test("shows activity indicator", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(makeSessions([{ name: "main" }]));
+    sidebar.setActivity("$0", true);
+    const grid = sidebar.getGrid();
+    let foundDot = false;
+    for (let r = 2; r < 20; r++) {
+      if (grid.cells[r][1].char === "\u25CF") {
+        foundDot = true;
+        break;
+      }
+    }
+    expect(foundDot).toBe(true);
+  });
+
+  test("shows attention flag", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    const sessions = makeSessions([{ name: "main" }]);
+    sessions[0].attention = true;
+    sidebar.updateSessions(sessions);
+    const grid = sidebar.getGrid();
+    let foundBang = false;
+    for (let r = 2; r < 20; r++) {
+      if (grid.cells[r][1].char === "!") {
+        foundBang = true;
+        break;
+      }
+    }
+    expect(foundBang).toBe(true);
+  });
+
+  test("getDisplayOrderIds returns sessions in grouped display order", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "c" },
+        { name: "a" },
+        { name: "b" },
+      ]),
+    );
+    const ids = sidebar.getDisplayOrderIds();
+    // Ungrouped, sorted alphabetically by name
+    expect(ids).toEqual(["$1", "$2", "$0"]); // a, b, c
+  });
+
+  test("getSessionByRow returns correct session for click handling", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    sidebar.updateSessions(
+      makeSessions([
+        { name: "api", directory: "~/Code/work/api" },
+        { name: "web", directory: "~/Code/work/web" },
+      ]),
+    );
+    sidebar.getGrid(); // must render to populate row map
+
+    // Row 2: group header → null
+    expect(sidebar.getSessionByRow(2)).toBeNull();
+    // Row 3: first session name row → api
+    expect(sidebar.getSessionByRow(3)?.name).toBe("api");
+    // Row 4: first session detail row → api
+    expect(sidebar.getSessionByRow(4)?.name).toBe("api");
+  });
+
+  test("shows window count", () => {
+    const sidebar = new Sidebar(SIDEBAR_WIDTH, 30);
+    const sessions = makeSessions([{ name: "main" }]);
+    sessions[0].windowCount = 5;
+    sidebar.updateSessions(sessions);
+    const grid = sidebar.getGrid();
+    let found = false;
+    for (let r = 2; r < 10; r++) {
+      const text = Array.from(
+        { length: SIDEBAR_WIDTH },
+        (_, i) => grid.cells[r][i].char,
+      ).join("");
+      if (text.includes("5w")) {
+        found = true;
+        break;
+      }
+    }
+    expect(found).toBe(true);
+  });
+});

package/src/__tests__/tmux-control.test.ts

@@ -0,0 +1,142 @@
+import { describe, test, expect } from "bun:test";
+import { ControlParser, type ControlEvent } from "../tmux-control";
+
+describe("ControlParser", () => {
+  test("emits sessions-changed notification", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%sessions-changed\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("sessions-changed");
+  });
+
+  test("emits session-changed notification", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%session-changed $3\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("session-changed");
+    if (events[0].type === "session-changed") {
+      expect(events[0].args).toBe("$3");
+    }
+  });
+
+  test("collects response block between %begin and %end", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%begin 1234 721599 1\n");
+    parser.feed("line one\n");
+    parser.feed("line two\n");
+    parser.feed("%end 1234 721599 1\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("response");
+    if (events[0].type === "response") {
+      expect(events[0].commandNumber).toBe(721599);
+      expect(events[0].flags).toBe(1);
+      expect(events[0].lines).toEqual(["line one", "line two"]);
+    }
+  });
+
+  test("emits error response on %error", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%begin 1234 2 1\n");
+    parser.feed("something bad\n");
+    parser.feed("%error 1234 2 1\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("error");
+    if (events[0].type === "error") {
+      expect(events[0].commandNumber).toBe(2);
+      expect(events[0].flags).toBe(1);
+      expect(events[0].lines).toEqual(["something bad"]);
+    }
+  });
+
+  test("parses flags field from %begin/%end", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    // flags=0 means response is NOT from this client (e.g. initial attach)
+    parser.feed("%begin 1234 100 0\n");
+    parser.feed("%end 1234 100 0\n");
+
+    // flags=1 means response IS from this client
+    parser.feed("%begin 1234 200 1\n");
+    parser.feed("data\n");
+    parser.feed("%end 1234 200 1\n");
+
+    expect(events.length).toBe(2);
+    if (events[0].type === "response") {
+      expect(events[0].flags).toBe(0);
+    }
+    if (events[1].type === "response") {
+      expect(events[1].flags).toBe(1);
+    }
+  });
+
+  test("emits subscription-changed notification", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%subscription-changed attention main=1 dev=\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("subscription-changed");
+    if (events[0].type === "subscription-changed") {
+      expect(events[0].name).toBe("attention");
+      expect(events[0].value).toBe("main=1 dev=");
+    }
+  });
+
+  test("handles partial lines across multiple feeds", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%sessions");
+    expect(events.length).toBe(0);
+    parser.feed("-changed\n");
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("sessions-changed");
+  });
+
+  test("handles multiple lines in single feed", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%sessions-changed\n%session-changed $1\n");
+
+    expect(events.length).toBe(2);
+    expect(events[0].type).toBe("sessions-changed");
+    expect(events[1].type).toBe("session-changed");
+  });
+
+  test("emits window-renamed notification", () => {
+    const parser = new ControlParser();
+    const events: ControlEvent[] = [];
+    parser.onEvent((e) => events.push(e));
+
+    parser.feed("%window-renamed @0 bash\n");
+
+    expect(events.length).toBe(1);
+    expect(events[0].type).toBe("window-renamed");
+    if (events[0].type === "window-renamed") {
+      expect(events[0].args).toBe("@0 bash");
+    }
+  });
+});

package/src/cell-grid.ts

@@ -0,0 +1,63 @@
+import type { Cell, CellGrid } from "./types";
+import { ColorMode } from "./types";
+
+export const DEFAULT_CELL: Readonly<Cell> = {
+  char: " ",
+  fg: 0,
+  bg: 0,
+  fgMode: ColorMode.Default,
+  bgMode: ColorMode.Default,
+  bold: false,
+  italic: false,
+  underline: false,
+  dim: false,
+};
+
+export function createGrid(cols: number, rows: number): CellGrid {
+  const cells: Cell[][] = [];
+  for (let r = 0; r < rows; r++) {
+    const row: Cell[] = [];
+    for (let c = 0; c < cols; c++) {
+      row.push({ ...DEFAULT_CELL });
+    }
+    cells.push(row);
+  }
+  return { cols, rows, cells };
+}
+
+export interface CellAttrs {
+  fg?: number;
+  bg?: number;
+  fgMode?: ColorMode;
+  bgMode?: ColorMode;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+  dim?: boolean;
+}
+
+export function writeString(
+  grid: CellGrid,
+  row: number,
+  col: number,
+  text: string,
+  attrs?: CellAttrs,
+): void {
+  if (row < 0 || row >= grid.rows) return;
+  for (let i = 0; i < text.length; i++) {
+    const c = col + i;
+    if (c < 0 || c >= grid.cols) continue;
+    const cell = grid.cells[row][c];
+    cell.char = text[i];
+    if (attrs) {
+      if (attrs.fg !== undefined) cell.fg = attrs.fg;
+      if (attrs.bg !== undefined) cell.bg = attrs.bg;
+      if (attrs.fgMode !== undefined) cell.fgMode = attrs.fgMode;
+      if (attrs.bgMode !== undefined) cell.bgMode = attrs.bgMode;
+      if (attrs.bold !== undefined) cell.bold = attrs.bold;
+      if (attrs.italic !== undefined) cell.italic = attrs.italic;
+      if (attrs.underline !== undefined) cell.underline = attrs.underline;
+      if (attrs.dim !== undefined) cell.dim = attrs.dim;
+    }
+  }
+}

package/src/input-router.ts

@@ -0,0 +1,85 @@
+export interface SgrMouseEvent {
+  button: number;
+  x: number;
+  y: number;
+  release: boolean;
+}
+
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+
+export function parseSgrMouse(seq: string): SgrMouseEvent | null {
+  const match = seq.match(SGR_MOUSE_RE);
+  if (!match) return null;
+  return {
+    button: parseInt(match[1], 10),
+    x: parseInt(match[2], 10),
+    y: parseInt(match[3], 10),
+    release: match[4] === "m",
+  };
+}
+
+export function translateMouseX(
+  seq: string,
+  offset: number,
+): string | null {
+  const match = seq.match(SGR_MOUSE_RE);
+  if (!match) return null;
+  const newX = parseInt(match[2], 10) - offset;
+  if (newX <= 0) return null;
+  return `\x1b[<${match[1]};${newX};${match[3]}${match[4]}`;
+}
+
+export interface InputRouterOptions {
+  sidebarCols: number;
+  onPtyData: (data: string) => void;
+  onSidebarClick: (row: number) => void;
+  onSessionPrev?: () => void;
+  onSessionNext?: () => void;
+}
+
+export class InputRouter {
+  private opts: InputRouterOptions;
+  private sidebarVisible: boolean;
+
+  constructor(opts: InputRouterOptions, sidebarVisible: boolean) {
+    this.opts = opts;
+    this.sidebarVisible = sidebarVisible;
+  }
+
+  setSidebarVisible(visible: boolean): void {
+    this.sidebarVisible = visible;
+  }
+
+  handleInput(data: string): void {
+    // Always-active hotkeys: Ctrl-Shift-Up/Down for session switching
+    if (data === "\x1b[1;6A") {
+      this.opts.onSessionPrev?.();
+      return;
+    }
+    if (data === "\x1b[1;6B") {
+      this.opts.onSessionNext?.();
+      return;
+    }
+
+    // Check for SGR mouse events
+    const mouse = parseSgrMouse(data);
+    if (mouse && this.sidebarVisible) {
+      if (mouse.x <= this.opts.sidebarCols) {
+        // Click in sidebar region
+        if (!mouse.release) {
+          this.opts.onSidebarClick(mouse.y - 1); // 0-indexed row
+        }
+        return; // Consume sidebar mouse events
+      }
+      // Mouse in main area — translate X coordinate
+      const translated = translateMouseX(data, this.opts.sidebarCols + 1);
+      if (translated) {
+        this.opts.onPtyData(translated);
+      }
+      return;
+    }
+
+    // Default: pass through to PTY
+    this.opts.onPtyData(data);
+  }
+}