buninu-linux 0.4.0 → 0.6.0

package/initramfs/init.js

@@ -2,9 +2,19 @@ console.log("init.js: Bun runtime entered JavaScript");
 
 const { dlopen, FFIType, ptr, read } = await import("bun:ffi");
 
-console.log("init.js: loading physical musl libc for FFI");
-
-const libc = dlopen("/lib/libc.musl-x86_64.so.1", {
+// The musl file name and the number of finit_module, which musl has no
+// wrapper for, are all that differs per CPU in this file. /lib/dlopen.js has
+// the same table for the commands; it is repeated rather than imported so
+// that nothing but bun:ffi loads before the mounts below.
+const architecture = {
+  x64: { libc: "libc.musl-x86_64.so.1", SYS_finit_module: 313 },
+  arm64: { libc: "libc.musl-aarch64.so.1", SYS_finit_module: 273 },
+}[process.arch];
+if (!architecture) throw new Error(`init.js: unsupported CPU architecture ${process.arch}`);
+
+console.log(`init.js: loading physical musl libc /lib/${architecture.libc} for FFI`);
+
+const libc = dlopen(`/lib/${architecture.libc}`, {
   mount: {
     args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.u64, FFIType.ptr],
     returns: FFIType.i32,
@@ -94,6 +104,81 @@ const mountFilesystems = () => {
 mountFilesystems();
 console.log("init.js: mounted /proc, /sys, /dev, /tmp, /dev/pts");
 
+// Num Lock. The keypad's lock state lives per virtual console in the
+// kernel's keyboard table, and the kernel starts every console with it off,
+// so the keypad types arrows instead of digits. KDSKBLED carries the current
+// flags in its low nibble and the ones a console is reset to in its high
+// nibble; KDSETLED with a value above 7 puts the physical LED back to
+// following those flags. A console allocated later (Ctrl-Alt-F3 for the
+// first time) starts from the kernel default again, so numlock() is left in
+// the REPL for that case.
+const KDSETLED = 0x4b32;
+const KDGKBLED = 0x4b64;
+const KDSKBLED = 0x4b65;
+const LED_NUM = 0x02;
+
+// Nothing here is essential to booting, so a console that is not a virtual
+// terminal, a missing device node or a rejected ioctl is skipped rather than
+// reported: the remaining consoles are still set, and the system comes up
+// either way.
+const setNumLock = (enabled = true) => {
+  const consoles = [];
+  const paths = ["/dev/tty0", "/dev/console", "/dev/tty"];
+  for (let index = 1; index <= 12; index++) paths.push(`/dev/tty${index}`);
+  for (const path of paths) {
+    let fd = -1;
+    try {
+      fd = libc.symbols.open(cString(path), 2, 0);
+      if (fd < 0) continue;
+      const state = new Uint8Array(1);
+      if (libc.symbols.ioctl(fd, KDGKBLED, ptr(state)) !== 0) continue;
+      const current = enabled ? state[0] | LED_NUM : state[0] & ~LED_NUM;
+      const fallback = enabled ? (state[0] >> 4) | LED_NUM : (state[0] >> 4) & ~LED_NUM;
+      const flags = (current & 7) | ((fallback & 7) << 4);
+      if (libc.symbols.ioctl(fd, KDSKBLED, flags) !== 0) continue;
+      libc.symbols.ioctl(fd, KDSETLED, 0x80);
+      consoles.push(path);
+    } catch {
+      // This console keeps whatever state it had; the others still get set.
+    } finally {
+      if (fd >= 0) {
+        try { libc.symbols.close(fd); } catch {}
+      }
+    }
+  }
+  return consoles;
+};
+
+globalThis.numlock = setNumLock;
+try {
+  const consoles = setNumLock(true);
+  console.log(consoles.length
+    ? `init.js: num lock on (${consoles.join(" ")})`
+    : "init.js: no virtual console accepted a num lock setting");
+} catch (error) {
+  console.error(`init.js: num lock: ${error?.message ?? error}`);
+}
+
+// The input layer's character devices, so a pointing device has a
+// /dev/input/event* node for `bunterm --mouse` to read. Loading them only
+// creates those nodes: the console keyboard is unaffected, and nothing reads
+// a pointer unless it is asked to. psmouse is the PS/2 mouse of a PC or q35;
+// QEMU's aarch64 virt machine has virtio-input instead. Each image ships only
+// the one its machine has, and tryModprobe skips the other. A USB mouse also
+// needs the usbhid stack, which `cfg.all` or a --real boot brings in.
+try {
+  const { tryModprobe } = await import("/lib/modprobe.js");
+  const loaded = ["evdev", "psmouse", "virtio_input"].filter((module) => tryModprobe(module) !== null);
+  const { readdirSync } = await import("node:fs");
+  const devices = (() => {
+    try { return readdirSync("/dev/input").filter((name) => name.startsWith("event")); } catch { return []; }
+  })();
+  console.log(`init.js: input modules ${loaded.length ? loaded.join(" ") : "none"}`
+    + ` (${devices.length} event device${devices.length === 1 ? "" : "s"})`);
+} catch (error) {
+  console.error(`init.js: input modules: ${error?.message ?? error}`);
+}
+
 const { default: repl } = await import("node:repl");
 const { mkdirSync, writeFileSync } = await import("node:fs");
 
@@ -117,7 +202,11 @@ const loadModule = (path) => {
     const parameters = cString("");
     // -EEXIST is harmless when firmware or another module loaded it first.
     // musl has no finit_module wrapper, so use its generic syscall(2).
-    check(`finit_module(${path})`, libc.symbols.syscall(313, fd, ptr(parameters), 0), [-17]);
+    check(
+      `finit_module(${path})`,
+      libc.symbols.syscall(architecture.SYS_finit_module, fd, ptr(parameters), 0),
+      [-17],
+    );
   } finally {
     libc.symbols.close(fd);
   }
@@ -158,21 +247,14 @@ const bringUpLoopback = () => {
   }
 };
 
-const configureQemuNetwork = () => {
-  const release = process.env.KERNEL_RELEASE ?? "6.18.52-0-virt";
-  const modules = [
-    `lib/modules/${release}/kernel/net/core/failover.ko`,
-    `lib/modules/${release}/kernel/drivers/net/net_failover.ko`,
-    `lib/modules/${release}/kernel/drivers/net/virtio_net.ko`,
-  ];
-  if (release.endsWith("-lts")) modules.unshift(
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_ring.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci_legacy_dev.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci_modern_dev.ko`,
-    `lib/modules/${release}/kernel/drivers/virtio/virtio_pci.ko`,
-  );
-  for (const module of modules) loadModule(`/${module}`);
+// Which virtio pieces are modules differs per kernel flavor and CPU (linux-lts
+// has virtio_pci as a module, linux-virt builds it in), so /lib/modprobe.js
+// resolves them from the shipped modules.dep and modules.builtin: the PCI
+// transport first, since nothing in modules.dep depends on it, then the NIC.
+const configureQemuNetwork = async () => {
+  const { modprobe, tryModprobe } = await import("/lib/modprobe.js");
+  tryModprobe("virtio_pci");
+  modprobe("virtio_net");
 
   const fd = check("socket(AF_INET, SOCK_DGRAM)", libc.symbols.socket(2, 2, 0));
   const ioctl = (request, value, operation) =>
@@ -191,8 +273,9 @@ const configureQemuNetwork = () => {
 
     bringUp(ioctl, "eth0");
 
-    // struct rtentry on Linux x86_64. Only gateway and flags are needed for
-    // the default route; rt_dst and rt_genmask remain 0.0.0.0.
+    // struct rtentry on 64-bit Linux, the same on x86_64 and aarch64. Only
+    // gateway and flags are needed for the default route; rt_dst and
+    // rt_genmask remain 0.0.0.0.
     const route = new Uint8Array(120);
     const routeView = new DataView(route.buffer);
     writeSockaddrIpv4(route, 8, "0.0.0.0");
@@ -286,7 +369,7 @@ try {
 
 
 try {
-  configureQemuNetwork();
+  await configureQemuNetwork();
   console.log("network: eth0 10.0.2.15/24 via 10.0.2.2");
   const response = await fetch("http://example.com");
   console.log(`fetch example.com: HTTP ${response.status}, ${response.headers.get("content-type")}`);
@@ -339,7 +422,9 @@ const launchBunmsh = () => {
 
 
 
-const launchBuninu = () => {
+let replServer = null;
+
+const launchBuninu = async () => {
 
   console.log(`
 Type bunterm in bunmsh: Graphical Terminal
@@ -347,22 +432,36 @@ Type bunterm in bunmsh: Graphical Terminal
   Supports Kitty Graphics Protocol
 `)
 
+  const classic_path = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+  
+  const buninu_path = "/buninu/.local/bin:/buninu/.bun/bin:/buninu/bin"
+
   const entry = `/buninu/bin/init.js`;
   console.log(`buninu: Starting ${entry} --local`);
-  const shell = Bun.spawnSync([
-    "/bin/bun", entry, "--local"
-  ], {
-    env: {
-      ...process.env,
-      PATH:"/bin:/usr/bin:/buninu/bin",
-      HOME:"/buninu"
-    },
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-  console.log(`buninu exited with status ${shell.exitCode}; returning to Bun REPL.`);
-  return shell.exitCode;
+  replServer?.pause();
+  try {
+    const shell = Bun.spawn([
+      "/bin/bun", entry, "--local"
+    ], {
+      env: {
+        ...process.env,
+        PATH:  classic_path + ":" +
+               buninu_path,
+        HOME:"/buninu"
+      },
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const exitCode = await shell.exited;
+    console.log(`buninu exited with status ${exitCode}; returning to Bun REPL.`);
+    return exitCode;
+  } finally {
+    // The child inherits the console directly. Keep the REPL from consuming
+    // the same input while it runs, but leave PID 1's event loop alive so its
+    // SIGCHLD handler can reap orphaned grandchildren such as Chromium.
+    replServer?.resume();
+  }
   
 }
 
@@ -478,12 +577,24 @@ Type start() to run buninu --local`);
 showWelcome();
 
 const startRepl = () => {
-  const server = repl.start({
+  const server = replServer = repl.start({
     prompt: "bun-repl> ",
     input: process.stdin,
     output: process.stdout,
     terminal: true,
   });
+  // `start()` returns a promise so PID 1's event loop can keep reaping
+  // children. Make the two convenient whole-line forms foreground commands;
+  // otherwise the REPL finishes evaluating the pending promise and resumes
+  // itself, competing with Buninu for the console input.
+  const defaultEval = server.eval.bind(server);
+  server.eval = (command, context, filename, callback) => {
+    const trimmed = command.trim();
+    if (trimmed === "start" || /^start\s*\(\s*\)\s*;?$/.test(trimmed)) {
+      command = "await start()\n";
+    }
+    return defaultEval(command, context, filename, callback);
+  };
   // Run before REPL's own line listener so its next prompt is printed after
   // the repeated welcome. Empty and whitespace-only lines both trigger it.
   server.prependListener("line", (line) => {

package/initramfs/lib/bunterm/images.js

@@ -53,6 +53,7 @@ export class ImageStore {
     this.term = term;
     this.renderer = renderer;
     this.images = new Map();      // image id → Skia Image
+    this.imageSources = new Map(); // image id → parser image object
     this.placements = new Map();  // placement key → placement
     this.counter = 0;
     this.coveredKey = "";
@@ -70,14 +71,26 @@ export class ImageStore {
     if (graphic.kind !== "placement") return "";
     const { control, image } = graphic;
     let decoded = this.images.get(image.id);
-    if (!decoded) {
+    const replacesImage = decoded && this.imageSources.get(image.id) !== image;
+    if (!decoded || replacesImage) {
       try {
-        decoded = await decodeImage(this.CanvasKit, image);
+        const replacement = await decodeImage(this.CanvasKit, image);
+        if (replacesImage) {
+          // Kitty requires retransmitting a non-zero image id to delete the
+          // old image and all its placements.  Screen-streaming clients such
+          // as casty deliberately reuse one id for every frame.
+          for (const placement of [...this.placements.values()]) {
+            if (placement.imageId === image.id) this.dispose(placement);
+          }
+          decoded.delete();
+        }
+        decoded = replacement;
       } catch (error) {
         graphic.responseMessage = `EBADPNG:${error.message}`;
         return "";
       }
       this.images.set(image.id, decoded);
+      this.imageSources.set(image.id, image);
     }
     const { cellWidth, cellHeight } = this.renderer;
     const buffer = this.term.buffer.active;
@@ -169,6 +182,7 @@ export class ImageStore {
         if (!used.has(id)) {
           image.delete();
           this.images.delete(id);
+          this.imageSources.delete(id);
         }
       }
     }
@@ -221,5 +235,6 @@ export class ImageStore {
     this.placements.clear();
     for (const image of this.images.values()) image.delete();
     this.images.clear();
+    this.imageSources.clear();
   }
 }

package/initramfs/lib/bunterm/mouse.js

@@ -0,0 +1,222 @@
+// /lib/bunterm/mouse.js — pointing devices through the Linux input layer.
+//
+// Read from /dev/input/event*, where the kernel reports one 24-byte
+// input_event per axis, button or wheel notch, ending each batch with an
+// EV_SYN. Relative devices (a mouse) move the pointer by their deltas;
+// absolute ones (QEMU's USB tablet, a touchscreen) place it directly, which
+// needs the axis range from EVIOCGABS. This module is only loaded when
+// bunterm is asked for a mouse.
+
+import { closeSync, existsSync, openSync, read, readFileSync, readdirSync } from "node:fs";
+import { libc, ptr } from "../dlopen.js";
+
+const EVENT_SIZE = 24;
+const EV_SYN = 0x00;
+const EV_KEY = 0x01;
+const EV_REL = 0x02;
+const EV_ABS = 0x03;
+const REL_X = 0x00;
+const REL_Y = 0x01;
+const REL_WHEEL = 0x08;
+const REL_HWHEEL = 0x06;
+const ABS_X = 0x00;
+const ABS_Y = 0x01;
+const BTN_LEFT = 0x110;
+const BTN_RIGHT = 0x111;
+const BTN_MIDDLE = 0x112;
+const BTN_TOUCH = 0x14a;
+
+// struct input_absinfo { s32 value, minimum, maximum, fuzz, flat, resolution }
+const EVIOCGABS = (axis) => 0x80184540 + axis;
+
+const buttonNames = {
+  [BTN_LEFT]: "left",
+  [BTN_RIGHT]: "right",
+  [BTN_MIDDLE]: "middle",
+  [BTN_TOUCH]: "left",
+};
+
+const capability = (directory, name) => {
+  try {
+    // A capability file is a space-separated list of 64-bit hex words, most
+    // significant first, so the last word holds bits 0-63.
+    const words = readFileSync(`${directory}/${name}`, "utf8").trim().split(/\s+/u).reverse();
+    return (bit) => {
+      const word = words[Math.floor(bit / 64)];
+      return word ? (BigInt(`0x${word}`) >> BigInt(bit % 64)) & 1n ? true : false : false;
+    };
+  } catch {
+    return () => false;
+  }
+};
+
+// Every /dev/input/event* that looks like a pointer, with how it reports
+// position. A device with both relative and absolute axes counts as absolute.
+export const findPointers = (directory = "/dev/input") => {
+  const found = [];
+  let names = [];
+  try {
+    names = readdirSync(directory).filter((name) => /^event\d+$/u.test(name));
+  } catch {
+    return found;
+  }
+  for (const name of names.sort()) {
+    const sysfs = `/sys/class/input/${name}/device/capabilities`;
+    if (!existsSync(sysfs)) continue;
+    const relative = capability(sysfs, "rel");
+    const absolute = capability(sysfs, "abs");
+    const keys = capability(sysfs, "key");
+    const hasRelative = relative(REL_X) && relative(REL_Y);
+    const hasAbsolute = absolute(ABS_X) && absolute(ABS_Y);
+    const hasButton = keys(BTN_LEFT) || keys(BTN_TOUCH);
+    if (!hasButton || (!hasRelative && !hasAbsolute)) continue;
+    let label = name;
+    try {
+      label = readFileSync(`/sys/class/input/${name}/device/name`, "utf8").trim() || name;
+    } catch {}
+    found.push({
+      path: `${directory}/${name}`,
+      name: label,
+      kind: hasAbsolute ? "absolute" : "relative",
+      wheel: relative(REL_WHEEL),
+    });
+  }
+  return found;
+};
+
+const absoluteRange = (fd, axis) => {
+  const info = new Int32Array(6);
+  if (libc.symbols.ioctl(fd, EVIOCGABS(axis), ptr(info)) === -1) return null;
+  const [, minimum, maximum] = info;
+  return maximum > minimum ? { minimum, maximum } : null;
+};
+
+// Opens every pointer in `devices` and reports the pointer state after each
+// EV_SYN: { x, y, buttons: { left, middle, right }, wheel, hwheel, moved,
+// pressed, released }. Coordinates are pixels clamped to width x height.
+// `speed` scales relative motion. close() releases the devices.
+export const openPointer = ({
+  devices = findPointers(),
+  width,
+  height,
+  speed = 1,
+  x = Math.floor(width / 2),
+  y = Math.floor(height / 2),
+  onSync,
+  onError = () => {},
+}) => {
+  const state = {
+    x, y,
+    buttons: { left: false, middle: false, right: false },
+    wheel: 0,
+    hwheel: 0,
+    moved: false,
+    pressed: [],
+    released: [],
+  };
+  const open = [];
+
+  for (const device of devices) {
+    let fd = -1;
+    try {
+      fd = openSync(device.path, "r");
+      const ranges = device.kind === "absolute"
+        ? { x: absoluteRange(fd, ABS_X), y: absoluteRange(fd, ABS_Y) }
+        : null;
+      // An absolute device without a usable range is read as relative.
+      const kind = ranges?.x && ranges?.y ? "absolute" : "relative";
+      open.push({ ...device, fd, kind, ranges, buffer: Buffer.alloc(EVENT_SIZE * 64), reading: true });
+    } catch (error) {
+      if (fd >= 0) {
+        try { closeSync(fd); } catch {}
+      }
+      onError(new Error(`${device.path}: ${error.message}`));
+    }
+  }
+
+  const clamp = (value, maximum) => Math.max(0, Math.min(maximum - 1, value));
+
+  const apply = (entry, type, code, value) => {
+    if (type === EV_REL) {
+      if (code === REL_X) { state.x = clamp(Math.round(state.x + value * speed), width); state.moved = true; }
+      else if (code === REL_Y) { state.y = clamp(Math.round(state.y + value * speed), height); state.moved = true; }
+      else if (code === REL_WHEEL) state.wheel += value;
+      else if (code === REL_HWHEEL) state.hwheel += value;
+      return;
+    }
+    if (type === EV_ABS && entry.kind === "absolute") {
+      const range = code === ABS_X ? entry.ranges.x : code === ABS_Y ? entry.ranges.y : null;
+      if (!range) return;
+      const span = range.maximum - range.minimum;
+      const fraction = (value - range.minimum) / span;
+      if (code === ABS_X) state.x = clamp(Math.round(fraction * width), width);
+      else state.y = clamp(Math.round(fraction * height), height);
+      state.moved = true;
+      return;
+    }
+    if (type === EV_KEY) {
+      const button = buttonNames[code];
+      if (!button) return;
+      const down = value !== 0;
+      if (state.buttons[button] === down) return; // key repeat
+      state.buttons[button] = down;
+      (down ? state.pressed : state.released).push(button);
+    }
+  };
+
+  const flush = () => {
+    const report = {
+      x: state.x,
+      y: state.y,
+      buttons: { ...state.buttons },
+      wheel: state.wheel,
+      hwheel: state.hwheel,
+      moved: state.moved,
+      pressed: state.pressed,
+      released: state.released,
+    };
+    state.wheel = 0;
+    state.hwheel = 0;
+    state.moved = false;
+    state.pressed = [];
+    state.released = [];
+    if (report.moved || report.wheel || report.hwheel || report.pressed.length || report.released.length) {
+      try { onSync(report); } catch (error) { onError(error); }
+    }
+  };
+
+  const pump = (entry) => {
+    if (!entry.reading) return;
+    read(entry.fd, entry.buffer, 0, entry.buffer.length, null, (error, count) => {
+      if (!entry.reading) return;
+      if (error) {
+        if (error.code === "EAGAIN") { setTimeout(() => pump(entry), 10); return; }
+        entry.reading = false;
+        onError(new Error(`${entry.path}: ${error.message}`));
+        return;
+      }
+      for (let offset = 0; offset + EVENT_SIZE <= count; offset += EVENT_SIZE) {
+        const type = entry.buffer.readUInt16LE(offset + 16);
+        const code = entry.buffer.readUInt16LE(offset + 18);
+        const value = entry.buffer.readInt32LE(offset + 20);
+        if (type === EV_SYN) flush();
+        else apply(entry, type, code, value);
+      }
+      pump(entry);
+    });
+  };
+
+  for (const entry of open) pump(entry);
+
+  return {
+    devices: open.map(({ path, name, kind }) => ({ path, name, kind })),
+    state,
+    close() {
+      for (const entry of open) {
+        entry.reading = false;
+        try { closeSync(entry.fd); } catch {}
+      }
+      open.length = 0;
+    },
+  };
+};

package/initramfs/lib/bunterm/renderer.js

@@ -105,6 +105,7 @@ export class Renderer {
     this.forcedRows = new Set();
     this.dirtyAll = true;
     this.lastCursor = { x: -1, y: -1, visible: false };
+    this.lastPointer = null;
   }
 
   fontFor(typeface, size, { bold = false, italic = false } = {}) {
@@ -355,11 +356,46 @@ export class Renderer {
     }
   }
 
+  // Draws the mouse pointer at (x, y) in pixels: an arrow outlined in the
+  // background colour so it stays visible over any cell.
+  drawPointer({ x, y }) {
+    const { CanvasKit, canvas } = this;
+    const size = Math.max(10, Math.round(this.fontSize * 0.9));
+    const builder = new CanvasKit.PathBuilder();
+    builder.moveTo(x, y);
+    builder.lineTo(x, y + size);
+    builder.lineTo(x + size * 0.28, y + size * 0.74);
+    builder.lineTo(x + size * 0.46, y + size * 1.08);
+    builder.lineTo(x + size * 0.63, y + size * 1.0);
+    builder.lineTo(x + size * 0.45, y + size * 0.66);
+    builder.lineTo(x + size * 0.72, y + size * 0.66);
+    builder.close();
+    const path = builder.detach();
+    builder.delete();
+    const outline = this.paintFor(this.background).copy();
+    outline.setStyle(CanvasKit.PaintStyle.Stroke);
+    outline.setStrokeWidth(Math.max(1, size / 8));
+    canvas.drawPath(path, outline);
+    canvas.drawPath(path, this.paintFor(this.cursorColor));
+    outline.delete();
+    path.delete();
+  }
+
+  // The rows an arrow at (x, y) covers, so they are repainted when it moves.
+  pointerRows({ x, y }) {
+    void x;
+    const size = Math.max(10, Math.round(this.fontSize * 0.9));
+    const first = Math.floor((y - this.offsetY) / this.cellHeight);
+    const last = Math.ceil((y + size * 1.1 - this.offsetY) / this.cellHeight);
+    return [first, last];
+  }
+
   // Repaints what changed and flushes to the framebuffer. `cursor` is
   // { x, y, visible }; `images` is a list of { image, rect } placements in
-  // screen pixels, from images.js, drawn over the text. Returns true when
-  // anything was painted.
-  render(term, { cursor, images = [] } = {}) {
+  // screen pixels, from images.js, drawn over the text; `pointer` is the
+  // mouse position in pixels, drawn last. Returns true when anything was
+  // painted.
+  render(term, { cursor, images = [], pointer = null } = {}) {
     const buffer = term.buffer.active;
     const top = buffer.viewportY;
     const dirty = [];
@@ -375,6 +411,13 @@ export class Renderer {
     const cursorRows = new Set();
     if (this.lastCursor.visible) cursorRows.add(this.lastCursor.y);
     if (cursor?.visible) cursorRows.add(cursor.y);
+    // Wherever the pointer was and is has to be repainted: the text under it
+    // has not changed, so no row hash would say so.
+    for (const position of [this.lastPointer, pointer]) {
+      if (!position) continue;
+      const [first, last] = this.pointerRows(position);
+      for (let row = Math.max(0, first); row < Math.min(this.rows, last); row++) cursorRows.add(row);
+    }
     for (const row of cursorRows) {
       if (row >= 0 && row < this.rows && !dirty.includes(row)) dirty.push(row);
     }
@@ -390,6 +433,8 @@ export class Renderer {
     }
     this.lastCursor = { x: cursor?.x ?? -1, y: cursor?.y ?? -1, visible: Boolean(cursor?.visible) };
     if (images.length) this.drawImages(images, dirty);
+    if (pointer) this.drawPointer(pointer);
+    this.lastPointer = pointer ? { x: pointer.x, y: pointer.y } : null;
     this.screen.flush();
     return true;
   }