buninu-linux 0.14.57 → 0.16.59

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);
 
@@ -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,
@@ -86,42 +93,99 @@ export const createSession = ({
   });
 
   let frameTimer = null;
+  let lastPaintTime = -Infinity;
   let active = true;
   let blinkOn = true;
   const cursorHidden = () => Boolean(term._core?.coreService?.isCursorHidden);
   // 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;
     if (!active) return false;
+    lastPaintTime = performance.now();
     const buffer = term.buffer.active;
     // 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);
+    // Limit paint starts, rather than adding 16 ms after every arriving frame.
+    // Slow rendering already consumes the interval; keep one pending paint.
+    frameTimer ??= setTimeout(paint, Math.max(0, 16 - (performance.now() - lastPaintTime)));
   };
+  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();
   };
@@ -138,17 +202,25 @@ export const createSession = ({
   let queue = Promise.resolve();
   const pump = (chunk) => {
     queue = queue.then(async () => {
+      if (closed) return;
       const { events } = kitty.consume(chunk);
       for (const event of events) {
+        if (closed) return;
         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;
         }
         const buffer = term.buffer.active;
         const graphic = kitty.parsePacket(event.packet, { row: buffer.cursorY + 1, col: buffer.cursorX + 1 });
         if (!graphic) continue;
+        using frame = graphic[Symbol.dispose] ? graphic : null;
         const motion = await images.handle(graphic);
+        if (closed) return;
         if (motion) await writeTerminal(term, motion);
+        if (closed) return;
         const ack = kitty.acknowledge(graphic);
         if (ack) backend.write(Buffer.from(ack, "utf8"));
       }
@@ -169,6 +241,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 +254,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 +320,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,12 +384,18 @@ 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;
+    kitty.dispose();
     images.delete();
     renderer.delete();
     term.dispose();
@@ -293,6 +405,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 +421,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 +482,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 });
 };

package/initramfs/lib/bunterm/vt-menu.js

@@ -0,0 +1,181 @@
+// Local overlay; none of its input is sent to the PTY.
+import { StringDecoder } from "node:string_decoder";
+
+export function createVtMenu({ list, select, create = null, changed, width, height, rowHeight, controls = null }) {
+  let row = Math.max(24, Math.ceil(rowHeight + 8));
+  let capacity = Math.max(1, Math.floor(height / row) - 2);
+  const panelWidth = Math.min(width, 420);
+  let entries = null, selected = 0, offset = 0, swallow = false;
+  let command = [], caret = 0, editing = false, status = "", escape = "";
+  let decoder = new StringDecoder("utf8");
+  let creating = false;
+  const layout = () => {
+    row = Math.max(24, Math.ceil((controls?.cellHeight?.() ?? rowHeight) + 8));
+    capacity = Math.max(1, Math.floor(height / row) - 2);
+    if (selected >= offset + capacity) offset = selected - capacity + 1;
+  };
+  const close = () => { entries = null; editing = false; changed(); };
+  const move = delta => {
+    selected = Math.max(0, Math.min(entries.length - 1, selected + delta));
+    offset = Math.max(0, Math.min(offset, selected));
+    if (selected >= offset + capacity) offset = selected - capacity + 1;
+    changed();
+  };
+  const run = (line) => {
+    // Promise.resolve().then also catches synchronous callbacks.
+    Promise.resolve().then(() => controls.execute(line)).then(message => {
+      status = message || ""; changed();
+    }).catch(error => { status = error.message; changed(); });
+  };
+  const choose = (right = false) => {
+    const target = entries[selected];
+    if (target?.kind === "create") {
+      if (creating) return;
+      creating = true;
+      status = "啟動中 / Starting…"; changed();
+      Promise.resolve().then(() => create(controls.fontSize())).then(() => close())
+        .catch(error => { status = error.message; changed(); })
+        .finally(() => { creating = false; });
+      return;
+    }
+    if (target?.kind === "font") { run(`font ${right ? "+" : "-"}`); return; }
+    if (target?.kind === "clipboard") {
+      run(right ? "paste" : "copy");
+      return;
+    }
+    if (target?.kind === "command") { editing = true; changed(); return; }
+    close(); if (target) select(target.number);
+  };
+  return {
+    get visible() { return entries !== null; },
+    close,
+    pointer(report) {
+      layout();
+      if (swallow && !entries) {
+        if (!Object.values(report.buttons).some(Boolean)) swallow = false;
+        return true;
+      }
+      if (!entries) {
+        if (report.x < 0 || report.y < 0 || report.x >= 2 || report.y >= 2 || !report.pressed.includes("left")) return false;
+        entries = [...(controls ? [{kind:"font"}, {kind:"clipboard"}, {kind:"command"}] : []), ...list(),
+          ...(create && controls ? [{kind:"create",label:"+ 新增 bunterm / New bunterm"}] : [])];
+        selected = 0; offset = 0; swallow = true; status = ""; escape = "";
+        decoder = new StringDecoder("utf8"); changed(); return true;
+      }
+      swallow = Object.values(report.buttons).some(Boolean);
+      if (report.wheel) move(-Math.sign(report.wheel));
+      const index = Math.floor(report.y / row) - 1 + offset;
+      const inside = report.x >= 0 && report.x < panelWidth && report.y >= row && index >= offset && index < Math.min(entries.length, offset + capacity);
+      if (inside && report.moved && !editing) { selected = index; changed(); }
+      if (report.pressed.includes("left")) {
+        swallow = true;
+        if (controls?.toggleFps && report.y >= 0 && report.y < row &&
+            report.x >= Math.max(0,panelWidth-112) && report.x < panelWidth) {
+          controls.toggleFps(); changed(); return true;
+        }
+        if (inside) {
+          selected = index; editing = false;
+          if (entries[index].kind !== "font" || report.x < 64 || report.x >= panelWidth-64)
+            choose(report.x >= panelWidth/2);
+          else changed();
+        } else close();
+      } else if (report.pressed.includes("right")) { swallow = true; close(); }
+      return true;
+    },
+    input(bytes) {
+      if (!entries) return false;
+      layout();
+      const text = decoder.write(bytes);
+      if (text === "\x1b" && !escape || text === "\x03") { close(); return true; }
+      // Parse multiple keys in one console read, retaining incomplete CSI/SS3.
+      const input = escape + text; escape = "";
+      for (let i = 0; i < input.length;) {
+        let key = String.fromCodePoint(input.codePointAt(i));
+        if (key === "\x1b") {
+          const rest = input.slice(i);
+          const match = /^\x1b(?:\[[0-9;]*[A-Za-z~]|O[A-Za-z])/.exec(rest);
+          if (!match) { if (/^\x1b(?:\[[0-9;]*|O)?$/.test(rest)) escape = rest; break; }
+          key = match[0];
+        }
+        i += key.length;
+        if (key === "\x03") { close(); break; }
+        if (key === "\t" && controls) {
+          editing = !editing;
+          if (editing && controls) { selected = 2; move(0); }
+        } else if (editing) {
+          if (key === "\r" || key === "\n") { run(command.join("")); command = []; caret = 0; }
+          else if (key === "\x7f" || key === "\b") { if (caret) command.splice(--caret,1); }
+          else if (key === "\x1b[3~") command.splice(caret,1);
+          else if (["\x1b[D","\x1bOD"].includes(key)) caret = Math.max(0,caret-1);
+          else if (["\x1b[C","\x1bOC"].includes(key)) caret = Math.min(command.length,caret+1);
+          else if (["\x01","\x1b[H","\x1bOH"].includes(key)) caret = 0;
+          else if (["\x05","\x1b[F","\x1bOF"].includes(key)) caret = command.length;
+          else if (key === "\x15") { command = []; caret = 0; }
+          else if (key.codePointAt(0) >= 32 && !key.startsWith("\x1b") && command.length < 1024) command.splice(caret++,0,key);
+        } else if (["\x1b[A", "\x1bOA", "k"].includes(key)) move(-1);
+        else if (["\x1b[B", "\x1bOB", "j"].includes(key)) move(1);
+        else if (key === "\r" || key === "\n") { choose(); if (!entries) break; }
+        else if (controls && ["+","-","\x1b[C","\x1b[D"].includes(key) && entries[selected]?.kind === "font")
+          choose(key === "+" || key === "\x1b[C");
+        else if (controls && entries[selected]?.kind === "clipboard" && ["c","p","\x1b[C","\x1b[D"].includes(key))
+          choose(key === "p" || key === "\x1b[C");
+      }
+      changed();
+      return true;
+    },
+    draw(renderer) {
+      if (!entries) return;
+      layout();
+      const { canvas, CanvasKit } = renderer;
+      const visible = entries.slice(offset, offset + capacity);
+      const rect = (y, color) => canvas.drawRect(CanvasKit.XYWHRect(0, y, panelWidth, row), renderer.paintFor(color));
+      const text = (value, y, x = 8, span = panelWidth - 16, align = "left") => renderer.drawText(value, x, y + (row - renderer.cellHeight) / 2,
+        Math.max(1, Math.floor(span / renderer.cellWidth)), [240, 240, 240], {align});
+      canvas.save();
+      canvas.clipRect(CanvasKit.XYWHRect(0, 0, panelWidth, Math.min(height, (visible.length + 2) * row)), CanvasKit.ClipOp.Intersect, false);
+      rect(0, [35, 40, 48]);
+      const fpsWidth = controls?.toggleFps ? Math.min(panelWidth,112) : 0;
+      text(controls ? "bunterm" : "Switch terminal",0,8,Math.max(1,panelWidth-fpsWidth-16));
+      if (fpsWidth) {
+        canvas.drawRect(CanvasKit.XYWHRect(panelWidth-fpsWidth,2,fpsWidth-2,row-4),
+          renderer.paintFor(controls.fpsEnabled()?[35,100,110]:[55,65,75]));
+        text(controls.fpsEnabled() ? "[FPS ✓]" : "[FPS]",0,panelWidth-fpsWidth+4,fpsWidth-10,"center");
+      }
+      visible.forEach((entry, i) => {
+        const y = (i + 1) * row;
+        rect(y, i + offset === selected ? [45, 80, 125] : [25, 29, 35]);
+        if (entry.kind === "font") {
+          // Use equal, cell-aligned button widths. Centered text scales to
+          // fit at large font sizes instead of clipping the closing bracket.
+          const buttonWidth = Math.max(1,Math.floor(48/renderer.cellWidth))*renderer.cellWidth;
+          const labelStart = buttonWidth+16;
+          text("[-]",y,8,buttonWidth,"center");
+          text(`🔤 字體 Font ${controls.fontSize()}`,y,labelStart,Math.max(1,panelWidth-labelStart*2),"center");
+          text("[+]",y,Math.max(8,panelWidth-8-buttonWidth),buttonWidth,"center");
+          return;
+        }
+        if (entry.kind === "clipboard") {
+          text("📋 複製 Copy",y,8,panelWidth/2-16);
+          text("📥 貼上 Paste",y,panelWidth/2+8,panelWidth/2-16);
+          return;
+        }
+        if (entry.kind === "command") {
+          canvas.drawRect(CanvasKit.XYWHRect(4,y+2,panelWidth-8,row-4),renderer.paintFor(editing?[80,170,220]:[85,95,105]));
+          canvas.drawRect(CanvasKit.XYWHRect(5,y+3,panelWidth-10,row-6),renderer.paintFor([225,230,235]));
+          const placeholder = !command.length && !editing;
+          const label = placeholder ? "Click to type a command…"
+            : `${command.slice(Math.max(0,caret-24),caret).join("")}${editing?"│":""}${command.slice(caret).join("")}`;
+          renderer.drawText(label,10,y+(row-renderer.cellHeight)/2,
+            Math.max(1,Math.floor((panelWidth-20)/renderer.cellWidth)),
+            placeholder?[100,110,120]:[20,25,30],{align:"left"});
+          return;
+        }
+        const label = `${entry.label}${entry.current ? " (current)" : ""}`;
+        text(label, y);
+      });
+      const y = (visible.length + 1) * row;
+      rect(y, [35, 40, 48]); text(status || (controls ? "Tab: command · Enter · Esc" : "↑↓ / wheel · Enter · Esc"), y);
+      canvas.restore();
+    },
+  };
+}

package/initramfs/lib/bunterm/vt.js

@@ -6,7 +6,7 @@
 // hold the console device open.  Both facts live under /proc/<pid> and disappear
 // with the process; there is no persistent pid or lock file to become stale.
 
-import { readdirSync, readFileSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
 import { libc, cString, check } from "../dlopen.js";
 
 const PR_SET_NAME = 15;
@@ -89,3 +89,29 @@ Switch between TTYs by Ctrl+Alt+F1-12
     try { setTaskName(previousName); } catch {}
   };
 };
+
+// Discover live owners using the same task-name + device-fd contract as claim.
+export const listVirtualTerminals = () => {
+  let initial = 1;
+  try {
+    initial = virtualConsoleNumber(readlinkSync("/proc/1/fd/0")) ?? 1;
+  } catch {}
+  const entries = new Map([[initial, { number: initial, label: `tty${initial} — initial console` }]]);
+  for (const pid of readdirSync("/proc").filter(name => /^\d+$/.test(name))) {
+    try {
+      const match = /^bunterm:tty([1-9][0-9]*)$/.exec(readFileSync(`/proc/${pid}/comm`, "utf8").trim());
+      if (!match) continue;
+      const number = Number(match[1]);
+      if (number > 63 || !processHoldsDevice(pid, statSync(`/dev/tty${number}`).rdev)) continue;
+      entries.set(number, { number, label: `tty${number} — bunterm${number === initial ? " / initial console" : ""}` });
+    } catch {} // processes can exit during the scan
+  }
+  return [...entries.values()].sort((a, b) => a.number - b.number);
+};
+
+// Match the menu: append after the last known session, reserving tty1.
+export const nextVirtualTerminal = (entries = listVirtualTerminals()) => {
+  const number = Math.max(1, ...entries.map(entry => entry.number)) + 1;
+  if (number > 63) throw new Error("沒有可用 tty / No next tty available");
+  return number;
+};

package/initramfs/lib/canvas.js

@@ -1,3 +1,4 @@
+import {rawImageData, rawImageOpaque, skiaImage} from './raw-image.js';
 // /lib/canvas.js — CanvasKit (Skia in WebAssembly) on the Linux framebuffer.
 //
 // Skia draws into a buffer inside the wasm heap that already has the
@@ -80,6 +81,17 @@ export const openCanvas = (CanvasKit, display) => {
   memory.toTypedArray().set(previousPixels.subarray(0, length));
   display.pixels = memory.toTypedArray();
   let open = true;
+  let cachedImage = null, cachedOpaque = false;
+  let imageMemory = null, imageCapacity = 0;
+  const directRaw = (image, rect, source) => {
+    const raw = rawImageData(image);
+    if (!raw || display.bitsPerPixel !== 32 || raw.colorType !== colorType) return null;
+    const [left, top, right, bottom] = rect, [sx, sy, ex, ey] = source;
+    if (![...rect, ...source].every(Number.isInteger)
+        || right - left !== ex - sx || bottom - top !== ey - sy
+        || sx < 0 || sy < 0 || ex > raw.width || ey > raw.height || ex <= sx || ey <= sy) return null;
+    return rawImageOpaque(raw) ? raw : null;
+  };
   return {
     CanvasKit,
     display,
@@ -88,6 +100,90 @@ export const openCanvas = (CanvasKit, display) => {
     colorType,
     width: display.width,
     height: display.height,
+    // Only exact, opaque 32-bit copies bypass Skia. Keep at most one decoded
+    // image (32 MiB); scaled, translucent and 16-bit images use normal drawing.
+    canDrawRawImage(image, rect, source) { return Boolean(directRaw(image, rect, source)); },
+    drawOpaqueImage(image, rect, source, bands) {
+      if (!open) throw new Error("canvas is closed");
+      const [left, top, right, bottom] = rect;
+      const [sx, sy, ex, ey] = source;
+      const width = image.width(), height = image.height();
+      if (display.bitsPerPixel !== 32 || ![...rect, ...source].every(Number.isInteger)
+          || right - left !== ex - sx || bottom - top !== ey - sy
+          || sx < 0 || sy < 0 || ex > width || ey > height
+          || ex <= sx || ey <= sy || width * height * 4 > 32 * 1024 * 1024) return false;
+      const raw = directRaw(image, rect, source);
+      if (!raw) image = skiaImage(image);
+      if (!raw && cachedImage !== image) {
+        cachedImage = image;
+        cachedOpaque = false;
+        const size = width * height * 4;
+        if (size > imageCapacity) {
+          if (imageMemory) CanvasKit.Free(imageMemory);
+          imageMemory = CanvasKit.Malloc(Uint8Array, size);
+          imageCapacity = size;
+        }
+        // Supplying a destination bypasses CanvasKit's JS return-type switch,
+        // which otherwise rejects BGRA and copies supported formats out of WASM.
+        const info = {width, height, colorType,
+          alphaType: CanvasKit.AlphaType.Unpremul, colorSpace: CanvasKit.ColorSpace.SRGB};
+        let pixels = image.readPixels(0, 0, info, imageMemory, width * 4);
+        let swap = false;
+        if (!pixels && colorType === CanvasKit.ColorType.BGRA_8888) {
+          pixels = image.readPixels(0, 0, {...info, colorType: CanvasKit.ColorType.RGBA_8888}, imageMemory, width * 4);
+          swap = true;
+        }
+        if (pixels) {
+          cachedOpaque = true;
+          for (let i = 0; i < size; i += 4) {
+            if (pixels[i + 3] !== 255) { cachedOpaque = false; break; }
+            if (swap) {
+              const red = pixels[i]; pixels[i] = pixels[i + 2]; pixels[i + 2] = red;
+            }
+          }
+        }
+      }
+      if (!raw && !cachedOpaque) return false;
+      surface.flush();
+      // Drawing elsewhere can grow the WASM heap between cache hits.
+      const sourcePixels = raw ? raw.pixels : imageMemory.toTypedArray();
+      const target = memory.toTypedArray();
+      const x0 = Math.max(0, left), x1 = Math.min(display.width, right);
+      if (x1 <= x0) return true;
+      for (const [bandTop, bandBottom] of bands) {
+        const y0 = Math.max(0, top, bandTop), y1 = Math.min(display.height, bottom, bandBottom);
+        for (let y = y0; y < y1; y++) {
+          const offset = ((sy + y - top) * width + sx + x0 - left) * 4;
+          target.set(sourcePixels.subarray(offset, offset + (x1 - x0) * 4), y * display.stride + x0 * 4);
+        }
+      }
+      return true;
+    },
+    // Save/restore small overlays in native pixel format, without decoding or
+    // channel conversion. Refresh the WASM view after every possible allocation.
+    saveRegion(left, top, right, bottom) {
+      if (!open) throw new Error("canvas is closed");
+      surface.flush();
+      const x = Math.max(0, Math.min(display.width, Math.floor(left))), y = Math.max(0, Math.min(display.height, Math.floor(top)));
+      const width = Math.max(0, Math.min(display.width, Math.ceil(right)) - x);
+      const height = Math.max(0, Math.min(display.height, Math.ceil(bottom)) - y);
+      const rowBytes = width * (display.bitsPerPixel / 8);
+      const pixels = new Uint8Array(rowBytes * height), source = memory.toTypedArray();
+      for (let row = 0; row < height; row++) {
+        const offset = (y + row) * display.stride + x * (display.bitsPerPixel / 8);
+        pixels.set(source.subarray(offset, offset + rowBytes), row * rowBytes);
+      }
+      return {x, y, height, rowBytes, pixels};
+    },
+    restoreRegion(region) {
+      if (!open) throw new Error("canvas is closed");
+      surface.flush();
+      const target = memory.toTypedArray();
+      for (let row = 0; row < region.height; row++) {
+        target.set(region.pixels.subarray(row * region.rowBytes, (row + 1) * region.rowBytes),
+          (region.y + row) * display.stride + region.x * (display.bitsPerPixel / 8));
+      }
+    },
     // Finishes pending Skia work and copies the frame to the framebuffer.
     // toTypedArray() is re-read because wasm heap growth detaches old views.
     flush() {
@@ -101,6 +197,9 @@ export const openCanvas = (CanvasKit, display) => {
     close() {
       if (!open) return;
       open = false;
+      cachedImage = null; cachedOpaque = false;
+      if (imageMemory) CanvasKit.Free(imageMemory);
+      imageMemory = null; imageCapacity = 0;
       previousPixels.set(memory.toTypedArray().subarray(0, previousPixels.length));
       display.pixels = previousPixels;
       surface.delete();