buninu-linux 0.13.56 → 0.15.58

package/initramfs/lib/bunterm/renderer.js

@@ -1,3 +1,4 @@
+import {skiaImage} from '../raw-image.js';
 // /lib/bunterm/renderer.js — paints an xterm.js headless buffer onto a Skia
 // canvas as a grid of cells.
 //
@@ -58,12 +59,13 @@ const isSingleCodePoint = (text) => {
 };
 
 export class Renderer {
-  constructor({ CanvasKit, screen, fonts, fontSize = 16, lineHeight = 1, theme = defaultTheme }) {
+  constructor({ CanvasKit, screen, fonts, fontSize = 13, lineHeight = 1, theme = defaultTheme }) {
     this.CanvasKit = CanvasKit;
     this.screen = screen;
     this.canvas = screen.canvas;
     this.fonts = fonts;
     this.fontSize = fontSize;
+    this.lineHeight = lineHeight;
     this.theme = theme;
     this.palette = buildPalette(theme);
     this.foreground = parseColor(theme.foreground);
@@ -127,6 +129,30 @@ export class Renderer {
     return font;
   }
 
+  setFontSize(size) {
+    if (!Number.isInteger(size) || size < 6 || size > 96) throw new Error("font size must be an integer from 6 to 96");
+    if (size === this.fontSize) return;
+    for (const font of this.fontCache.values()) font.delete();
+    for (const paragraph of this.paragraphCache.values()) paragraph.delete();
+    this.fontCache.clear();
+    this.metricsCache.clear();
+    this.paragraphCache.clear();
+    this.fontSize = size;
+    const font = this.fontFor(this.fonts.regular, size), metrics = font.getMetrics();
+    this.cellWidth = Math.max(1, Math.round(font.getGlyphWidths(this.fonts.regular.getGlyphIDs("M"))[0]));
+    this.cellHeight = Math.max(1, Math.round((metrics.descent-metrics.ascent+(metrics.leading||0))*this.lineHeight));
+    this.columns = Math.max(1, Math.floor(this.screen.width/this.cellWidth));
+    this.rows = Math.max(1, Math.floor(this.screen.height/this.cellHeight));
+    this.offsetX = Math.floor((this.screen.width-this.columns*this.cellWidth)/2);
+    this.offsetY = Math.floor((this.screen.height-this.rows*this.cellHeight)/2);
+    this.rowHashes = new Int32Array(this.rows);
+    this.rawCoveredRows = new Set();
+    this.forcedRows.clear();
+    this.lastCursor = {x:-1,y:-1,visible:false};
+    this.lastPointer = null;
+    this.invalidate();
+  }
+
   metricsFor(font) {
     let metrics = this.metricsCache.get(font);
     if (!metrics) {
@@ -214,7 +240,7 @@ export class Renderer {
       width * this.cellWidth, height * this.cellHeight);
   }
 
-  drawText(text, x, y, cells, color, { bold, italic, emoji }) {
+  drawText(text, x, y, cells, color, { bold, italic, emoji, align = "center" }) {
     const { CanvasKit, canvas } = this;
     const available = cells * this.cellWidth;
     const paint = this.paintFor(color);
@@ -235,7 +261,7 @@ export class Renderer {
       }
       const metrics = this.metricsFor(font);
       const baseline = y + (this.cellHeight - (metrics.descent - metrics.ascent)) / 2 - metrics.ascent;
-      canvas.drawGlyphs([glyph], [x + (available - advance) / 2, baseline], 0, 0, font, paint);
+      canvas.drawGlyphs([glyph], [align === "left" ? x : x + (available - advance) / 2, baseline], 0, 0, font, paint);
       return;
     }
     // Grapheme clusters are shaped by the Paragraph API and cached.
@@ -272,13 +298,13 @@ export class Renderer {
     const height = paragraph.getHeight();
     canvas.save();
     canvas.clipRect(CanvasKit.XYWHRect(x, y, available, this.cellHeight), CanvasKit.ClipOp.Intersect, false);
-    if (width > available) {
+    if (width > available && align !== "left") {
       const scale = available / width;
       canvas.translate(x, y + (this.cellHeight - height * scale) / 2);
       canvas.scale(scale, scale);
       canvas.drawParagraph(paragraph, 0, 0);
     } else {
-      canvas.drawParagraph(paragraph, x + (available - width) / 2, y + (this.cellHeight - height) / 2);
+      canvas.drawParagraph(paragraph, align === "left" ? x : x + (available - width) / 2, y + (this.cellHeight - height) / 2);
     }
     canvas.restore();
   }
@@ -395,25 +421,44 @@ export class Renderer {
   // 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 } = {}) {
+  render(term, { cursor, images = [], pointer = null, overlay = null } = {}) {
     const buffer = term.buffer.active;
     const top = buffer.viewportY;
     const dirty = [];
+    // Only proven opaque, exact raw copies may hide text work. Partial rows,
+    // scaling, transparency and unsupported framebuffer layouts remain unchanged.
+    const coveredRows = new Set();
+    const previouslyCovered = this.rawCoveredRows ?? new Set();
+    for (const {image, rect, source} of images) {
+      const bounds = source || [0, 0, image.width(), image.height()];
+      if (rect[0] > this.offsetX || rect[2] < this.offsetX + this.columns * this.cellWidth
+          || !this.screen.canDrawRawImage?.(image, rect, bounds)) continue;
+      const first = Math.max(0, Math.ceil((rect[1] - this.offsetY) / this.cellHeight));
+      const end = Math.min(this.rows, Math.floor((rect[3] - this.offsetY) / this.cellHeight));
+      for (let row = first; row < end; row++) coveredRows.add(row);
+    }
     for (let row = 0; row < this.rows; row++) {
       const line = buffer.getLine(top + row);
-      const hash = line ? this.rowHash(line, this.columns) : 0;
-      if (this.dirtyAll || hash !== this.rowHashes[row] || this.forcedRows.has(row)) {
+      const hash = coveredRows.has(row) ? this.rowHashes[row] : line ? this.rowHash(line, this.columns) : 0;
+      if (this.dirtyAll || hash !== this.rowHashes[row] || this.forcedRows.has(row)
+          || coveredRows.has(row) !== previouslyCovered.has(row)) {
         dirty.push(row);
         this.rowHashes[row] = hash;
       }
     }
+    this.rawCoveredRows = coveredRows;
     this.forcedRows.clear();
+    const localPointer = Boolean(this.screen.saveRegion && this.screen.restoreRegion);
+    const pointerChanged = this.lastPointer?.x !== pointer?.x || this.lastPointer?.y !== pointer?.y;
+    const cursorChanged = this.lastCursor.x !== (cursor?.x ?? -1)
+      || this.lastCursor.y !== (cursor?.y ?? -1)
+      || this.lastCursor.visible !== Boolean(cursor?.visible);
     const cursorRows = new Set();
-    if (this.lastCursor.visible) cursorRows.add(this.lastCursor.y);
-    if (cursor?.visible) cursorRows.add(cursor.y);
+    if ((!localPointer || cursorChanged) && this.lastCursor.visible) cursorRows.add(this.lastCursor.y);
+    if ((!localPointer || cursorChanged) && 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]) {
+    for (const position of localPointer ? [] : [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);
@@ -421,19 +466,35 @@ export class Renderer {
     for (const row of cursorRows) {
       if (row >= 0 && row < this.rows && !dirty.includes(row)) dirty.push(row);
     }
+    if (!dirty.length && !this.dirtyAll && (!localPointer || !pointerChanged)) return false;
+    if (this.pointerBackground) {
+      this.screen.restoreRegion(this.pointerBackground);
+      this.pointerBackground = null;
+    }
     if (this.dirtyAll) {
       this.canvas.clear(this.CanvasKit.Color(this.background[0], this.background[1], this.background[2]));
     }
     this.dirtyAll = false;
-    if (!dirty.length) return false;
     dirty.sort((a, b) => a - b);
-    for (const row of dirty) this.drawRow(buffer.getLine(top + row), row);
-    if (cursor?.visible && cursor.y >= 0 && cursor.y < this.rows) {
+    for (const row of dirty) {
+      if (!coveredRows.has(row)) this.drawRow(buffer.getLine(top + row), row);
+    }
+    if (cursor?.visible && !coveredRows.has(cursor.y) && dirty.includes(cursor.y)) {
       this.drawCursor(buffer.getLine(top + cursor.y), cursor.x, cursor.y);
     }
     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);
+    if (images.length && dirty.length) this.drawImages(images, dirty);
+    if (overlay && dirty.length) overlay();
+    if (pointer) {
+      if (localPointer) {
+        const size = Math.max(10, Math.round(this.fontSize * 0.9));
+        // Include the mitered outline and anti-aliasing outside the arrow path.
+        const padding = Math.ceil(Math.max(1, size / 8) * 2) + 2;
+        this.pointerBackground = this.screen.saveRegion(pointer.x - padding, pointer.y - padding,
+          pointer.x + size * 0.72 + padding, pointer.y + size * 1.08 + padding);
+      }
+      this.drawPointer(pointer);
+    }
     this.lastPointer = pointer ? { x: pointer.x, y: pointer.y } : null;
     this.screen.flush();
     return true;
@@ -442,16 +503,24 @@ export class Renderer {
   // Redraws the parts of image placements that intersect the repainted rows.
   drawImages(images, dirtyRows) {
     const { CanvasKit, canvas } = this;
+    const bands = [];
+    for (const row of dirtyRows) {
+      const top = this.offsetY + row * this.cellHeight, bottom = top + this.cellHeight;
+      const last = bands.at(-1);
+      if (last && last[1] === top) last[1] = bottom;
+      else bands.push([top, bottom]);
+    }
     for (const { image, rect, source } of images) {
       const [left, top, right, bottom] = rect;
-      const sourceRect = source ? CanvasKit.LTRBRect(...source) : CanvasKit.LTRBRect(0, 0, image.width(), image.height());
-      for (const row of dirtyRows) {
-        const rowTop = this.offsetY + row * this.cellHeight;
-        const rowBottom = rowTop + this.cellHeight;
+      if (!bands.some(([y0, y1]) => bottom > y0 && top < y1)) continue;
+      const bounds = source || [0, 0, image.width(), image.height()];
+      if (this.screen.drawOpaqueImage?.(image, rect, bounds, bands)) continue;
+      const sourceRect = CanvasKit.LTRBRect(...bounds);
+      for (const [rowTop, rowBottom] of bands) {
         if (bottom <= rowTop || top >= rowBottom) continue;
         canvas.save();
         canvas.clipRect(CanvasKit.LTRBRect(0, rowTop, this.screen.width, rowBottom), CanvasKit.ClipOp.Intersect, false);
-        canvas.drawImageRectOptions(image, sourceRect, CanvasKit.LTRBRect(left, top, right, bottom),
+        canvas.drawImageRectOptions(skiaImage(image), sourceRect, CanvasKit.LTRBRect(left, top, right, bottom),
           CanvasKit.FilterMode.Linear, CanvasKit.MipmapMode.Linear, null);
         canvas.restore();
       }

package/initramfs/lib/bunterm/selection.js

@@ -0,0 +1,60 @@
+// Coordinates are buffer cells, not UTF-16 indices. Endpoints include a whole
+// grapheme, even when the mouse hits the continuation cell of a wide character.
+export function createSelection(term, renderer, changed) {
+  let anchor = null, end = null, dragging = false;
+  const clear = () => { if (anchor) { anchor = end = null; dragging = false; changed(); } };
+  const point = report => {
+    const x = Math.max(0, Math.min(term.cols - 1, Math.floor((report.x - renderer.offsetX) / renderer.cellWidth)));
+    const y = term.buffer.active.viewportY + Math.max(0, Math.min(term.rows - 1,
+      Math.floor((report.y - renderer.offsetY) / renderer.cellHeight)));
+    return {x,y};
+  };
+  const bounds = () => {
+    if (!anchor) return null;
+    let [a,b] = anchor.y < end.y || anchor.y === end.y && anchor.x <= end.x ? [anchor,end] : [end,anchor];
+    const first = term.buffer.active.getLine(a.y), last = term.buffer.active.getLine(b.y);
+    let start = a.x, stop = b.x;
+    if (first?.getCell(start)?.getWidth() === 0) start = Math.max(0,start-1);
+    if (last?.getCell(stop)?.getWidth() === 0) stop = Math.max(0,stop-1);
+    stop += Math.max(1,last?.getCell(stop)?.getWidth() || 1);
+    return {a:{x:start,y:a.y},b:{x:stop,y:b.y}};
+  };
+  return {
+    clear,
+    stop() { dragging = false; },
+    get active() { return !!anchor; },
+    pointer(report) {
+      if (term._core?.coreMouseService?.areMouseEventsActive) { clear(); return false; }
+      if (report.pressed.includes("left")) { anchor = end = point(report); dragging = true; changed(); }
+      if (dragging && (report.moved || report.released.includes("left"))) { end = point(report); changed(); }
+      if (report.released.includes("left")) dragging = false;
+      return true;
+    },
+    text() {
+      const range = bounds();
+      if (!range) return "";
+      const {a,b} = range;
+      let text = "";
+      for (let y = a.y; y <= b.y; y++) {
+        const line = term.buffer.active.getLine(y);
+        if (!line) continue;
+        const start = y === a.y ? a.x : 0, stop = y === b.y ? b.x : term.cols;
+        if (y > a.y && !line.isWrapped) text += "\n";
+        // Wrapped rows join without a newline or lost meaningful spaces.
+        const nextWrapped = y < b.y && term.buffer.active.getLine(y + 1)?.isWrapped;
+        text += line.translateToString(!nextWrapped, start, stop);
+      }
+      return text;
+    },
+    draw() {
+      const range = bounds();
+      if (!range) return;
+      const {a,b} = range, top = term.buffer.active.viewportY;
+      for (let y = Math.max(a.y,top); y <= Math.min(b.y,top+term.rows-1); y++) {
+        const start = y === a.y ? a.x : 0, stop = y === b.y ? b.x : term.cols;
+        renderer.canvas.drawRect(renderer.cellRect(start,y-top,stop-start),
+          renderer.paintFor([70,150,220],95));
+      }
+    },
+  };
+}

package/initramfs/lib/bunterm/terminal.js

@@ -1,3 +1,4 @@
+import {bgraParser} from './raw-protocol.js';
 // /lib/bunterm/terminal.js — a graphical terminal on the Linux framebuffer.
 //
 //   Bun.spawn({ terminal })  ──── PTY output ────▶ KittyGraphicsParser
@@ -13,17 +14,22 @@
 // keyboard are Buninu's own.
 
 import { createRequire } from "node:module";
-import { runGraphics } from "../fbdev.js";
+import { runGraphics, activeConsole } from "../fbdev.js";
 import { loadCanvasKit, openCanvas, loadFontSet } from "../canvas.js";
 import { Terminal } from "../xterm/xterm-headless.mjs";
 import { UnicodeGraphemesAddon } from "../xterm/addon-unicode-graphemes.mjs";
 import { Renderer, defaultTheme } from "./renderer.js";
 import { ImageStore } from "./images.js";
 import { openKeyboard, translateKeys } from "./input.js";
-import { claimVirtualConsole } from "./vt.js";
+import { claimVirtualConsole, listVirtualTerminals, nextVirtualTerminal } from "./vt.js";
+import { createFpsMeter } from "./fps.js";
+import { createVtMenu } from "./vt-menu.js";
 import { attachGeometry } from "./geometry.js";
 import { terminalMouseEvent } from "./pointer-report.js";
-import { attachClipboard } from "./clipboard.js";
+import { attachClipboard, readClipboard, writeClipboard, pasteText } from "./clipboard.js";
+import { createSelection } from "./selection.js";
+import { createCommands } from "./commands.js";
+import { attachKeyboard as createKeyboard } from "./keyboard.js";
 
 const require = createRequire(import.meta.url);
 
@@ -49,7 +55,7 @@ export const createSession = ({
   fonts,
   command = "/bin/sh",
   argv = [],
-  fontSize = 16,
+  fontSize = 13,
   lineHeight = 1,
   theme = defaultTheme,
   scrollback = 1000,
@@ -57,6 +63,7 @@ export const createSession = ({
   mouse = true,
   clipboard = true,
   env = {},
+  vtMenu = null,
   onError = (error) => console.error(`bunterm: ${error?.stack ?? error}`),
 }) => {
   const { BunPtyBackend, KittyGraphicsParser } = loadJsgotty();
@@ -70,7 +77,7 @@ export const createSession = ({
   term.loadAddon(new UnicodeGraphemesAddon());
   term.unicode.activeVersion = "15-graphemes";
   const images = new ImageStore({ CanvasKit, term, renderer });
-  const kitty = new KittyGraphicsParser({ binaryData: true });
+  const kitty = new (bgraParser(KittyGraphicsParser,screen.display))({ binaryData: true });
 
   const backend = new BunPtyBackend({
     command,
@@ -92,6 +99,11 @@ export const createSession = ({
   // Only set when a pointer is attached; without one the renderer is called
   // exactly as before.
   let pointer = null;
+  let menu = null;
+  const fps = createFpsMeter();
+  let fpsTimer = null;
+  let keyboardProtocol = null;
+  let consoleKeyboard = null;
   const paint = () => {
     if (frameTimer) clearTimeout(frameTimer);
     frameTimer = null;
@@ -100,28 +112,76 @@ export const createSession = ({
     // cursorY counts from the buffer's base, so a scrolled-back viewport
     // moves the cursor down the screen and eventually off it.
     const row = buffer.baseY + buffer.cursorY - buffer.viewportY;
-    return renderer.render(term, {
+    if (menu?.visible || selection.active) renderer.invalidate();
+    const visibleImages = images.visible();
+    const rendered = renderer.render(term, {
       cursor: {
         x: buffer.cursorX,
         y: row,
         visible: blinkOn && !cursorHidden() && row >= 0 && row < renderer.rows,
       },
-      images: images.visible(),
+      images: visibleImages,
       pointer,
+      overlay: () => { selection.draw(); fps.draw(renderer); if (menu?.visible) menu.draw(renderer); },
     });
+    if (rendered && fps.enabled) fps.presented(visibleImages);
+    return rendered;
   };
   const requestFrame = () => {
     if (!active) return;
     frameTimer ??= setTimeout(paint, 16);
   };
+  const changed = () => { renderer.invalidate(); requestFrame(); };
+  const selection = createSelection(term, renderer, changed);
+  const setFontSize = size => {
+    renderer.setFontSize(size);
+    selection.clear();
+    term.resize(renderer.columns, renderer.rows);
+    backend.resize(renderer.columns, renderer.rows);
+    changed();
+  };
+  const copy = async () => {
+    if (!clipboard) throw new Error("Clipboard disabled (--no-clipboard)");
+    if (!selection.active) throw new Error("Drag to select text first (application mouse reporting must be off)");
+    await writeClipboard(selection.text());
+  };
+  const paste = async () => {
+    if (!clipboard) throw new Error("Clipboard disabled (--no-clipboard)");
+    const text = await readClipboard();
+    if (closed) return;
+    pasteText(term, text, value => backend.write(Buffer.from(value, "utf8")));
+    menu?.close();
+    term.scrollToBottom();
+    changed();
+  };
+  const toggleFps = () => {
+    if (fpsTimer) clearInterval(fpsTimer);
+    fpsTimer = null;
+    if (fps.toggle(images.visible())) fpsTimer = setInterval(() => {
+      fps.sample();
+      if (active) { renderer.invalidateRows(0,1); requestFrame(); }
+    },1000);
+    renderer.invalidateRows(0,1); requestFrame();
+  };
+  const commands = createCommands({fontSize:()=>renderer.fontSize,setFontSize,copy,paste,
+    switchVT: number => vtMenu?.select(number)});
+  if (vtMenu) menu = createVtMenu({
+    ...vtMenu, width: screen.width, height: screen.height, rowHeight: renderer.cellHeight,
+    changed,
+    controls: {fpsEnabled:()=>fps.enabled,toggleFps,fontSize:()=>renderer.fontSize,cellHeight:()=>renderer.cellHeight,execute:line=>commands.execute(line)},
+  });
   const suspend = () => {
+    keyboardProtocol?.blur();
+    selection.stop();
     active = false;
+    menu?.close();
     if (frameTimer) clearTimeout(frameTimer);
     frameTimer = null;
   };
   const resume = () => {
     if (active) return;
     active = true;
+    consoleKeyboard?.clearHeld();
     renderer.invalidate();
     paint();
   };
@@ -141,6 +201,9 @@ export const createSession = ({
       const { events } = kitty.consume(chunk);
       for (const event of events) {
         if (event.kind === "plain") {
+          // A selection is a snapshot of the displayed cells. Drop it before
+          // output scrolls/replaces those cells, rather than copying stale rows.
+          selection.clear();
           await writeTerminal(term, event.data);
           continue;
         }
@@ -169,6 +232,8 @@ export const createSession = ({
 
   // Keyboard bytes from the console, rewritten for the program's key mode.
   const input = (bytes) => {
+    if (!active) return;
+    if (menu?.input(bytes)) return;
     const applicationCursorKeys = Boolean(term._core?.coreService?.decPrivateModes?.applicationCursorKeys);
     const text = translateKeys(bytes.toString("latin1"), { applicationCursorKeys });
     backend.write(Buffer.from(text, "latin1"));
@@ -180,6 +245,31 @@ export const createSession = ({
     resetBlink();
     requestFrame();
   };
+  const attachKeyboard = device => {
+    consoleKeyboard = device;
+    keyboardProtocol = createKeyboard({
+      term,
+      setEnhanced: value => device.setEnhanced(value),
+      write: text => {
+        backend.write(Buffer.from(text,"utf8"));
+        term.scrollToBottom(); resetBlink(); changed();
+      },
+      localInput: (event, text) => {
+        if (!menu?.visible) return false;
+        if (text) menu.input(Buffer.from(text,"utf8"));
+        return true;
+      },
+      switchVT: number => { Promise.resolve(vtMenu?.select(number)).catch(onError); },
+      switchRelative: delta => {
+        try {
+          const number = Math.max(1,Math.min(63,activeConsole({fd:device.fd})+delta));
+          Promise.resolve(vtMenu?.select(number)).catch(onError);
+        } catch (error) { onError(error); }
+      },
+      onError,
+    });
+  };
+  const keyEvent = event => { if (active) keyboardProtocol?.event(event); };
 
   // Turns a pointer report from mouse.js into the mouse sequences the
   // program asked for. xterm.js's CoreMouseService owns the protocol: it
@@ -221,11 +311,18 @@ export const createSession = ({
     if (!active) return;
     pointer = { x: report.x, y: report.y };
     requestFrame();
+    if (menu?.pointer(report)) {
+      selection.stop();
+      keyboardProtocol?.blur();
+      return;
+    }
     const service = term._core?.coreMouseService;
     if (!service?.areMouseEventsActive) {
       if (report.wheel) wheelScroll(report.wheel);
+      selection.pointer(report);
       return;
     }
+    selection.clear();
     const send = (button, action) => {
       try {
         service.triggerMouseEvent(terminalMouseEvent(report, renderer, button, action));
@@ -278,10 +375,15 @@ export const createSession = ({
   const close = () => {
     if (closed) return;
     closed = true;
+    active = false;
     if (blinkTimer) clearInterval(blinkTimer);
+    if (fpsTimer) clearInterval(fpsTimer);
+    fpsTimer = null;
     if (frameTimer) clearTimeout(frameTimer);
     frameTimer = null;
     backend.close();
+    try { keyboardProtocol?.dispose(); } catch (error) { onError(error); }
+    keyboardProtocol = null;
     pointerDevice?.close();
     pointerDevice = null;
     images.delete();
@@ -293,6 +395,7 @@ export const createSession = ({
   return {
     term, backend, renderer, images, kitty,
     paint, requestFrame, suspend, resume, settle, input, exited, close, attachPointer, reportMouse, wheelScroll,
+    attachKeyboard, keyEvent, selection, setFontSize, commands,
   };
 };
 
@@ -308,21 +411,52 @@ export const runTerminal = async ({ console: consoleDevice = null, device = "/de
 
   return runGraphics(async (display, { onRestore, onRelease, onAcquire }) => {
     const screen = openCanvas(CanvasKit, display);
-    const session = createSession({ CanvasKit, screen, fonts, ...options });
+    let switching = false;
+    let keyboard = null;
+    const session = createSession({ CanvasKit, screen, fonts, ...options, vtMenu: {
+      list: () => {
+        const current = keyboard ? activeConsole(keyboard) : null;
+        return listVirtualTerminals().map(entry => ({...entry,current:entry.number===current}));
+      },
+      create: async fontSize => {
+        // Re-scan at activation, since another session may have opened while
+        // the menu was visible. The launcher detaches onto the new console;
+        // its normal VT ownership checks still apply.
+        const number = nextVirtualTerminal();
+        const child = Bun.spawn([process.execPath, `${import.meta.dir}/../../bin/bunterm`,
+          String(number), "-s", String(fontSize), "--fb", device],
+          { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
+        const [status, error] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+        if (status !== 0) throw new Error(error.trim() || "無法啟動 / Failed to start bunterm");
+      },
+      select: async number => {
+        if (switching) return;
+        switching = true;
+        try {
+          // Waiting in this process would block its VT_PROCESS signal handlers.
+          const child = Bun.spawn([process.execPath, `${import.meta.dir}/../../bin/chvt`, String(number)],
+            { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
+          const [status, error] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+          if (status !== 0) console.error(`bunterm: ${error.trim() || "VT switch failed"}`);
+        } catch (error) { console.error(`bunterm: VT switch: ${error.message}`); }
+        finally { switching = false; }
+      },
+    } });
     onRelease(session.suspend);
     // Coming back from another console (Ctrl-Alt-Fn): fbcon or another
     // bunterm has drawn over the framebuffer, so repaint everything.
     onAcquire(session.resume);
-    let keyboard = null;
     try {
       keyboard = openKeyboard({
         device: consoleDevice,
         onData: session.input,
+        onKey: session.keyEvent,
         onError: (error) => {
           console.error(`bunterm: keyboard: ${error.message}`);
           session.backend.close();
         },
       });
+      session.attachKeyboard(keyboard);
       onRestore(() => keyboard.close());
       if (options.mouse !== false) {
         // A pointer that cannot be opened is reported and the session
@@ -338,9 +472,10 @@ export const runTerminal = async ({ console: consoleDevice = null, device = "/de
       }
       return await session.exited;
     } finally {
-      keyboard?.close();
-      session.close();
-      screen.close();
+      try { session.close(); }
+      finally {
+        try { keyboard?.close(); } finally { screen.close(); }
+      }
     }
   }, { device, console: consolePaths, prepareConsole: claimVirtualConsole });
 };