buninu-linux 0.13.56 → 0.15.58

package/scripts/fetch-gpu.js

@@ -0,0 +1,105 @@
+// Firmware is image data, not a running service. Only cfg.gpu loads GPU drivers.
+import { createHash } from "node:crypto";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, rmSync, symlinkSync, statSync, mkdtempSync, renameSync } from "node:fs";
+import { join, dirname, posix } from "node:path";
+import pins from "./gpu-firmware.json" with { type: "json" };
+import { config, runIfMain, withUmask022 } from "./arch.js";
+import { download, readTar } from "./fetch.js";
+
+const fingerprint = (cfg) => createHash("sha256").update(JSON.stringify({ revision: 2, arch: cfg.arch, release: cfg.kernelRelease, real: !!cfg.real, noGpu: !!cfg.noGpu, pins })).digest("hex");
+const marker = (cfg) => join(cfg.modulesRoot, "gpu-support.json");
+
+export const gpuReady = (cfg) => {
+  try {
+    const state = JSON.parse(readFileSync(marker(cfg), "utf8"));
+    if (cfg.noGpu && existsSync(join(cfg.nativeDir, "lib/firmware"))) return false;
+    return state.fingerprint === fingerprint(cfg) && state.files.every(path => statSync(join(cfg.nativeDir, path)).size > 0);
+  } catch { return false; }
+};
+
+// Validate paths before writing; firmware packages can link across GPU folders.
+export const firmwarePath = (name) => {
+  if (!name.startsWith("lib/firmware/") || name.includes("\\") || posix.normalize(name) !== name || name.endsWith("/"))
+    throw Error(`Invalid firmware path: ${name}`);
+  return name;
+};
+export const firmwareLinkTarget = (name, { target, hard }) => {
+  firmwarePath(name);
+  if (target.startsWith("/") || target.includes("\\")) throw Error(`Invalid firmware link: ${name} -> ${target}`);
+  return firmwarePath(posix.normalize(hard ? target : posix.join(posix.dirname(name), target)));
+};
+
+export const extractFirmware = (archives, staging) => {
+  const files = new Map(), links = new Map();
+  for (const archive of archives) {
+    for (const [name, bytes] of archive.entries()) if (name.startsWith("lib/firmware/")) files.set(firmwarePath(name), bytes);
+    for (const [name, link] of archive.links()) if (name.startsWith("lib/firmware/")) {
+      firmwareLinkTarget(name, link);
+      links.set(name, link);
+    }
+  }
+  const directories = new Set();
+  for (const name of [...files.keys(), ...links.keys()])
+    for (let parent = posix.dirname(name); parent !== "."; parent = posix.dirname(parent)) directories.add(parent);
+  // NVIDIA also aliases entire GPU firmware directories. Resolve links in any
+  // path component, without following host filesystem links during validation.
+  const resolve = (name, seen = new Set()) => {
+    if (seen.has(name)) throw Error(`Firmware link cycle: ${name}`);
+    seen.add(name);
+    for (let prefix = name; prefix !== "."; prefix = posix.dirname(prefix)) {
+      const link = links.get(prefix);
+      if (link) {
+        if (seen.has("link:" + prefix)) throw Error(`Firmware link cycle: ${prefix}`);
+        seen.add("link:" + prefix);
+        return resolve(firmwareLinkTarget(prefix, link) + name.slice(prefix.length), seen);
+      }
+    }
+    if (files.has(name)) return files.get(name);
+    if (directories.has(name)) return null;
+    throw Error(`Missing firmware link target: ${name}`);
+  };
+  for (const name of [...files.keys(), ...links.keys()]) {
+    for (let parent = posix.dirname(name); parent !== "."; parent = posix.dirname(parent))
+      if (links.has(parent) || files.has(parent)) throw Error(`Firmware parent is not a directory: ${parent}`);
+    if (links.has(name)) {
+      if (files.has(name)) throw Error(`Duplicate firmware file/link: ${name}`);
+      if (resolve(name) === null && links.get(name).hard) throw Error(`Firmware hardlink to directory: ${name}`);
+    }
+  }
+  for (const [name, bytes] of files) {
+    const path = join(staging, name); mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, bytes);
+  }
+  for (const [name, link] of links) {
+    const path = join(staging, name); mkdirSync(dirname(path), { recursive: true });
+    if (files.has(name)) throw Error(`Duplicate firmware file/link: ${name}`);
+    if (link.hard) writeFileSync(path, resolve(name));
+    else symlinkSync(link.target, path);
+  }
+  return [...files.keys(), ...links.keys()];
+};
+
+export const fetchGpuFirmware = (cfg = config()) => withUmask022(async () => {
+  const dep = readFileSync(join(cfg.modulesRoot, "modules.dep"), "utf8");
+  const builtin = readFileSync(join(cfg.modulesRoot, "modules.builtin"), "utf8");
+  const pc = !cfg.noGpu && cfg.arch === "x86_64" && /\/(?:i915|xe|amdgpu|radeon|nouveau)\.ko(?:[:\n]|$)/.test(dep + "\n" + builtin);
+  // Firmware bytes are architecture-independent; these pins refer to the x86_64 APKs.
+  const packages = pc ? pins : [];
+  const archives = [];
+  for (const pkg of packages) archives.push(readTar(await download(cfg, `${cfg.alpineBase}/${pkg.name}`, pkg.name, pkg.sha256)));
+  mkdirSync(join(cfg.nativeDir, "lib"), { recursive: true });
+  const staging = mkdtempSync(join(cfg.nativeDir, "lib", ".gpu-firmware-"));
+  try {
+    const files = extractFirmware(archives, staging);
+    const target = join(cfg.nativeDir, "lib/firmware");
+    // This generated directory is owned by the firmware fetch stage.
+    rmSync(target, { recursive: true, force: true });
+    if (files.length) renameSync(join(staging, "lib/firmware"), target);
+    writeFileSync(marker(cfg), JSON.stringify({ fingerprint: fingerprint(cfg), packages, files }, null, 2) + "\n");
+    console.log(`GPU support: ${packages.length} firmware packages, ${files.length} files/links; drivers stay opt-in via cfg.gpu`);
+  } finally { rmSync(staging, { recursive: true, force: true }); }
+});
+
+runIfMain(import.meta.url, async () => {
+  if (process.argv.includes("--check")) process.exitCode = gpuReady(config()) ? 0 : 1;
+  else await fetchGpuFirmware();
+});

package/scripts/fetch.js

@@ -73,7 +73,9 @@ export const download = async (cfg, url, name, sha256) => {
 export const readTar = (path) => {
   const data = gunzipSync(readFileSync(path));
   const files = new Map();
+  const links = new Map();
   let longName = null;
+  let longLink = null;
   for (let offset = 0; offset + 512 <= data.length;) {
     const header = data.subarray(offset, offset + 512);
     if (header.every((byte) => byte === 0)) { offset += 512; continue; }
@@ -87,19 +89,25 @@ export const readTar = (path) => {
       for (const record of body.toString("utf8").split("\n")) {
         const match = /^\d+ path=(.*)$/.exec(record);
         if (match) longName = match[1];
+        const link = /^\d+ linkpath=(.*)$/.exec(record);
+        if (link) longLink = link[1];
       }
       continue;
     }
     if (type === "L") { longName = body.toString("utf8").replace(/\0.*$/s, ""); continue; }
+    if (type === "K") { longLink = body.toString("utf8").replace(/\0.*$/s, ""); continue; }
     if (type === "g") continue;
     const prefix = field(345, 155);
     const name = longName ?? (prefix ? `${prefix}/${field(0, 100)}` : field(0, 100));
     longName = null;
     if (type === "0" || type === "\0") files.set(name.replace(/^\.\//, ""), body);
+    if (type === "1" || type === "2") links.set(name.replace(/^\.\//, ""), { target: longLink ?? field(157, 100), hard: type === "1" });
+    longLink = null;
   }
   return {
     // Enumerate regular files without exposing the Map's mutation methods.
     entries() { return files.entries(); },
+    links() { return links.entries(); },
     get(name) {
       const bytes = files.get(name);
       if (!bytes) throw new Error(`${path}: no ${name}`);
@@ -132,7 +140,7 @@ export const fetchAlpine = (cfg = config()) => withUmask022(async () => {
   const release = `lib/modules/${cfg.kernelRelease}`;
   const dep = linux.get(`${release}/modules.dep`).toString();
   const builtin = linux.get(`${release}/modules.builtin`);
-  const { selected, notes } = select({ dep, builtin: builtin.toString(), packageName: cfg.linuxPackage, arch: cfg.arch, flavor: cfg.flavor, real: cfg.real });
+  const { selected, notes } = select({ dep, builtin: builtin.toString(), packageName: cfg.linuxPackage, arch: cfg.arch, flavor: cfg.flavor, real: cfg.real, noGpu: cfg.noGpu });
   for (const note of notes) console.error(note);
   rmSync(cfg.modulesRoot, { recursive: true, force: true });
   writeTo(join(cfg.modulesRoot, "modules.builtin"), builtin);
@@ -142,6 +150,8 @@ export const fetchAlpine = (cfg = config()) => withUmask022(async () => {
   writeTo(join(cfg.modulesRoot, "modules.dep"), trimDependencies(dep, selected));
   writeTo(join(cfg.modulesRoot, "modules.alias"), filterAliases(linux.get(`${release}/modules.alias`).toString(), selected));
 
+  await (await import("./fetch-gpu.js")).fetchGpuFirmware(cfg);
+
   chmodSync(join(cfg.nativeDir, "lib", cfg.muslLoader), 0o755);
   console.log(`Fetched Alpine ${cfg.arch} linux-${cfg.flavor} kernel, ${selected.length} modules, musl, and the ${cfg.efiStub} UKI stub.`);
 });

package/scripts/gpu-firmware.json

@@ -0,0 +1,22 @@
+[
+  {
+    "name": "linux-firmware-amdgpu-20260519-r0.apk",
+    "sha256": "70bc5c972a2da62b84b53e06b6d4c5aec0a8e9d6d280802755c3c8643f3bb8c6"
+  },
+  {
+    "name": "linux-firmware-i915-20260519-r0.apk",
+    "sha256": "3946f8b0a8f0dd187bd71d9aa9b3085a10cb1e8cf4700aa876799e6368309fa4"
+  },
+  {
+    "name": "linux-firmware-nvidia-20260519-r0.apk",
+    "sha256": "9fd3fa7eff65792ef8558c01a27246862e2701a99ef97dba5111b9f6db2c80ee"
+  },
+  {
+    "name": "linux-firmware-radeon-20260519-r0.apk",
+    "sha256": "3b0d6d3982563d17df0c33c2d695a5a547487cb56f2fd9a004ed729fac8f0684"
+  },
+  {
+    "name": "linux-firmware-xe-20260519-r0.apk",
+    "sha256": "6ebc37da64ecb48973c1814d1499c2c2f8f38593e8cf7227811d840c8b17172f"
+  }
+]

package/scripts/modules.js

@@ -16,11 +16,15 @@
 const required = (names) => names.map((name) => ({ name }));
 const optional = (names) => names.map((name) => ({ name, optional: true }));
 
-export const requests = ({ arch, flavor, real }) => [
+export const requests = ({ arch, flavor, real, noGpu = false }) => [
+  // Pack, but never coldplug at boot or through cfg.all. cfg.gpu matches hardware.
+  ...(!noGpu ? optional(["virtio-gpu", "vmwgfx"]) : []),
+  ...(!noGpu && arch === "x86_64" ? optional(["i915", "xe", "amdgpu", "radeon", "nouveau"]) : []),
   ...required([
     "failover",
     "net_failover",
     "virtio_net",
+    "af_packet", // DHCP before an interface has an IPv4 address
   ]),
   ...optional([
     "virtio_pci",

package/scripts/npm-packages.md

@@ -1,24 +1,24 @@
 # npm packages
 # Latest versions checked on 2026-10-11; SHA-256 pins verified against registry SHA-512 integrity.
-# buninu-browser updated and verified on 2026-10-12.
-# casty 1.3.7 and buninu-land 0.1.3 verified on 2026-10-16.
+# buninu-browser 0.3.0, buninu-land 0.2.0, casty 1.4.1, and jspulse 0.2.3 verified on 2026-10-22.
+# jspinyin 0.2.0 verified on 2026-10-22.
 
-"buninu-browser@0.2.3":
-  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.2.3.tgz
-  - sha256:0f7c9cd9df689d7b0900fdf3172851125ebd8aba12bed555be7e091d427146e8
+"buninu-browser@0.3.0":
+  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.3.0.tgz
+  - sha256:4590c523f76ce7c3a079894b80a541b788c95895036d0094c0e98c2acc6d5179
 
-"buninu-land@0.1.3":
-  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.1.3.tgz
-  - sha256:b2c94f7fa0f7275ed739f4949d0be3ef45a99bf0b61e63a71ea9d6459f9f1c2e
+"buninu-land@0.2.0":
+  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.2.0.tgz
+  - sha256:543098c9f934fe4d723ca65b5a0c8a0bd11a04268228c23c3272073dc4549b56
 
-"@drxiaozhi/casty@1.3.7":
-  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.3.7.tgz
-  - sha256:acc0641fb68c00222ba1cd2b7520ba99c269b996e145e82f18466be4d126b811
+"@drxiaozhi/casty@1.4.1":
+  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.4.1.tgz
+  - sha256:0179c699a82202dc3d84f8736c8d88b29941d87995d6c6b554fd534daa70d280
 
-"@drxiaozhi/jspulse@0.2.1":
-  - https://registry.npmjs.org/@drxiaozhi/jspulse/-/jspulse-0.2.1.tgz
-  - sha256:9a34a76b1edac6767fa90e33cbc4d3a511c082e9ab73fb196390f841aad37839
+"@drxiaozhi/jspulse@0.2.3":
+  - https://registry.npmjs.org/@drxiaozhi/jspulse/-/jspulse-0.2.3.tgz
+  - sha256:c4a1a7adb559f94096243bebaac0890dc5096d518f7f83ed489c38d5cdfaa263
 
-"@drxiaozhi/jspinyin@0.1.1":
-  - https://registry.npmjs.org/@drxiaozhi/jspinyin/-/jspinyin-0.1.1.tgz
-  - sha256:c6d10a40b6c93a942d85dff69ed2e45dacf506b15caab6821688e8e29df810ed
+"@drxiaozhi/jspinyin@0.2.0":
+  - https://registry.npmjs.org/@drxiaozhi/jspinyin/-/jspinyin-0.2.0.tgz
+  - sha256:b6dfb18f8a8602b9449b75823bce1790fd9682fac68fcbc57c55b4ebd98baa6e

package/test/bunterm-fps.test.js

@@ -0,0 +1,17 @@
+import {test,expect} from 'bun:test';
+import {createFpsMeter} from '../initramfs/lib/bunterm/fps.js';
+test('FPS counts new image presentations, ignores redraws, idles at zero and resets on toggle',()=>{
+ let time=0;const meter=createFpsMeter(()=>time),old={},a={},b={};
+ meter.presented([{image:old}]);expect(meter.enabled).toBe(false);
+ expect(meter.toggle([{image:old}])).toBe(true);
+ meter.presented([{image:old}]);
+ meter.presented([{image:a}]);meter.presented([{image:a}]);
+ meter.presented([{image:a},{image:b}]);meter.presented([]);
+ time=1000;expect(meter.sample()).toBe(2);
+ time=2000;expect(meter.sample()).toBe(0);
+ expect(meter.toggle()).toBe(false);
+ meter.presented([{image:{}}]);
+ time=3000;expect(meter.sample()).toBe(0);
+ meter.toggle([{image:b}]);meter.presented([{image:b}]);
+ meter.presented([{image:{}}]);time=3500;expect(meter.sample()).toBe(2);
+});

package/test/bunterm-keyboard.test.js

@@ -0,0 +1,116 @@
+import {test,expect} from "bun:test";
+import {Terminal} from "../initramfs/lib/xterm/xterm-headless.mjs";
+import {ConsoleKeys,MediumRawDecoder,legacyKey} from "../initramfs/lib/bunterm/keycodes.js";
+import {attachKeyboard} from "../initramfs/lib/bunterm/keyboard.js";
+const write = (term,text) => new Promise(resolve=>term.write(text,resolve));
+const letters = {16:"q",17:"w",18:"e",19:"r",20:"t",21:"y",22:"u",23:"i",24:"o",25:"p",
+  30:"a",31:"s",32:"d",33:"f",34:"g",35:"h",36:"j",37:"k",38:"l",44:"z",45:"x",46:"c",
+  47:"v",48:"b",49:"n",50:"m"};
+const keys = () => new ConsoleKeys({lookup:(table,n) => {
+  const letter = letters[n];
+  if (letter) return 0xb00 | (table & 1 ? letter.toUpperCase() : letter).charCodeAt(0);
+  return n === 57 ? 32 : n === 53 ? (table & 1 ? 63 : 47) : null;
+}});
+function fixture(extra = {}) {
+  const term = new Terminal({allowProposedApi:true}), output = [], modes = [], switches = [];
+  const keyboard = attachKeyboard({term,write:text=>output.push(text),
+    setEnhanced:v=>modes.push(v),switchVT:n=>switches.push(n),...extra});
+  return {term,output,modes,switches,keyboard,close(){keyboard.dispose();term.dispose();}};
+}
+test("mediumraw extended codes survive every possible read boundary", () => {
+  const bytes = Buffer.from([30,158,0,129,183,128,129,183]); // F13 = 183
+  for (let split=0;split<=bytes.length;split++) {
+    const decoder = new MediumRawDecoder(), events=[];
+    decoder.feed(bytes.subarray(0,split),(c,d)=>events.push([c,d]));
+    decoder.feed(bytes.subarray(split),(c,d)=>events.push([c,d]));
+    expect(events).toEqual([[30,true],[30,false],[183,true],[183,false]]);
+  }
+});
+test("all Ctrl/Alt/Shift/Super letter combinations stay distinct", async () => {
+  const f=fixture();
+  try {
+    await write(f.term,"\x1b[>9u");
+    for (let bits=0;bits<16;bits++) for (const [number,letter] of Object.entries(letters)) {
+      const state=keys();
+      for (const [mask,code] of [[1,42],[2,56],[4,29],[8,125]]) if(bits&mask) f.keyboard.event(state.event(code,true));
+      f.output.length=0;
+      f.keyboard.event(state.event(Number(number),true));
+      expect(f.output).toEqual([`\x1b[${letter.charCodeAt(0)}${bits?";"+(bits+1):""}u`]);
+      f.keyboard.blur();
+    }
+  } finally {f.close();}
+});
+test("push/pop, repeat/release, recovery keys, independent buffers and reset", async () => {
+  const f=fixture(), state=keys();
+  try {
+    await write(f.term,"\x1b[?u\x1b[>11u");
+    expect(f.output).toEqual(["\x1b[?0u"]);
+    f.output.length=0;
+    f.keyboard.event(state.event(125,true));
+    f.keyboard.event(state.event(50,true));
+    f.keyboard.event(state.event(50,true));
+    f.keyboard.event(state.event(50,false));
+    f.keyboard.event(state.event(125,false));
+    expect(f.output).toEqual(["\x1b[57444;9u","\x1b[109;9u","\x1b[109;9:2u","\x1b[109;9:3u","\x1b[57444;1:3u"]);
+    await write(f.term,"\x1b[>1u");
+    f.output.length=0;
+    f.keyboard.event(state.event(28,true));
+    f.keyboard.event(state.event(28,false));
+    f.keyboard.event(state.event(30,true));
+    expect(f.output).toEqual(["\r","a"]);
+    await write(f.term,"\x1b[<u");
+    expect(f.keyboard.flags).toBe(11);
+    await write(f.term,"\x1b[?1049h");
+    expect(f.keyboard.flags).toBe(0);
+    await write(f.term,"\x1b[?1049l");
+    expect(f.keyboard.flags).toBe(11);
+    await write(f.term,"\x1bc");
+    expect(f.keyboard.flags).toBe(0);
+    expect(f.modes).toEqual([true,false,true,false]);
+  } finally {f.close();}
+});
+test("local menu and reserved VT keys never reach the child", async () => {
+  let menu=false;
+  const f=fixture({localInput:()=>menu}), state=keys();
+  try {
+    await write(f.term,"\x1b[>11u");
+    f.keyboard.event(state.event(29,true));
+    f.keyboard.event(state.event(56,true));
+    f.output.length=0;
+    f.keyboard.event(state.event(60,true));
+    f.keyboard.event(state.event(60,false));
+    expect(f.switches).toEqual([2]);
+    expect(f.output).toEqual([]);
+    f.keyboard.blur(); f.output.length=0;
+    menu=true;
+    f.keyboard.event(state.event(30,true));
+    f.keyboard.event(state.event(30,false));
+    expect(f.output).toEqual([]);
+  } finally {f.close();}
+});
+test("layout translation, caps, AltGr, keypad and Unicode map", () => {
+  const state=keys();
+  state.event(58,true); state.event(58,false);
+  expect(state.event(30,true).key).toBe("A");
+  state.event(42,true);
+  expect(state.event(30,true).key).toBe("a");
+  expect(state.event(100,true).key).toBe("AltGraph");
+  expect(state.event(53,true).getModifierState("AltGraph")).toBe(true);
+  const unicode=new ConsoleKeys({lookup:()=>0xf000^0x4e2d});
+  expect(unicode.event(30,true).key).toBe("中");
+  const num=keys();
+  num.event(69,true);
+  expect(num.event(79,true).key).toBe("1");
+  expect(num.event(79,false).location).toBe(3);
+  expect(legacyKey({type:"keydown",key:"/",ctrlKey:true})).toBe("\x1f");
+});
+test("failed console transition resets flags and does not strand the protocol", async () => {
+  const errors=[];
+  const f=fixture({setEnhanced(){throw new Error("not a VT");},onError:e=>errors.push(e.message)});
+  try {
+    await write(f.term,"\x1b[>11u\x1b[?u");
+    expect(f.keyboard.flags).toBe(0);
+    expect(f.output).toEqual(["\x1b[?0u"]);
+    expect(errors).toEqual(["not a VT"]);
+  } finally {f.close();}
+});

package/test/bunterm-next-vt.test.js

@@ -0,0 +1,9 @@
+import {expect,test} from 'bun:test';
+import {nextVirtualTerminal} from '../initramfs/lib/bunterm/vt.js';
+test('new bunterm appends after known sessions and reserves the initial console',()=>{
+ expect(nextVirtualTerminal([])).toBe(2);
+ expect(nextVirtualTerminal([{number:1}])).toBe(2);
+ expect(nextVirtualTerminal([{number:1},{number:2},{number:6}])).toBe(7);
+ expect(nextVirtualTerminal([{number:4}])).toBe(5);
+ expect(()=>nextVirtualTerminal([{number:63}])).toThrow('No next tty');
+});

package/test/bunterm-raw-protocol.test.js

@@ -0,0 +1,19 @@
+import {test,expect} from 'bun:test';
+import {createRequire} from 'node:module';
+import {preferredPixelFormat,bgraParser,BGRA_FORMAT} from '../initramfs/lib/bunterm/raw-protocol.js';
+const {KittyGraphicsParser}=createRequire(import.meta.url)('../initramfs/buninu/apps/jsgotty/gotty.js');
+const field=offset=>({offset,length:8,msbRight:0});
+const fb=(red=16,blue=0)=>({bitsPerPixel:32,fields:{red:field(red),green:field(8),blue:field(blue),transp:{length:0}}});
+test('native preference follows framebuffer bitfields; browser parser remains unchanged',()=>{
+ for(const [display,preferred] of [[fb(),'bgra'],[fb(0,16),'rgba'],[{bitsPerPixel:16},'png'],[undefined,'png']]){
+  expect(preferredPixelFormat(display)).toBe(preferred);
+  const p=new (bgraParser(KittyGraphicsParser,display))({binaryData:true});
+  const packet=Buffer.from(`a=q,f=${BGRA_FORMAT},s=1,v=1,i=41;AAAA/w==`);
+  expect(p.parsePacket(packet,{}).responseMessage).toBe('OK Buninu1 '+preferred);
+  expect(new KittyGraphicsParser().parsePacket(packet,{}).responseMessage).toBe('OK');
+  expect(p.images.size).toBe(0);
+  expect(p.parsePacket(Buffer.from(`a=q,f=${BGRA_FORMAT},s=2,v=1,i=41;AAAA/w==`),{}).responseMessage).toStartWith('ERROR:');
+ }
+ const bad=fb();bad.fields.red.msbRight=1;
+ expect(preferredPixelFormat(bad)).toBe('png');expect(preferredPixelFormat(fb(),false)).toBe('png');
+});

package/test/bunterm-renderer.test.js

@@ -0,0 +1,158 @@
+import {test,expect} from "bun:test";
+import {loadCanvasKit,loadFontSet} from "../initramfs/lib/canvas.js";
+import {Renderer} from "../initramfs/lib/bunterm/renderer.js";
+import {Terminal} from "../initramfs/lib/xterm/xterm-headless.mjs";
+import {createVtMenu} from "../initramfs/lib/bunterm/vt-menu.js";
+
+test("real CanvasKit redraws resized text and overlay with fresh font metrics", async () => {
+  const CanvasKit=await loadCanvasKit(), fonts=loadFontSet(CanvasKit,"terminal");
+  const surface=CanvasKit.MakeSurface(800,480);
+  const screen={width:800,height:480,canvas:surface.getCanvas(),flush:()=>surface.flush()};
+  const renderer=new Renderer({CanvasKit,screen,fonts});
+  const term=new Terminal({cols:renderer.columns,rows:renderer.rows,allowProposedApi:true});
+  try {
+    await new Promise(resolve=>term.write("Hello 中文 👨‍👩‍👧\r\nSelection and font resize",resolve));
+    const columns=renderer.columns;
+    renderer.render(term);
+    renderer.setFontSize(20);
+    expect(renderer.columns).toBeLessThan(columns);
+    term.resize(renderer.columns,renderer.rows);
+    const menu=createVtMenu({list:()=>[{number:1,label:"tty1 — initial console"}],select(){},changed(){renderer.invalidate();},
+      width:800,height:480,rowHeight:renderer.cellHeight,
+      controls:{fontSize:()=>renderer.fontSize,cellHeight:()=>renderer.cellHeight,execute:()=>""}});
+    menu.pointer({x:0,y:0,pressed:["left"],buttons:{left:true},wheel:0});
+    renderer.render(term,{overlay:()=>menu.draw(renderer)});
+    const image=surface.makeImageSnapshot();
+    expect(image.width()).toBe(800);
+    image.delete();
+    renderer.setFontSize(13);
+    expect(renderer.columns).toBe(columns);
+    expect(()=>renderer.setFontSize(NaN)).toThrow();
+  } finally {term.dispose();renderer.delete();fonts.delete();surface.delete();}
+},20000);
+
+test("local pointer restores exact pixels across images, edges, text and font changes", async () => {
+  const {openCanvas}=await import('../initramfs/lib/canvas.js');
+  const CK=await loadCanvasKit(), fonts=loadFontSet(CK,'terminal');
+  const make=()=>{
+    const display={width:320,height:200,stride:1296,bitsPerPixel:32,
+      fields:{red:{offset:16,length:8},green:{offset:8,length:8},blue:{offset:0,length:8}},pixels:new Uint8Array(1296*200)};
+    const screen=openCanvas(CK,display);screen.flush=()=>screen.surface.flush();
+    return screen;
+  };
+  const screen=make(),reference=make();
+  reference.drawOpaqueImage = undefined;
+  const r=new Renderer({CanvasKit:CK,screen,fonts}), ref=new Renderer({CanvasKit:CK,screen:reference,fonts});
+  const term=new Terminal({cols:r.columns,rows:r.rows,allowProposedApi:true});
+  const imageSurface=CK.MakeSurface(37,29);imageSurface.getCanvas().clear(CK.Color(30,90,170));
+  const image=imageSurface.makeImageSnapshot(), images=[{image,rect:[0,20,320,200]}];
+  let imageDraws=0;const draw=r.drawImages.bind(r);r.drawImages=(...args)=>{imageDraws++;return draw(...args);};
+  const check=(pointer,cursor={x:1,y:0,visible:true})=>{
+    const options={pointer,cursor,images};r.render(term,options);ref.invalidate();ref.render(term,options);
+    expect(screen.saveRegion(0,0,320,200).pixels).toEqual(reference.saveRegion(0,0,320,200).pixels);
+  };
+  try {
+    await new Promise(resolve=>term.write('Hello world',resolve));
+    check({x:100,y:100});const initial=imageDraws;
+    for(const point of [{x:101,y:101},{x:0,y:0},{x:319,y:199},{x:150.5,y:78.5},null])check(point);
+    expect(imageDraws).toBe(initial);
+    check({x:20,y:20});
+    await new Promise(resolve=>term.write('\rChanged',resolve));check({x:20,y:20});
+    check({x:50,y:50},{x:2,y:0,visible:false});
+    r.setFontSize(24);ref.setFontSize(24);term.resize(r.columns,r.rows);check({x:318,y:198});
+    check(null);
+  } finally {term.dispose();r.delete();ref.delete();image.delete();imageSurface.delete();screen.close();reference.close();fonts.delete();}
+},20000);
+
+test('opaque copies match Skia for clipped crops and dirty bands; transparency and scaling fall back', async()=>{
+ const {openCanvas}=await import('../initramfs/lib/canvas.js');
+ const CK=await loadCanvasKit();
+ const make=()=>openCanvas(CK,{width:64,height:48,stride:272,bitsPerPixel:32,
+ fields:{red:{offset:16,length:8},green:{offset:8,length:8},blue:{offset:0,length:8}},pixels:new Uint8Array(272*48)});
+ const a=make(),b=make();
+ const data=new Uint8Array(32*24*4);for(let i=0;i<data.length;i+=4){data[i]=i%251;data[i+1]=(i*7)%253;data[i+2]=(i*13)%255;data[i+3]=255;}
+ const info={width:32,height:24,colorType:CK.ColorType.RGBA_8888,alphaType:CK.AlphaType.Unpremul,colorSpace:CK.ColorSpace.SRGB};
+ const image=CK.MakeImage(info,data,128);
+ const bands=[[0,9],[12,35]];
+ try {
+  for(const rect of [[5,4,37,28],[-5,-3,27,21],[55,39,87,63]]){
+   a.canvas.clear(CK.Color(7,11,13));b.canvas.clear(CK.Color(7,11,13));
+   expect(a.drawOpaqueImage(image,rect,[0,0,32,24],bands)).toBe(true);
+   for(const [y0,y1] of bands){b.canvas.save();b.canvas.clipRect(CK.LTRBRect(0,y0,64,y1),CK.ClipOp.Intersect,false);b.canvas.drawImageRectOptions(image,CK.LTRBRect(0,0,32,24),CK.LTRBRect(...rect),CK.FilterMode.Linear,CK.MipmapMode.Linear,null);b.canvas.restore();}
+   expect(a.saveRegion(0,0,64,48).pixels).toEqual(b.saveRegion(0,0,64,48).pixels);
+  }
+  expect(a.drawOpaqueImage(image,[0,0,64,48],[0,0,32,24],bands)).toBe(false);
+  expect(a.drawOpaqueImage(image,[0.5,0,32.5,24],[0,0,32,24],bands)).toBe(false);
+  data[3]=100;const alpha=CK.MakeImage(info,data,128);
+  try{expect(a.drawOpaqueImage(alpha,[0,0,32,24],[0,0,32,24],bands)).toBe(false);}finally{alpha.delete();}
+ }finally{image.delete();a.close();b.close();}
+},20000);
+
+test('opaque image readback reuses WASM destination and falls back when native BGRA is rejected',async()=>{
+ const {openCanvas}=await import('../initramfs/lib/canvas.js');const CK=await loadCanvasKit();
+ const screen=openCanvas(CK,{width:8,height:8,stride:32,bitsPerPixel:32,
+ fields:{red:{offset:16,length:8},green:{offset:8,length:8},blue:{offset:0,length:8}},pixels:new Uint8Array(256)});
+ const info={width:8,height:8,colorType:CK.ColorType.RGBA_8888,alphaType:CK.AlphaType.Unpremul,colorSpace:CK.ColorSpace.SRGB};
+ const bytes=new Uint8Array(256);for(let i=0;i<256;i+=4)bytes.set([201,71,19,255],i);
+ const images=[],destinations=[];
+ try{
+  for(const fallback of [false,true]){
+   const image=CK.MakeImage(info,bytes,32);images.push(image);
+   const read=image.readPixels.bind(image);let reads=0;
+   image.readPixels=(x,y,format,destination,stride)=>{reads++;expect(destination).toBeTruthy();destinations.push(destination);
+    if(fallback && format.colorType===CK.ColorType.BGRA_8888)return null;
+    return read(x,y,format,destination,stride);};
+   for(let n=0;n<2;n++)expect(screen.drawOpaqueImage(image,[0,0,8,8],[0,0,8,8],[[0,8]])).toBe(true);
+   expect(reads).toBe(fallback?2:1);
+   const actual=screen.saveRegion(0,0,8,8).pixels;
+   for(let i=0;i<256;i+=4)expect([...actual.subarray(i,i+4)]).toEqual([19,71,201,255]);
+  }
+  expect(destinations.every(d=>d===destinations[0])).toBe(true);
+ }finally{images.forEach(i=>i.delete());screen.close();}
+},20000);
+
+test('raw images bypass Skia allocation/readback; covered text, removal, crops and fallback match full repaint', async()=>{
+ const {openCanvas}=await import('../initramfs/lib/canvas.js');
+ const {decodeImage}=await import('../initramfs/lib/bunterm/images.js');
+ const {skiaImage,rawImageData}=await import('../initramfs/lib/raw-image.js');
+ const CK=await loadCanvasKit(),fonts=loadFontSet(CK,'terminal');
+ const make=()=>{const s=openCanvas(CK,{width:320,height:200,stride:1296,bitsPerPixel:32,
+  fields:{red:{offset:16,length:8},green:{offset:8,length:8},blue:{offset:0,length:8}},pixels:new Uint8Array(1296*200)});s.flush=()=>s.surface.flush();return s;};
+ const screen=make(),reference=make();reference.drawOpaqueImage=undefined;reference.canDrawRawImage=undefined;
+ const r=new Renderer({CanvasKit:CK,screen,fonts}),ref=new Renderer({CanvasKit:CK,screen:reference,fonts});
+ const term=new Terminal({cols:r.columns,rows:r.rows,allowProposedApi:true});
+ const handles=[];let allocations=0,draws=0;
+ const makeImage=CK.MakeImage.bind(CK),drawRow=r.drawRow.bind(r);
+ const proxy=Object.create(CK);proxy.MakeImage=(...args)=>{allocations++;return makeImage(...args);};
+ r.drawRow=(...args)=>{draws++;return drawRow(...args);};
+ const create=async(format=0x42475241,alpha=255)=>{
+  const bytes=new Uint8Array(320*200*4);
+  for(let i=0;i<bytes.length;i+=4)bytes.set([i%251,83,211,alpha],i);
+  const handle=await decodeImage(proxy,{format,width:320,height:200,data:bytes},{deferRaw:true});handles.push(handle);
+  return handle;
+ };
+ const check=(image,rect=[0,0,320,200],source=[0,0,320,200],pointer=null,invalidate=true)=>{
+  const images=image?[{image,rect,source}]:[];
+  if(invalidate)r.invalidate();r.render(term,{images,pointer,cursor:{x:1,y:1,visible:true}});
+  const before=allocations;
+  ref.invalidate();ref.render(term,{images:images.map(p=>({...p,image:skiaImage(p.image)})),pointer,cursor:{x:1,y:1,visible:true}});
+  expect(screen.saveRegion(0,0,320,200).pixels).toEqual(reference.saveRegion(0,0,320,200).pixels);
+  return before;
+ };
+ try{
+  await new Promise(resolve=>term.write('Hello 中文\r\nHidden text',resolve));
+  const raw=await create();
+  expect(allocations).toBe(0);expect(check(raw)).toBe(0);expect(draws).toBe(0);
+  // Editing covered text must be visible once the image disappears.
+  await new Promise(resolve=>term.write('\rChanged underlying text',resolve));
+  check(raw,[0,0,320,200],[0,0,320,200],{x:100,y:100});
+  check(null,undefined,undefined,null,false);expect(draws).toBeGreaterThan(0);
+  check(raw,[-5,11,310,171],[5,20,320,180]);
+  check(raw,[0,0,160,100]); // scaling materializes lazily
+  check(await create(32)); // channel mismatch falls back
+  check(await create(0x42475241,100)); // transparency must paint underlying text
+  check(raw,[0.5,0,320.5,200]);
+  r.setFontSize(20);ref.setFontSize(20);term.resize(r.columns,r.rows);check(raw);check(null);
+  raw.delete();expect(rawImageData(raw)).toBeUndefined();raw.delete();
+ }finally{handles.forEach(i=>i.delete());term.dispose();r.delete();ref.delete();screen.close();reference.close();fonts.delete();}
+},20000);

package/test/bunterm-selection.test.js

@@ -0,0 +1,38 @@
+import {test,expect} from "bun:test";
+import {Terminal} from "../initramfs/lib/xterm/xterm-headless.mjs";
+import {createSelection} from "../initramfs/lib/bunterm/selection.js";
+import {pasteText} from "../initramfs/lib/bunterm/clipboard.js";
+const write = (term,text) => new Promise(resolve=>term.write(text,resolve));
+const point = (x,y,pressed=[],released=[]) => ({x,y,pressed,released,moved:true});
+test("selection joins wraps, includes wide graphemes and works backwards", async () => {
+  const term=new Terminal({cols:8,rows:4,allowProposedApi:true});
+  try {
+    await write(term,"ab中文efghij\r\nlast");
+    const s=createSelection(term,{offsetX:0,offsetY:0,cellWidth:1,cellHeight:1},()=>{});
+    s.pointer(point(3,0,["left"]));
+    s.pointer(point(1,1,[],["left"]));
+    expect(s.text()).toBe("中文efgh");
+    s.pointer(point(1,1,["left"]));
+    s.pointer(point(3,0,[],["left"]));
+    expect(s.text()).toBe("中文efgh");
+    s.pointer(point(0,1,["left"]));
+    s.pointer(point(3,2,[],["left"]));
+    expect(s.text()).toBe("ghij\nlast");
+    await write(term,"\x1b[?1000h");
+    expect(s.pointer(point(0,0,["left"]))).toBe(false);
+    expect(s.active).toBe(false);
+  } finally {term.dispose();}
+});
+test("paste uses one negotiated bracketed write, strips embedded ESC, normalizes LF", async () => {
+  const term=new Terminal({allowProposedApi:true}),out=[];
+  try {
+    pasteText(term,"a\nb\r\nc",s=>out.push(s));
+    expect(out.pop()).toBe("a\rb\rc");
+    await write(term,"\x1b[?2004h");
+    pasteText(term,"a\n\x1b[201~b",s=>out.push(s));
+    expect(out.pop()).toBe("\x1b[200~a\r[201~b\x1b[201~");
+    await write(term,"\x1b[?2004l");
+    pasteText(term,"text",s=>out.push(s));
+    expect(out).toEqual(["text"]);
+  } finally {term.dispose();}
+});