buninu-linux 0.14.57 → 0.16.59

package/initramfs/lib/chvt.js

@@ -0,0 +1,31 @@
+// Use the same VT_ACTIVATE/VT_WAITACTIVE path as bunterm. Never take VT ownership.
+export function parseChvt(args) {
+  if (args.length === 1 && ["-h", "--help"].includes(args[0])) return { help: true };
+  if (args.length !== 1 || !/^[0-9]+$/.test(args[0]) || Number(args[0]) < 1 || Number(args[0]) > 63)
+    throw new Error("usage: chvt N (1–63); see chvt -h or --help");
+  return { number: Number(args[0]) };
+}
+
+export async function switchVt(number, backend) {
+  if (!Number.isInteger(number) || number < 1 || number > 63) throw new Error("VT number must be 1–63");
+  const { openConsole, activeConsole, activateConsole } = backend ?? await import("./fbdev.js");
+  const failures = [];
+  let consoleDevice;
+  // /dev/tty in bunterm is a PTY, and /dev/console may be a serial console.
+  // Probe VT_GETSTATE before accepting an open fd.
+  for (const path of ["/dev/tty0", "/dev/tty", "/dev/console"]) {
+    let candidate;
+    try {
+      candidate = openConsole([path]);
+      activeConsole(candidate);
+      consoleDevice = candidate;
+      break;
+    } catch (error) {
+      candidate?.close();
+      failures.push(`${path}: ${error.message}`);
+    }
+  }
+  if (!consoleDevice) throw new Error(`no accessible Linux VT (${failures.join("; ")})`);
+  try { activateConsole(consoleDevice, number); }
+  finally { consoleDevice.close(); }
+}

package/initramfs/lib/fbdev.js

@@ -261,17 +261,41 @@ export const clear = (display, color = { r: 0, g: 0, b: 0, a: 255 }) => {
   }
 };
 
+// msync is a file writeback operation, not a universal fbdev present API.
+// DRM mappings may have no backing fsync operation (vfs_fsync_range then
+// returns EINVAL). Keep working drivers' deferred-I/O sync, but probe unsupported
+// mappings only once. The address is the original mmap base, and flags are fixed.
+export const syncFramebuffer = (display, native = {
+  msync: (...args) => libc.symbols.msync(...args), errno, strerror,
+}) => {
+  if (display.msyncUnsupported) return;
+  for (;;) {
+    if (native.msync(display.address, display.memoryLength, MS_SYNC) !== -1) return;
+    const code = native.errno();
+    if (code === 4) continue; // EINTR
+    if (code === 22 || code === 95) { // EINVAL / EOPNOTSUPP on this device mapping
+      display.msyncUnsupported = true;
+      return;
+    }
+    throw new Error(`msync(${display.path}): ${native.strerror(code)}`);
+  }
+};
+
 export const flush = (display) => {
   const visibleBytes = display.width * display.bytesPerPixel;
-  for (let y = 0; y < display.height; y++) {
-    const row = display.pixels.subarray(y * display.stride, y * display.stride + visibleBytes);
-    const position = (y + display.yOffset) * display.stride
-      + display.xOffset * display.bytesPerPixel;
-    display.memory.set(row, position);
-  }
-  if (libc.symbols.msync(display.address, display.memoryLength, MS_SYNC) === -1) {
-    fail(`msync(${display.path})`);
+  if (display.xOffset === 0 && display.stride === visibleBytes) {
+    // Contiguous visible rows need one bulk copy, not one JS call per row.
+    display.memory.set(display.pixels.subarray(0, display.height * display.stride),
+      display.yOffset * display.stride);
+  } else {
+    for (let y = 0; y < display.height; y++) {
+      const row = display.pixels.subarray(y * display.stride, y * display.stride + visibleBytes);
+      const position = (y + display.yOffset) * display.stride
+        + display.xOffset * display.bytesPerPixel;
+      display.memory.set(row, position);
+    }
   }
+  syncFramebuffer(display);
 };
 
 // Copies an RGBA ImageData (HTML canvas layout, 4 bytes per pixel, rows of

package/initramfs/lib/gpu.js

@@ -0,0 +1,77 @@
+// Explicit one-shot GPU coldplug. Importing this module never loads a driver.
+import * as fs from "node:fs";
+import { join, basename } from "node:path";
+
+const drivers = new Set(["i915", "xe", "amdgpu", "radeon", "nouveau", "virtio_gpu", "vmwgfx"]);
+export const isGpuPath = (_module, path) => path.startsWith("kernel/drivers/gpu/");
+export const isGpuDriver = (module, path) => isGpuPath(module, path) && drivers.has(module.replaceAll("-", "_"));
+
+export const framebufferUsers = ({ root = "/", io = fs } = {}) => {
+  const users = [];
+  for (const pid of io.readdirSync(join(root, "proc")).filter(name => /^\d+$/.test(name))) {
+    try {
+      const dir = join(root, "proc", pid, "fd");
+      let busy = false;
+      for (const fd of io.readdirSync(dir)) {
+        try { if (/^\/dev\/fb\d+(?: \(deleted\))?$/.test(io.readlinkSync(join(dir, fd)))) busy = true; }
+        catch (error) { if (error.code !== "ENOENT") throw error; }
+      }
+      // An mmap can outlive its fd.
+      if (/\/dev\/fb\d+(?:\s|$)/m.test(io.readFileSync(join(root, "proc", pid, "maps"), "utf8"))) busy = true;
+      if (busy) users.push(pid);
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ESRCH") throw error;
+    }
+  }
+  return users;
+};
+
+export const configureGpu = ({ autoload, tryModprobe, root = "/", io = fs, env = process.env, log = console.log } = {}) => {
+  const result = { devices: [], renderNodes: [], framebuffers: [], errors: [], blocked: false };
+  const say = text => { try { log(`[gpu] ${text}`); } catch {} };
+  try {
+    const gid = env.BUNINU_RENDER_GID === undefined ? 0 : Number(env.BUNINU_RENDER_GID);
+    if (!Number.isInteger(gid) || gid < 0 || gid >= 0xffffffff || env.BUNINU_RENDER_GID === "")
+      throw Error("BUNINU_RENDER_GID must be a numeric group ID");
+    const users = framebufferUsers({ root, io });
+    if (users.length) {
+      result.blocked = true;
+      say(`not loaded: framebuffer in use by PID ${users.join(", ")}; exit bunterm/fbdev and run cfg.gpu before reopening it`);
+      return result;
+    }
+    // A virtio GPU may not appear on the virtio bus until its PCI transport loads.
+    try { tryModprobe("virtio_pci"); } catch (error) { result.errors.push(`virtio_pci: ${error?.message ?? error}`); }
+    result.devices = autoload({ buses: ["pci", "virtio"], acceptModule: isGpuDriver });
+    for (const device of result.devices) {
+      if (device.error) result.errors.push(`${device.bus}/${device.device}: ${device.error}`);
+      say(`${device.bus}/${device.device} ${device.modules.join(" ")}: ${device.error ?? (device.loaded.length ? "loaded " + device.loaded.join(" ") : "already loaded/probed")}`);
+    }
+    const list = path => { try { return io.readdirSync(join(root, path)); } catch (error) { if (error.code === "ENOENT") return []; throw error; } };
+    for (const name of list("dev/dri").filter(name => /^renderD\d+$/.test(name)).sort()) {
+      const path = join(root, "dev/dri", name);
+      try {
+        if (!io.statSync(path).isCharacterDevice()) continue;
+        io.chownSync(path, 0, gid);
+        io.chmodSync(path, 0o660);
+        let driver = "unknown";
+        try {
+          const device = join(root, "sys/class/drm", name, "device");
+          driver = basename(io.readlinkSync(join(device, "driver")));
+          // virtio DRM nodes can point at the parent PCI transport device.
+          if (driver === "virtio-pci") for (const child of io.readdirSync(device).filter(n => /^virtio\d+$/.test(n))) {
+            const candidate = basename(io.readlinkSync(join(device, child, "driver")));
+            if (candidate === "virtio_gpu" || candidate === "virtio-gpu") { driver = candidate; break; }
+          }
+        } catch {}
+        result.renderNodes.push({ path: `/dev/dri/${name}`, driver, gid });
+        say(`/dev/dri/${name}: driver=${driver}, root:${gid} mode=0660`);
+      } catch (error) { result.errors.push(`${name}: ${error?.message ?? error}`); }
+    }
+    result.framebuffers = list("dev").filter(name => /^fb\d+$/.test(name)).sort().map(name => `/dev/${name}`);
+    say(`framebuffer: ${result.framebuffers.join(", ") || "none"}; reopen framebuffer clients after GPU handoff`);
+    if (!result.renderNodes.length) say("no accessible render node yet; check kernel firmware/driver messages and GPU support, then retry cfg.gpu after probing finishes");
+    say("clients still need their own Mesa/Vulkan driver; non-root clients need the render node's numeric group");
+  } catch (error) { result.errors.push(String(error?.message ?? error)); }
+  for (const error of result.errors) say(`failed: ${error}; init continues`);
+  return result;
+};

package/initramfs/lib/mapped-frame.js

@@ -0,0 +1,28 @@
+// Only buffers created by our mmap reader may be detached. Ordinary buffers,
+// pooled Buffer slabs and callers' pixel arrays retain their normal lifetime.
+const mappings = new WeakMap();
+
+export function ownMapping(bytes) {
+  const buffer = bytes.buffer;
+  if (mappings.has(buffer)) throw Error('mapping already owned');
+  mappings.set(buffer, {refs: 0});
+  return retainMapping(bytes);
+}
+
+export function retainMapping(bytes) {
+  const buffer = bytes?.buffer;
+  const state = buffer && mappings.get(buffer);
+  if (!state) return null;
+  state.refs++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    if (--state.refs) return;
+    mappings.delete(buffer);
+    // Transfer to zero bytes runs Bun's mmap deallocator immediately, rather
+    // than batching many full frames into a later GC pause. Older runtimes or
+    // non-detachable buffers safely fall back to ordinary GC reclamation.
+    try { buffer.transfer?.(0); } catch {}
+  };
+}

package/initramfs/lib/raw-image.js

@@ -0,0 +1,71 @@
+import {retainMapping} from "./mapped-frame.js";
+// Retain immutable raw pixels until an operation actually needs a Skia Image.
+// The native image store owns these handles; encoded images remain ordinary Skia images.
+const rawImages = new WeakMap();
+const littleEndian = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+export const rawImageData = image => rawImages.get(image);
+export const skiaImage = image => rawImages.get(image)?.materialize() ?? image;
+
+export function createRawImage(CanvasKit, pixels, width, height, colorType) {
+  let decoded = null, closed = false;
+  const release = retainMapping(pixels);
+  const data = {
+    pixels, width, height, colorType,
+    opaque: undefined,
+    materialize() {
+      if (closed) throw Error('raw image is closed');
+      if (!decoded) {
+        decoded = CanvasKit.MakeImage({width, height, colorType,
+          alphaType: CanvasKit.AlphaType.Unpremul, colorSpace: CanvasKit.ColorSpace.SRGB}, pixels, width * 4);
+        if (!decoded) throw Error('raw image rejected');
+      }
+      return decoded;
+    },
+  };
+  const image = {
+    width: () => width,
+    height: () => height,
+    delete() {
+      if (closed) return;
+      closed = true;
+      try { decoded?.delete(); }
+      finally {
+        decoded = null;
+        data.pixels = pixels = null;
+        rawImages.delete(image);
+        release?.();
+      }
+    },
+  };
+  rawImages.set(image, data);
+  return image;
+}
+
+// Check actual bytes once; raw protocol support does not imply opacity.
+export function rawImageOpaque(data) {
+  if (data.opaque === undefined) {
+    const pixels = data.pixels;
+    data.opaque = true;
+    if (littleEndian && pixels.byteOffset % 4 === 0 && pixels.byteLength % 4 === 0) {
+      const words = new Uint32Array(pixels.buffer, pixels.byteOffset, pixels.byteLength / 4);
+      let i = 0;
+      // All eight alpha bytes must be 255 for their AND to stay 255. Group
+      // the common opaque case without skipping any pixel or reading a tail.
+      for (; i + 7 < words.length; i += 8) {
+        if (((words[i] & words[i + 1] & words[i + 2] & words[i + 3]
+          & words[i + 4] & words[i + 5] & words[i + 6] & words[i + 7]) >>> 24) !== 255) {
+          data.opaque = false;
+          break;
+        }
+      }
+      for (; data.opaque && i < words.length; i++) {
+        if ((words[i] >>> 24) !== 255) { data.opaque = false; break; }
+      }
+    } else {
+      for (let i = 3; i < pixels.length; i += 4) {
+        if (pixels[i] !== 255) { data.opaque = false; break; }
+      }
+    }
+  }
+  return data.opaque;
+}

package/initramfs/lib/xdg-open.js

@@ -0,0 +1,42 @@
+import { realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export function browserTarget(target, cwd = process.cwd()) {
+  if (/^about:/i.test(target)) return target;
+  if (/^https?:\/\//i.test(target)) {
+    // Reject malformed URLs before starting a new terminal.
+    try { return new URL(target).href; }
+    catch { throw openError("Invalid HTTP/HTTPS URL", 1); }
+  }
+  const fileUrl = /^file:/i.test(target);
+  if (!fileUrl && /^[a-z][a-z0-9+.-]*:/i.test(target)) {
+    throw openError("Unsupported URL scheme; use http://, https://, about: or a local file", 4);
+  }
+  const path = realpathSync(fileUrl ? fileURLToPath(target) : resolve(cwd, target));
+  if (!statSync(path).isFile()) throw openError("Expected a regular file", 4);
+  // Encode spaces, #, %, and non-ASCII characters as URL path components.
+  return pathToFileURL(path).href;
+}
+
+export function parseOpenArgs(args) {
+  if (args.length === 1 && ["-h", "--help", "--manual"].includes(args[0])) return { help: true };
+  if (args.length === 1 && args[0] === "--version") return { version: true };
+  if (args.length !== 1 || !args[0]) throw openError("Usage: xdg-open URL | FILE (see --help)", 1);
+  if (args[0].startsWith("-")) throw openError("Use ./ before a filename beginning with '-'", 1);
+  return { target: args[0] };
+}
+
+export function openError(message, exitCode) {
+  return Object.assign(new Error(message), { exitCode });
+}
+
+export function openExitCode(error) {
+  return error.exitCode ?? (["ENOENT", "ENOTDIR"].includes(error.code) ? 2 : 4);
+}
+
+export function releaseVersion(text) {
+  const value = /^VERSION_ID=(.*)$/m.exec(text)?.[1]?.trim();
+  if (!value) throw new Error("VERSION_ID missing from os-release");
+  return value.replace(/^["']|["']$/g, "");
+}

package/initramfs/usr/share/doc/buninu-linux/bunterm.md

@@ -8,7 +8,7 @@ box drawing and kitty graphics protocol images — no X11, Wayland or GPU.
 ```sh
 bunterm 2                    # start a detached bunterm on /dev/tty2
 bunterm /dev/tty2            # the full virtual-console spelling also works
-bunterm                      # take over the console you are on (on tty1 that hides the bun-repl)
+bunterm                      # open a new VT after the last session; first is tty2
 bunterm -s 20                # short for --font-size 20
 bunterm -e bun /buninu/apps/jsmdcui/src/index.js --demo
 bunterm --no-mouse          # keyboard only
@@ -16,14 +16,19 @@ bunterm --no-clipboard      # ignore OSC 52 copy and paste
 bunterm -h
 ```
 
+Use `chvt 1` inside bunterm to return to tty1 without stopping it, and
+`chvt 2` from a shell to return to a bunterm started on tty2. See `chvt --help`
+for use from the init REPL.
+
 The program's `TERM` is `xterm-256color`, `COLORTERM=truecolor`,
 `TERM_PROGRAM=bunterm` and `JSMDCUI_KITTY_MODE=extended` (so `jsmdcui` shows
 Markdown images without `--kitty`). When it exits, the console returns to
 text mode and `bunterm` exits with its status.
 
 Every live session has a canonical `/bin/bunterm /dev/ttyN ...` command line.
-When no console is named, the currently active VT is used in the foreground.
-Naming a different VT starts bunterm as a detached session and returns
+When no console is named, a new VT after the last known session is selected,
+starting at tty2 and keeping tty1 for hardware setup.
+Using a VT other than the active one starts bunterm as a detached session and returns
 immediately to the calling shell. Only one bunterm may control a given VT;
 ownership is
 identified from the process task name and its open console descriptor under
@@ -33,14 +38,14 @@ identified from the process task name and its open console descriptor under
 
 | Option | Meaning |
 | --- | --- |
-| `N`, `/dev/ttyN` | The virtual console to use for graphics and the keyboard; for example, `2` means `/dev/tty2`. Naming a VT other than the active one starts a detached bunterm there, switches the display to it, and immediately returns control to the calling shell. Without this argument, bunterm uses the active VT in the foreground. |
+| `N`, `/dev/ttyN` | The virtual console to use for graphics and the keyboard; for example, `2` means `/dev/tty2`. Naming a VT other than the active one starts a detached bunterm there, switches the display to it, and immediately returns control to the calling shell. Without this argument, bunterm selects the next VT after the last known session (tty2 initially). |
 | `-e command [argument...]` | The program to run; everything after `-e` belongs to it. Default `/bin/sh`. |
 | `-s N`, `--font-size N` | Font size in pixels (default 13). The cell is 0.6 × N wide and 1.16 × N tall with DejaVu Sans Mono, so 1024×768 at 16 px gives 106 × 41 cells. |
 | `--line-height F` | Multiplies the cell height (default 1). |
 | `--fb /dev/fbN` | The framebuffer device (default `/dev/fb0`). |
 | `--no-blink` | A steady cursor. |
 | `--no-mouse` | Do not attach a pointing device; nothing then reads `/dev/input`. |
-| `--no-clipboard` | Ignore OSC 52: programs can neither copy to nor read from the clipboard, and `xclip` is never run. |
+| `--no-clipboard` | Disable both OSC 52 and menu copy/paste; `xclip` is never run. |
 
 ## What is drawn
 
@@ -66,7 +71,7 @@ identified from the process task name and its open console descriptor under
 
 ## Keyboard
 
-The console stays in the kernel's translated keyboard mode, so
+Without Kitty keyboard negotiation, the console stays in the kernel's translated keyboard mode, so
 `Ctrl-Alt-F2` and friends still switch consoles; coming back repaints the
 screen. While its VT is inactive, bunterm continues consuming PTY output and
 updating its scrollback and kitty images, but neither writes the framebuffer
@@ -76,6 +81,28 @@ forth through the normal Linux VT switch. A few console-specific
 sequences are rewritten to xterm's (`F1`–`F5`, `Home`, `End`), and arrow keys
 follow the program's application cursor mode.
 
+### Kitty keyboard
+
+The Kitty keyboard protocol uses the same encoder as jsgotty 1.2.0:
+flags **1** (disambiguation), **2** (press/repeat/release), and **8** (all keys).
+Applications enable it with `CSI > flags u`, query with `CSI ? u`, and restore
+with `CSI < u`; normal and alternate buffers have separate stacks. Flags 4
+(alternate keys) and 16 (associated text) are not advertised.
+
+Only while an application enables Kitty, the active console uses Linux
+`K_MEDIUMRAW` to distinguish Ctrl, Alt, Shift, Super, keypad and key releases.
+Bunterm restores the original mode on pop/reset or exit. Ctrl+Alt+F1–F12 and
+Alt+Left/Right remain reserved for VT switching. The kernel keymap supplies
+printable characters, including Shift/Caps Lock/AltGr. Kernel dead-key/Compose
+sequences are not implemented in this Kitty path; the ordinary translated
+console path retains its existing behavior. No global evdev keyboard grab is
+needed. A mode transition discards pending console typeahead so raw keycodes
+cannot leak into the child as text.
+
+中文：Kitty 模式與 jsgotty 支援相同的 flags 1、2、8，可區分 Super、
+Ctrl/Alt/Shift 組合及按下／重複／放開。程式退出模式後恢復原有 console
+輸入；Ctrl+Alt+Fn、Alt+左右保留為切換 VT。Kitty 模式尚不處理 dead key／Compose。
+
 ## Mouse
 
 Every pointing device under `/dev/input/event*` is opened and an arrow is
@@ -94,6 +121,13 @@ arrow keys on the alternate screen, which has no scrollback and is what a
 pager expects. Typing returns to the live screen, and the text cursor is
 hidden while it is scrolled out of view.
 
+When mouse reporting is off, left-drag selects terminal text. Wide characters
+and graphemes are selected whole; wrapped lines copy without extra newlines.
+Use **Copy** in the top-left menu to send the selection to xclip. Selection is
+cleared when new PTY text arrives or the font size changes, so it cannot refer
+to replaced cells. Applications requesting mouse reporting receive the drag
+instead; selection never overrides their mouse mode.
+
 `--no-mouse` turns all of this off: the terminal then never looks at
 `/dev/input` and never loads the mouse module.
 
@@ -114,7 +148,12 @@ bunterm keeps no clipboard of its own: `ESC ] 52 ; c ; <base64>` is passed to
 with the output of `xclip -selection clipboard -o`, so every bunterm session
 shares the same clipboard as `xclip`. A query xclip cannot answer is replied
 to with empty contents. `--no-clipboard` turns this off, so a program can
-neither set nor read the clipboard through the terminal.
+neither set nor read the clipboard through the terminal; menu copy/paste is
+also disabled. The menu's **Paste** reads xclip and sends one paste to the PTY,
+wrapped in `CSI 200~` / `CSI 201~` when the application enabled bracketed paste
+(`DECSET 2004`). Programs that have not requested it receive plain text.
+Newlines are normalized to CR; embedded ESC bytes are stripped in bracketed
+mode so clipboard text cannot close the paste early.
 
 ## Limits
 
@@ -123,10 +162,8 @@ neither set nor read the clipboard through the terminal.
   `--linux-lts` or `--real` (efifb/simpledrm from UEFI).
 - The aarch64 image has no framebuffer yet: `run-qemu.sh` gives QEMU's
   `virt` machine no display device, so there is no `/dev/fb0` to draw on.
-- No selection, and no keyboard way to scroll back: the wheel is it. The
-  buffer keeps 1000 lines. A program that does not enable mouse reporting
-  sees no clicks — the arrow still moves, so the pointer is visibly alive.
-  `--no-mouse` removes the pointer entirely.
+- Scrollback uses the wheel; the buffer keeps 1000 lines.
+  `--no-mouse` removes the pointer and local selection.
 - A program that prints a terminal reply while the tty echoes (that is, one
   not in raw mode) will see the reply echoed, as on any terminal.
 - Kitty images are drawn above text; `z` ordering below text and animation
@@ -143,3 +180,40 @@ neither set nor read the clipboard through the terminal.
 - `/lib/fbdev.js` — the framebuffer itself (`fbdev.md`)
 - `/buninu/apps/jsgotty/gotty.js` — the PTY backend and kitty packet parser
   that are reused
+
+## Local menu and commands
+
+Left-click the top-left **2×2 physical pixels** to open a text menu of live
+bunterm VTs and the initial tty (normally tty1). Click an entry to switch, or use
+Up/Down and Enter. The active VT is marked `(current)`.
+The wheel scrolls the selection; Escape, right-click, or a click
+outside the entries closes the menu. Menu input is consumed locally, including
+when a terminal application has enabled mouse reporting. Requires mouse support.
+The menu switches existing sessions; it does not create a new bunterm.
+
+- **Font − / +** changes the current session's font size and resizes the PTY.
+- **Copy / Paste** uses the same xclip clipboard as OSC 52.
+- Click the light **command input field**, or press Tab, to type a local command.
+  Enter executes it, Tab returns to menu navigation, Esc closes the menu.
+  Backspace/Delete, Left/Right, Home/End and Ctrl+U edit the field.
+
+Commands: `font 16`, `font +`, `font -`, `copy`, `paste`, `vt 2`, `help`.
+Font commands accept integer sizes 6–96; changes last for this session.
+The command registry is `/lib/bunterm/commands.js`; new commands can be added
+there without changing the input widget. These are bunterm commands, not shell
+commands. Clipboard failures and command errors appear in the menu footer.
+
+中文：左鍵點擊螢幕最左上角 2×2 像素，會列出正在運行的 bunterm 和初始 tty。
+目前顯示的 VT 會標示 `(current)`。
+可以點選或用上下鍵、Enter 切換；Esc、右鍵或點擊選項外關閉。不會把選單操作
+送進底下的 shell／應用程式，也不會關閉原本的 bunterm。
+選單還有字體大小減／加、複製／貼上，以及自由輸入的命令框（點選或按 Tab）。
+可輸入 `font 16`、`copy`、`paste`、`vt 2`、`help`；Enter 執行。
+複製前用左鍵拖曳選字，僅在程式未開啟滑鼠回報時生效。貼上沿用 xclip，
+程式啟用 bracketed paste 時會加上貼上邊界。
+
+On GPU-provided fbdev devices, a shared framebuffer mapping may not support
+`msync`. bunterm probes it once: `EINVAL`/`EOPNOTSUPP` disables further msync
+calls for that mapping while pixel writes continue normally. Drivers that
+support msync retain it; other errors still propagate. This is not a vsync or
+GPU-acceleration mechanism.

package/initramfs/usr/share/doc/buninu-linux/chvt.md

@@ -0,0 +1,34 @@
+# chvt — switch Linux virtual terminals
+
+```sh
+chvt 1             # switch to /dev/tty1 (normally the init REPL)
+chvt 2             # switch to /dev/tty2
+chvt -h            # also --help
+```
+
+Accepts one VT number, 1–63. Requires access to a real Linux virtual console
+and permission to switch it (normally root). A PTY alone, including a remote
+terminal or Android terminal, is not a Linux VT.
+
+With bunterm, for example:
+
+```sh
+bunterm 2          # start bunterm on tty2
+chvt 1             # from its shell, return to tty1 without stopping bunterm
+```
+
+Run `chvt 2` from a shell to return, or use Alt+F2 / Ctrl+Alt+F2 as appropriate.
+At the init JavaScript REPL, run a command with
+`Bun.spawnSync(["/bin/chvt", "2"], {stdio: ["inherit", "inherit", "inherit"]})`.
+The command switches the existing VT; it does not start a shell or bunterm on an
+empty VT. bunterm retains ownership of its VT, pauses drawing when switched away,
+and redraws when switched back. chvt does not change keyboard or graphics modes.
+
+Like the traditional command, chvt waits for the target VT to become active,
+then exits. If its current owner refuses to release the VT, the wait can persist. No daemon is created.
+
+中文：`chvt 1` 切至 tty1，`chvt 2` 切回 tty2 的 bunterm；不會結束 bunterm，
+也不會替空白 VT 啟動 shell。切出／切回使用 bunterm 原有的釋放與重繪機制。
+
+Uses Linux VT_ACTIVATE and VT_WAITACTIVE:
+https://man7.org/linux/man-pages/man2/ioctl_vt.2.html

package/initramfs/usr/share/doc/buninu-linux/xdg-open.md

@@ -0,0 +1,43 @@
+# xdg-open — open in a new browser terminal / 開啟瀏覽器
+
+```sh
+xdg-open https://buninu.org
+xdg-open about:audio
+xdg-open ./page.html
+xdg-open "./file with spaces.md"
+xdg-open file:///buninu/page.html
+```
+
+Runs `bunterm -e buninu-browser URL` on a new virtual console. HTTP, HTTPS,
+and `about:` URLs go to the browser. Local files must exist: symbolic links
+are resolved and the real path is encoded as a `file://` URL, including spaces,
+Chinese characters, `#`, and `%`. Markdown also opens in the browser.
+
+透過 bunterm 在新 tty 啟動瀏覽器。本地檔案先確認存在、解析實際路徑，再轉成
+`file://` 網址；Markdown 同樣使用瀏覽器。檔名若以 `-` 開頭，請加上 `./`。
+
+Directories and other schemes (including `data:`, `mailto:` and `ftp:`) are
+not supported. This is Buninu's lightweight implementation, not xdg-utils;
+it does not consult MIME associations or desktop application registrations.
+目前不支援目錄與其他協定，也不查詢 MIME 預設程式關聯。
+
+## Options / 選項
+
+| Option | Meaning |
+| --- | --- |
+| `-h`, `--help`, `--manual` | Show this Markdown manual / 顯示本手冊 |
+| `--version` | Show the Buninu Linux version from the image's os-release / 顯示映像檔的發行版版本 |
+
+## Exit codes / 退出碼
+
+| Code | Meaning |
+| --- | --- |
+| 0 | New terminal launch succeeded / 新終端啟動成功 |
+| 1 | Invalid arguments or URL / 參數或網址格式錯誤 |
+| 2 | Local file does not exist / 本地檔案不存在 |
+| 3 | Required tool not found / 缺少必要工具 |
+| 4 | Opening failed or target unsupported / 開啟失敗或目標不支援 |
+
+bunterm detaches when opening a new VT. Exit code 0 confirms the launcher
+succeeded, not that the browser subsequently loaded the page.
+新 tty 以背景工作階段啟動，因此成功退出不代表後續網頁一定載入成功。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu-linux",
-  "version": "0.14.57",
+  "version": "0.16.59",
   "description": "A Linux distribution running Bun as PID 1 with the Buninu userspace.",
   "type": "module",
   "main": "./index.js",

package/scripts/arch.js

@@ -16,8 +16,8 @@ export const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 const pins = {
   x86_64: {
-    linuxVirtSha256: "414aa2572ef88164b1af9905fa6dfbe863bf50f6130d895d57282dea3e15f7b9",
-    linuxLtsSha256: "7614556471859956a436b95813daf409b444aa849ec899178b404e828c5a9d98",
+    linuxVirtSha256: "73ad4774ca26c196103a00e2fb8d28ed02de4c08c11fad96e903da03dcb085f4",
+    linuxLtsSha256: "ae0a669a08c90ef971996f81f1bcb6f7ca8211ad62624ad8c5b57412c3f1def8",
     muslSha256: "573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71",
     stubSha256: "8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9",
     libstdcppSha256: "14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6",
@@ -32,8 +32,8 @@ const pins = {
     serialMajor: 4,
   },
   aarch64: {
-    linuxVirtSha256: "b3820fee22e0366a15f7c139e5bc00348e333f3e7f77802271df7ded795aee4f",
-    linuxLtsSha256: "67b8f61c5cfb6ac9b5a65cb1610b67d467e6c4ffc17e7d29dbea4bd8c447ff32",
+    linuxVirtSha256: "89b68fc32d61a1483ab0d9db78b5a06144ac115fe2ee8102cb4ad7987f46d524",
+    linuxLtsSha256: "f6387970517083d5f08abacbf81baf1d70e1baa8fe4c2783469f45bb0751075c",
     muslSha256: "5e9674b7f41152fe2119093b5cb4c13eaaadb19c2d5422b2d7267913e663ee6e",
     stubSha256: "a1823d2d7082db555d528f82c1809f276c818aeb5b40f198f4565f104e055c38",
     libstdcppSha256: "2302e766d4e4926038ec166ecb85837ee884576115236ddb565e3a5fca4a11d7",
@@ -58,6 +58,7 @@ export const config = ({
   arch = process.env.BUNINU_ARCH || "x86_64",
   flavor = process.env.LINUX_FLAVOR || "virt",
   real = process.env.REAL_MACHINE === "1",
+  noGpu = process.env.BUNINU_NO_GPU === "1",
   mirror = process.env.ALPINE_MIRROR || "https://dl-cdn.alpinelinux.org/alpine",
 } = {}) => {
   arch = normalizeArch(arch);
@@ -67,7 +68,7 @@ export const config = ({
   // The Alpine repository keeps only the newest build of a package, so a pin
   // stops downloading when Alpine bumps it; the hashes then fail loudly.
   const alpineBase = `${mirror}/v3.24/main/${arch}`;
-  const kernelVersion = "6.18.57";
+  const kernelVersion = "6.18.59";
   const kernelRelease = `${kernelVersion}-0-${flavor}`;
   const bunVersion = "1.4.2";
   const downloadsDir = join(rootDir, "downloads", arch);
@@ -77,6 +78,7 @@ export const config = ({
     arch,
     flavor,
     real,
+    noGpu,
     rootDir,
     alpineBase,
     kernelVersion,

package/scripts/arch.sh

@@ -44,7 +44,7 @@ fi
 alpine_mirror=${ALPINE_MIRROR:-https://dl-cdn.alpinelinux.org/alpine}
 alpine_base="$alpine_mirror/v3.24/main/$arch"
 
-kernel_version=6.18.57
+kernel_version=6.18.59
 kernel_release="$kernel_version-0-$linux_flavor"
 linux_package="linux-$linux_flavor-$kernel_version-r0.apk"
 musl_package=musl-1.2.6-r2.apk
@@ -63,8 +63,8 @@ musl_libc="libc.musl-$arch.so.1"
 
 case $arch in
     x86_64)
-        linux_virt_sha256=414aa2572ef88164b1af9905fa6dfbe863bf50f6130d895d57282dea3e15f7b9
-        linux_lts_sha256=7614556471859956a436b95813daf409b444aa849ec899178b404e828c5a9d98
+        linux_virt_sha256=73ad4774ca26c196103a00e2fb8d28ed02de4c08c11fad96e903da03dcb085f4
+        linux_lts_sha256=ae0a669a08c90ef971996f81f1bcb6f7ca8211ad62624ad8c5b57412c3f1def8
         musl_sha256=573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71
         stub_sha256=8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9
         libstdcpp_sha256=14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6
@@ -82,8 +82,8 @@ case $arch in
         serial_major=4
         ;;
     aarch64)
-        linux_virt_sha256=b3820fee22e0366a15f7c139e5bc00348e333f3e7f77802271df7ded795aee4f
-        linux_lts_sha256=67b8f61c5cfb6ac9b5a65cb1610b67d467e6c4ffc17e7d29dbea4bd8c447ff32
+        linux_virt_sha256=89b68fc32d61a1483ab0d9db78b5a06144ac115fe2ee8102cb4ad7987f46d524
+        linux_lts_sha256=f6387970517083d5f08abacbf81baf1d70e1baa8fe4c2783469f45bb0751075c
         musl_sha256=5e9674b7f41152fe2119093b5cb4c13eaaadb19c2d5422b2d7267913e663ee6e
         stub_sha256=a1823d2d7082db555d528f82c1809f276c818aeb5b40f198f4565f104e055c38
         libstdcpp_sha256=2302e766d4e4926038ec166ecb85837ee884576115236ddb565e3a5fca4a11d7