buninu-linux 0.14.57 → 0.16.59

package/test/bunterm-renderer.test.js

@@ -0,0 +1,167 @@
+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);
+  // Casty leaves one column free. Hidden glyphs may be skipped, but the
+  // visible edge, wide/italic glyphs and exposed text must match full repaint.
+  await new Promise(resolve=>term.write('\x1b[H\x1b[3m'+('abc中W '.repeat(60))+'\x1b[0m',resolve));
+  let cells=0;const drawCell=r.drawCell.bind(r);r.drawCell=(...args)=>{cells++;return drawCell(...args);};
+  const width=(r.columns-1)*r.cellWidth,height=(r.rows-1)*r.cellHeight;
+  check(raw,[r.offsetX,r.offsetY,r.offsetX+width,r.offsetY+height],[0,0,width,height]);
+  expect(cells).toBeLessThan(r.columns*r.rows);
+  check(raw,[r.offsetX+r.cellWidth,r.offsetY,r.offsetX+width,r.offsetY+height],[0,0,width-r.cellWidth,height]);
+  check(null,undefined,undefined,null,false);
+  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();}
+});

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

@@ -0,0 +1,178 @@
+import { test, expect } from "bun:test";
+import { createVtMenu } from "../initramfs/lib/bunterm/vt-menu.js";
+import { createCommands } from "../initramfs/lib/bunterm/commands.js";
+const report = (x, y, pressed = [], released = []) => ({ x, y, pressed, released, buttons: {left: pressed.includes("left")}, wheel: 0, moved: false });
+function fixture(extra = {}) {
+  const selected = [];
+  const menu = createVtMenu({ width: 800, height: 600, rowHeight: 16,
+    list: () => [{number:1,label:"initial"}, {number:3,label:"bunterm"}],
+    select: n => selected.push(n), changed() {}, ...extra });
+  return {menu, selected};
+}
+test("new bunterm is below the tty list, inherits live font size, and prevents double launch", async () => {
+  let size=13, finish; const calls=[];
+  const {menu,selected}=fixture({controls:{fontSize:()=>size,execute:()=>""},
+    create:n=>{calls.push(n);return new Promise(resolve=>{finish=resolve;});}});
+  menu.pointer(report(0,0,["left"]));
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:text=>labels.push(text),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels.indexOf("+ 新增 bunterm / New bunterm")).toBe(labels.indexOf("bunterm",2)+1);
+  size=20;
+  menu.input(Buffer.from("\x1b[B".repeat(5)+"\r\r"));
+  await Bun.sleep(0);
+  expect(calls).toEqual([20]);expect(selected).toEqual([]);
+  finish();await Bun.sleep(0);expect(menu.visible).toBe(false);
+});
+
+test("failed new bunterm launch keeps the menu usable", async () => {
+  const {menu}=fixture({controls:{fontSize:()=>13,execute:()=>""},create:()=>{throw Error("No next tty available");}});
+  menu.pointer(report(0,0,["left"]));
+  menu.input(Buffer.from("\x1b[B".repeat(5)+"\r"));
+  await Bun.sleep(0);expect(menu.visible).toBe(true);
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:text=>labels.push(text),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels).toContain("No next tty available");
+  menu.input(Buffer.from("\x1b"));expect(menu.visible).toBe(false);
+});
+test("only the top-left four pixels open the menu; open and selection clicks never leak", () => {
+  const {menu,selected} = fixture();
+  expect(menu.pointer(report(2,1,["left"]))).toBe(false);
+  expect(menu.pointer(report(1,2,["left"]))).toBe(false);
+  expect(menu.pointer(report(1,1,["right"]))).toBe(false);
+  expect(menu.pointer(report(1,1,["left"]))).toBe(true);
+  expect(menu.visible).toBe(true);
+  expect(menu.pointer(report(1,1,[],["left"]))).toBe(true);
+  expect(menu.pointer(report(20,55,["left"]))).toBe(true);
+  expect(selected).toEqual([3]);
+  expect(menu.visible).toBe(false);
+  expect(menu.pointer(report(20,55,[],["left"]))).toBe(true);
+  expect(menu.pointer(report(30,60))).toBe(false);
+});
+test("menu consumes application input, supports keyboard selection and dismissal", () => {
+  const {menu,selected} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  expect(menu.input(Buffer.from("shell command"))).toBe(true);
+  menu.input(Buffer.from("\x1b[B"));
+  menu.input(Buffer.from("\r"));
+  expect(selected).toEqual([3]);
+  menu.pointer(report(0,0,[],["left"]));
+  menu.pointer(report(0,0,["left"]));
+  menu.input(Buffer.from("\x1b"));
+  expect(menu.visible).toBe(false);
+  expect(menu.input(Buffer.from("x"))).toBe(false);
+});
+test("short screens scroll selection; renderer overlays are clipped", () => {
+  const {menu,selected} = fixture({height:72});
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer({...report(10,10), wheel:-1});
+  const text=[];
+  menu.draw({cellWidth:8, cellHeight:16, CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor: c=>c, drawText: t=>text.push(t),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(text).toContain("bunterm");
+  expect(text).not.toContain("initial");
+  menu.input(Buffer.from("\r"));
+  expect(selected).toEqual([3]);
+});
+test("outside click dismisses without selecting or leaking its release", () => {
+  const {menu,selected} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  expect(menu.pointer(report(700,300,["left"]))).toBe(true);
+  expect(menu.visible).toBe(false);
+  expect(menu.pointer(report(700,300,[],["left"]))).toBe(true);
+  expect(selected).toEqual([]);
+});
+
+test("Escape after releasing the opener does not eat the next application click", () => {
+  const {menu} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  menu.input(Buffer.from("\x1b"));
+  expect(menu.pointer(report(100,100,["left"]))).toBe(false);
+});
+
+test("font and clipboard buttons dispatch local commands; UTF-8 command editing survives split reads", async () => {
+  const calls=[];
+  const {menu}=fixture({controls:{fontSize:()=>13,execute:async line=>{calls.push(line);return "OK";}}});
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  for (const [x,y] of [[10,30],[400,30],[10,55],[300,55],[10,80]]) {
+    menu.pointer(report(x,y,["left"]));
+    menu.pointer(report(x,y,[],["left"]));
+  }
+  const bytes=Buffer.from("font 16中文");
+  menu.input(bytes.subarray(0,9)); menu.input(bytes.subarray(9));
+  menu.input(Buffer.from("\x7f\x7f\r")); // remove the two full code points
+  await new Promise(resolve=>setTimeout(resolve,0));
+  expect(calls).toEqual(["font -","font +","copy","paste","font 16"]);
+  expect(menu.visible).toBe(true);
+  menu.input(Buffer.from("\x1b"));
+});
+
+test("command registry validates font/VT arguments and is extensible", async () => {
+  let size=13; const calls=[];
+  const c=createCommands({fontSize:()=>size,setFontSize:n=>{if(!Number.isInteger(n)||n<6||n>96)throw Error("size");size=n;},
+    copy:()=>calls.push("copy"),paste:()=>calls.push("paste"),switchVT:n=>calls.push(n)});
+  expect(await c.execute("font +")).toBe("Font: 14");
+  await c.execute("font 18"); expect(size).toBe(18);
+  await expect(c.execute("font nope")).rejects.toThrow();
+  await expect(c.execute("vt 64")).rejects.toThrow();
+  await expect(c.execute("copy extra")).rejects.toThrow();
+  await expect(c.execute("unknown")).rejects.toThrow("try help");
+  await c.execute("copy"); await c.execute("paste"); await c.execute("vt 3");
+  expect(calls).toEqual(["copy","paste",3]);
+  c.commands.set("example", args=>args.join(" "));
+  expect(await c.execute("example hello world")).toBe("hello world");
+});
+
+test("menu labels current VT and renders a real left-aligned command field with centered font value", () => {
+  const {menu}=fixture({list:()=>[{number:1,label:"tty1 — initial console",current:true}],
+    controls:{fontSize:()=>13,execute:()=>""}});
+  menu.pointer(report(0,0,["left"]));
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:(text,x,y,cells,color,options)=>labels.push({text,align:options.align}),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels).toContainEqual({text:"tty1 — initial console (current)",align:"left"});
+  expect(labels).toContainEqual({text:"Click to type a command…",align:"left"});
+  expect(labels).toContainEqual({text:"🔤 字體 Font 13",align:"center"});
+  expect(labels).toContainEqual({text:"📋 複製 Copy",align:"left"});
+  expect(labels).toContainEqual({text:"📥 貼上 Paste",align:"left"});
+  expect(labels.some(x=>x.text===">")).toBe(false);
+});
+
+test("font buttons fit equally and preserve the right margin as fonts grow", () => {
+  const {menu}=fixture({controls:{fontSize:()=>20,execute:()=>""}});
+  menu.pointer(report(0,0,["left"]));
+  for(const cellWidth of [8,12,19,58]) {
+    const labels=[];
+    menu.draw({cellWidth,cellHeight:24,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+      paintFor:c=>c,drawText:(text,x,y,cells,color,options)=>labels.push({text,x,cells,align:options.align}),
+      canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+    const plus=labels.find(x=>x.text==="[+]"),minus=labels.find(x=>x.text==="[-]");
+    expect(plus.align).toBe("center");expect(minus.align).toBe("center");
+    expect(plus.cells).toBe(minus.cells);
+    expect(plus.x+plus.cells*cellWidth).toBe(412);
+    expect(minus.x).toBe(8);
+  }
+});
+
+test('header FPS control toggles without selecting a tty or leaking the click',()=>{
+ let enabled=false;
+ const {menu,selected}=fixture({controls:{fontSize:()=>13,execute:()=>'',fpsEnabled:()=>enabled,toggleFps:()=>{enabled=!enabled;}}});
+ menu.pointer(report(0,0,['left']));
+ menu.pointer(report(0,0,[],['left']));
+ expect(menu.pointer(report(380,12,['left']))).toBe(true);
+ expect(enabled).toBe(true);expect(menu.visible).toBe(true);expect(selected).toEqual([]);
+ menu.pointer(report(380,12,[],['left']));
+ const labels=[];
+ menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+  paintFor:c=>c,drawText:text=>labels.push(text),canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+ expect(labels).toContain('[FPS ✓]');
+ menu.pointer(report(380,12,['left']));expect(enabled).toBe(false);
+});

package/test/chroot-bind.test.js

@@ -39,8 +39,21 @@ async function invoke(argumentsFor,env={}) {
  const mock=join(dir,'libc.js');
  writeFileSync(mock,`import {appendFileSync} from 'node:fs';
  const record=(name,...args)=>appendFileSync(${JSON.stringify(log)},JSON.stringify([name,...args.map(a=>typeof a==='bigint'?String(a):a)])+'\\n');
- export const ptr=x=>x,cString=x=>x,errno=()=>1,strerror=()=> 'mock mount denied',Errno={EINVAL:22,EPERM:1};
- export const libc={symbols:{mount:(...a)=>{record('mount',...a);return a[0]?.endsWith('/fail')?-1:0;},umount2:(...a)=>{record('umount',...a);return 0;},chroot:(...a)=>{record('chroot',...a);return 0;}}};`);
+ let entered=false;
+ const bound=new Map();
+ const functions={mount:(...a)=>{record('mount',...a);return a[0]?.endsWith('/fail')?-1:0;},
+ umount2:(...a)=>{record('umount',...a);return process.env.MOCK_UNMOUNT_FAIL?-1:0;},
+ chroot:(...a)=>{record('chroot',...a);entered=true;return 0;},
+ strerror:()=> 'mock mount denied',errno:()=>process.env.MOCK_UNMOUNT_FAIL?5:1};
+ export const libc={symbols:new Proxy({}, {get(_target,name){
+   if(!bound.has(name)){
+     record('resolve',name);
+     if(entered||process.env.MOCK_MISSING_SYMBOL===name)throw Error('Cannot load libc symbol '+name);
+     bound.set(name,functions[name]);
+   }
+   return bound.get(name);
+ }})};
+ export const ptr=x=>x,cString=x=>x,errno=()=>libc.symbols.errno(),strerror=code=>libc.symbols.strerror(code),Errno={EINVAL:22,EPERM:1};`);
  const source=readFileSync(new URL('../initramfs/bin/chroot',import.meta.url),'utf8')
   .replace('"../lib/dlopen.js"',JSON.stringify(mock))
   .replace('"../lib/chroot-options.js"',JSON.stringify(new URL('../initramfs/lib/chroot-options.js',import.meta.url).pathname))
@@ -68,3 +81,28 @@ test('shared tmp replaces default tmpfs and bind failure cleans up even with -k'
  expect(failure.calls.some(c=>c[0]==='chroot')).toBe(false);
  expect(failure.calls.filter(c=>c[0]==='umount').map(c=>c[1])).toEqual([failure.root+'/first']);
 });
+
+test('cleanup symbols are resolved before mounting and remain usable after chroot',async()=>{
+ const r=await invoke(({host})=>['-n','-b',`${host}:/work`],{MOCK_UNMOUNT_FAIL:'1'});
+ expect(r.status).toBe(0);
+ expect(r.stderr).toContain('chroot: unmount /work: mock mount denied');
+ expect(r.stderr).not.toContain('Cannot load libc symbol');
+ const firstMount=r.calls.findIndex(c=>c[0]==='mount');
+ for(const name of ['umount2','strerror','errno']){
+   const index=r.calls.findIndex(c=>c[0]==='resolve'&&c[1]===name);
+   expect(index).toBeGreaterThanOrEqual(0);expect(index).toBeLessThan(firstMount);
+ }
+ expect(r.calls.filter(c=>c[0]==='umount').map(c=>c[2])).toEqual([0,2]);
+});
+
+test('missing cleanup symbol fails before any mount, including keep-mounts',async()=>{
+ const r=await invoke(({host})=>['-n','-k','-b',`${host}:/work`],{MOCK_MISSING_SYMBOL:'umount2'});
+ expect(r.status).toBe(125);expect(r.stderr).toContain('Cannot load libc symbol umount2');
+ expect(r.calls.some(c=>['mount','chroot','umount'].includes(c[0]))).toBe(false);
+});
+
+test('no-mount chroot without binds does not require umount2',async()=>{
+ const r=await invoke(()=>['-n'],{MOCK_MISSING_SYMBOL:'umount2'});
+ expect(r.status).toBe(0);
+ expect(r.calls.some(c=>c[0]==='resolve'&&c[1]==='umount2')).toBe(false);
+});

package/test/chvt.test.js

@@ -0,0 +1,46 @@
+import { test, expect } from "bun:test";
+import { parseChvt, switchVt } from "../initramfs/lib/chvt.js";
+
+test("chvt accepts VT numbers and help, rejects invalid input before opening devices", async () => {
+  expect(parseChvt(["2"])).toEqual({ number: 2 });
+  expect(parseChvt(["63"])).toEqual({ number: 63 });
+  for (const flag of ["-h", "--help"]) expect(parseChvt([flag]).help).toBe(true);
+  for (const args of [[], ["0"], ["64"], ["-1"], ["2x"], ["1", "2"]]) expect(() => parseChvt(args)).toThrow();
+  await expect(switchVt(0, {})).rejects.toThrow();
+});
+
+test("chvt skips PTY/non-VT consoles, activates only a validated VT and closes descriptors", async () => {
+  const events = [];
+  await switchVt(2, {
+    openConsole([path]) {
+      events.push(path);
+      if (path === "/dev/tty0") throw Error("missing");
+      return { path, close: () => events.push(`close ${path}`) };
+    },
+    activeConsole(device) { if (device.path === "/dev/tty") throw Error("not a VT"); },
+    activateConsole(device, number) { events.push(`activate ${device.path} ${number}`); },
+  });
+  expect(events).toEqual(["/dev/tty0", "/dev/tty", "close /dev/tty", "/dev/console", "activate /dev/console 2", "close /dev/console"]);
+});
+
+test("chvt closes console on failed switch without overriding VT owner or trying another switch", async () => {
+  let closed = 0, opened = 0;
+  await expect(switchVt(1, {
+    openConsole() { opened++; return { close() { closed++; } }; },
+    activeConsole() { return 2; },
+    activateConsole() { throw Error("switch denied"); },
+  })).rejects.toThrow("switch denied");
+  expect(opened).toBe(1);
+  expect(closed).toBe(1);
+});
+
+test("chvt CLI help and invalid arguments work without a Linux console", () => {
+  for (const flag of ["-h", "--help"]) {
+    const result = Bun.spawnSync([process.execPath, "initramfs/bin/chvt", flag]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toContain("bunterm");
+  }
+  const invalid = Bun.spawnSync([process.execPath, "initramfs/bin/chvt", "0"]);
+  expect(invalid.exitCode).toBe(1);
+  expect(invalid.stderr.toString()).toContain("usage:");
+});

package/test/fbdev-sync.test.js

@@ -0,0 +1,42 @@
+import { test, expect } from "bun:test";
+import { syncFramebuffer, flush } from "../initramfs/lib/fbdev.js";
+const display = () => ({ address: 0x10000, memoryLength: 4096, path: "/dev/fb0" });
+test("unsupported framebuffer msync is probed once per mapping", () => {
+  for (const code of [22, 95]) {
+    const fb = display(); let calls = 0;
+    const native = { msync(...args) { calls++; expect(args).toEqual([0x10000, 4096, 4]); return -1; }, errno: () => code };
+    syncFramebuffer(fb, native); syncFramebuffer(fb, native);
+    expect(calls).toBe(1);
+    expect(fb.msyncUnsupported).toBe(true);
+  }
+});
+test("supported sync continues every frame and retries EINTR", () => {
+  const fb = display(); let calls = 0;
+  const native = { msync() { return ++calls === 1 ? -1 : 0; }, errno: () => 4 };
+  syncFramebuffer(fb, native); syncFramebuffer(fb, native);
+  expect(calls).toBe(3);
+  expect(fb.msyncUnsupported).toBeUndefined();
+});
+test("real mapping and I/O failures remain visible", () => {
+  for (const code of [5, 12, 9]) {
+    const fb = display();
+    expect(() => syncFramebuffer(fb, {msync: () => -1, errno: () => code, strerror: () => `error ${code}`})).toThrow(`error ${code}`);
+    expect(fb.msyncUnsupported).toBeUndefined();
+  }
+});
+test("pixel writes continue on unsupported sync and respect framebuffer offsets and stride", () => {
+  const fb = {...display(), msyncUnsupported: true, width: 2, height: 2, bytesPerPixel: 1,
+    stride: 4, xOffset: 1, yOffset: 1, pixels: new Uint8Array([1,2,0,0,3,4,0,0]), memory: new Uint8Array(16)};
+  flush(fb);
+  expect([...fb.memory]).toEqual([0,0,0,0,0,1,2,0,0,3,4,0,0,0,0,0]);
+  fb.pixels[0] = 9; flush(fb); expect(fb.memory[5]).toBe(9);
+});
+test("contiguous framebuffer writes preserve surrounding virtual rows", () => {
+  const fb = {...display(), msyncUnsupported: true, width: 3, height: 2, bytesPerPixel: 4,
+    stride: 12, xOffset: 0, yOffset: 1, pixels: Uint8Array.from({length:24},(_,i)=>i+1), memory: new Uint8Array(48).fill(90)};
+  flush(fb);
+  expect([...fb.memory]).toEqual([...new Uint8Array(12).fill(90),...fb.pixels,...new Uint8Array(12).fill(90)]);
+  fb.yOffset=0;fb.pixels.fill(7);flush(fb);
+  expect(fb.memory.subarray(0,24)).toEqual(fb.pixels);
+  expect(fb.memory.subarray(36)).toEqual(new Uint8Array(12).fill(90));
+});

package/test/fetch-npm.test.js

@@ -23,8 +23,8 @@ const url = `http://127.0.0.1:${server.port}/archive`;
 
 test("five exact registry pins share an architecture-independent cache", () => {
   expect(npmPackages.map(({ name, version }) => `${name}@${version}`)).toEqual([
-    "buninu-browser@0.2.4", "buninu-land@0.1.4", "@drxiaozhi/casty@1.3.7",
-    "@drxiaozhi/jspulse@0.2.1", "@drxiaozhi/jspinyin@0.1.1",
+    "buninu-browser@0.6.0", "buninu-land@0.3.1", "@drxiaozhi/casty@1.5.1",
+    "@drxiaozhi/jspulse@0.2.3", "@drxiaozhi/jspinyin@0.2.0",
   ]);
   expect(basename(npmDownloadsDir)).toBe("npm");
   for (const pkg of npmPackages) {