buninu-linux 0.14.57 → 0.15.58

package/initramfs/lib/bunterm/keyboard.js

@@ -0,0 +1,62 @@
+import { createRequire } from "node:module";
+import { legacyKey } from "./keycodes.js";
+const { KittyKeyboard } = createRequire(import.meta.url)("./kitty-keyboard.cjs");
+
+// The same protocol engine as jsgotty, with a console-mode notification.
+// Wait for the console to exist before installing handlers/advertising support.
+export function attachKeyboard({term, write, setEnhanced, localInput = () => false,
+  switchVT = () => {}, switchRelative = () => {}, onError = () => {}}) {
+  let keyboard, enhanced = false;
+  const sync = () => {
+    const next = Boolean(keyboard?.flags);
+    if (next === enhanced) return;
+    try {
+      setEnhanced(next);
+      enhanced = next;
+      keyboard.clearHeld(false);
+    } catch (error) {
+      keyboard.reset();
+      onError(error);
+    }
+  };
+  const wrap = name => (id, fn) => term.parser[name](id, params => {
+    const result = fn(params);
+    sync();
+    return result;
+  });
+  keyboard = new KittyKeyboard({
+    parser: {registerCsiHandler:wrap("registerCsiHandler"),registerEscHandler:wrap("registerEscHandler")},
+    buffer:term.buffer,options:term.options,
+    input: text => write(text),
+  });
+  const bufferChange = term.buffer.onBufferChange(sync);
+  const reserved = new Set();
+  return {
+    get flags() { return keyboard.flags; },
+    event(event) {
+      // Mediumraw disables the kernel's console shortcuts. Keep Ctrl-Alt-Fn
+      // available even when a client has requested all keys.
+      if (event.type === "keydown" && event.ctrlKey && event.altKey && /^F([1-9]|1[0-2])$/.test(event.key)) {
+        reserved.add(event.code);
+        if (!event.repeat) switchVT(Number(event.key.slice(1)));
+        return;
+      }
+      if (event.type === "keydown" && event.altKey && !event.ctrlKey && !event.shiftKey && !event.metaKey &&
+          ["ArrowLeft","ArrowRight"].includes(event.key)) {
+        reserved.add(event.code);
+        if (!event.repeat) switchRelative(event.key === "ArrowLeft" ? -1 : 1);
+        return;
+      }
+      if (event.type === "keyup" && reserved.delete(event.code)) return;
+      const text = legacyKey(event, Boolean(term._core?.coreService?.decPrivateModes?.applicationCursorKeys));
+      if (localInput(event, text)) { keyboard.clearHeld(); return; }
+      if (keyboard.handle(event) && text) write(text);
+    },
+    blur() { keyboard.clearHeld(); reserved.clear(); },
+    dispose() {
+      bufferChange.dispose();
+      keyboard.dispose();
+      if (enhanced) setEnhanced(false);
+    },
+  };
+}

package/initramfs/lib/bunterm/keycodes.js

@@ -0,0 +1,104 @@
+// Linux K_MEDIUMRAW -> browser-shaped key events for the shared Kitty encoder.
+// The kernel keymap supplies text; these names identify physical/function keys.
+const keys = {};
+const row = (start, names) => names.split(" ").forEach((name, i) => { keys[start + i] = name; });
+row(1, "Escape Digit1 Digit2 Digit3 Digit4 Digit5 Digit6 Digit7 Digit8 Digit9 Digit0 Minus Equal Backspace Tab");
+row(16, "KeyQ KeyW KeyE KeyR KeyT KeyY KeyU KeyI KeyO KeyP BracketLeft BracketRight Enter ControlLeft");
+row(30, "KeyA KeyS KeyD KeyF KeyG KeyH KeyJ KeyK KeyL Semicolon Quote Backquote ShiftLeft Backslash");
+row(44, "KeyZ KeyX KeyC KeyV KeyB KeyN KeyM Comma Period Slash ShiftRight NumpadMultiply AltLeft Space CapsLock");
+row(59, "F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 NumLock ScrollLock Numpad7 Numpad8 Numpad9 NumpadSubtract Numpad4 Numpad5 Numpad6 NumpadAdd Numpad1 Numpad2 Numpad3 Numpad0 NumpadDecimal");
+row(86, "IntlBackslash F11 F12");
+row(96, "NumpadEnter ControlRight NumpadDivide PrintScreen AltRight");
+row(102, "Home ArrowUp PageUp ArrowLeft ArrowRight End ArrowDown PageDown Insert Delete");
+Object.assign(keys, {113:"AudioVolumeMute",114:"AudioVolumeDown",115:"AudioVolumeUp",
+  117:"NumpadEqual",119:"Pause",121:"NumpadComma",125:"MetaLeft",126:"MetaRight",
+  127:"ContextMenu",163:"MediaTrackNext",164:"MediaPlayPause",165:"MediaTrackPrevious",
+  166:"MediaStop",167:"MediaRecord",168:"MediaRewind",208:"MediaFastForward"});
+row(183, "F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24");
+const special = {NumpadEnter:"Enter",NumpadDivide:"/",NumpadMultiply:"*",NumpadAdd:"+",
+  NumpadSubtract:"-",NumpadDecimal:".",NumpadEqual:"=",NumpadComma:","};
+const navigation = ["Insert","End","ArrowDown","PageDown","ArrowLeft","Clear","ArrowRight","Home","ArrowUp","PageUp"];
+
+// Mediumraw encodes >=128 as prefix (0 or 128), then two 7-bit groups
+// with bit 7 set. Preserve incomplete triples across read() boundaries.
+export class MediumRawDecoder {
+  pending = [];
+  feed(bytes, emit) {
+    for (const byte of bytes) {
+      this.pending.push(byte);
+      const first = this.pending[0];
+      if ((first & 127) !== 0) {
+        emit(first & 127, !(first & 128));
+        this.pending = [];
+      } else if (this.pending.length === 3) {
+        emit(((this.pending[1] & 127) << 7) | (this.pending[2] & 127), !(first & 128));
+        this.pending = [];
+      }
+    }
+  }
+}
+
+export class ConsoleKeys {
+  constructor({ lookup, leds = 0 } = {}) {
+    this.lookup = lookup;
+    this.held = new Set();
+    this.caps = Boolean(leds & 4);
+    this.num = Boolean(leds & 2);
+  }
+  event(number, down) {
+    const repeat = down && this.held.has(number);
+    if (down) this.held.add(number); else this.held.delete(number);
+    if (down && !repeat && number === 58) this.caps = !this.caps;
+    if (down && !repeat && number === 69) this.num = !this.num;
+    const shiftKey = this.held.has(42) || this.held.has(54);
+    const ctrlKey = this.held.has(29) || this.held.has(97);
+    const altKey = this.held.has(56);
+    const altgr = this.held.has(100);
+    const metaKey = this.held.has(125) || this.held.has(126);
+    const code = keys[number] || `LinuxKey${number}`;
+    let key = code.replace(/^(Shift|Control|Alt|Meta)(Left|Right)$/, "$1");
+    if (number === 100) key = "AltGraph";
+    else if (special[code]) key = special[code];
+    else if (/^Numpad\d$/.test(code)) key = this.num !== shiftKey ? code.slice(6) : navigation[Number(code.slice(6))];
+    else if (/^(Key|Digit|Intl)/.test(code) || ["Space","Minus","Equal","BracketLeft","BracketRight",
+      "Backslash","Semicolon","Quote","Backquote","Comma","Period","Slash"].includes(code)) {
+      // Exclude Ctrl/Alt from translation: the encoder needs the character,
+      // not an already-collapsed control byte or an ESC prefix.
+      const table = (shiftKey ? 1 : 0) | (altgr ? 2 : 0);
+      let symbol = this.lookup?.(table, number);
+      if ((symbol >> 8) === 11 && this.caps) symbol = this.lookup?.(table ^ 1, number);
+      const type = symbol >> 8;
+      key = symbol == null ? "Unidentified"
+        : type === 0 || type === 11 ? String.fromCodePoint(symbol & 255)
+        : type >= 16 ? String.fromCodePoint(symbol ^ 0xf000)
+        : type === 4 || type === 13 ? "Dead" : "Unidentified";
+    }
+    return {type:down?"keydown":"keyup",code,key,repeat,shiftKey,ctrlKey,altKey,metaKey,
+      location:/^Numpad/.test(code)?3:/Right$/.test(code)?2:/Left$/.test(code)?1:0,
+      getModifierState: name => name === "CapsLock" ? this.caps : name === "NumLock" ? this.num : name === "AltGraph" && altgr,
+      preventDefault() {}, stopPropagation() {}};
+  }
+}
+
+// Recovery/plain-text path when the negotiated enhancements leave a key in
+// legacy form. Used only in Kitty mode; normal console input stays unchanged.
+export function legacyKey(event, applicationCursorKeys = false) {
+  if (event.type !== "keydown") return "";
+  const { key, ctrlKey, altKey, shiftKey } = event;
+  let text = ({Enter:"\r",Tab:shiftKey?"\x1b[Z":"\t",Backspace:"\x7f",Escape:"\x1b"})[key];
+  const cursor = {ArrowUp:"A",ArrowDown:"B",ArrowRight:"C",ArrowLeft:"D",Home:"H",End:"F"}[key];
+  if (cursor) text = `\x1b${applicationCursorKeys?"O":"["}${cursor}`;
+  const tilde = {Insert:2,Delete:3,PageUp:5,PageDown:6}[key];
+  if (tilde) text = `\x1b[${tilde}~`;
+  if (text === undefined && [...key].length === 1) {
+    text = key;
+    if (ctrlKey) {
+      const n = key.toUpperCase().codePointAt(0);
+      if (n >= 64 && n <= 95) text = String.fromCharCode(n & 31);
+      else if (key === " " || key === "2") text = "\0";
+      else if (key === "/" || key === "?") text = "\x1f";
+      else if (key === "8") text = "\x7f";
+    }
+  }
+  return text === undefined ? "" : (altKey ? "\x1b" : "") + text;
+}

package/initramfs/lib/bunterm/kitty-keyboard.cjs

@@ -0,0 +1,195 @@
+// Vendored from jsgotty 1.2.0, static/js/kitty-keyboard.js (MIT).
+// Keep protocol behavior aligned with the browser terminal.
+// Kitty keyboard transport for the shipped xterm wrapper (no build step).
+// Spec: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+(function (root) {
+  'use strict';
+  // Supported progressive enhancements: disambiguation, event types, all keys.
+  // Do not advertise alternate-layout/text reporting until those are implemented.
+  const SUPPORTED = 1 | 2 | 8;
+  const functional = {
+    Escape:[27,'u'], Enter:[13,'u'], Tab:[9,'u'], Backspace:[127,'u'],
+    Insert:[2,'~'], Delete:[3,'~'], ArrowLeft:[1,'D'], ArrowRight:[1,'C'],
+    ArrowUp:[1,'A'], ArrowDown:[1,'B'], PageUp:[5,'~'], PageDown:[6,'~'],
+    Home:[1,'H'], End:[1,'F'], CapsLock:[57358,'u'], ScrollLock:[57359,'u'],
+    NumLock:[57360,'u'], PrintScreen:[57361,'u'], Pause:[57362,'u'], ContextMenu:[57363,'u'],
+    MediaPlay:[57428,'u'], MediaPause:[57429,'u'], MediaPlayPause:[57430,'u'],
+    MediaStop:[57432,'u'], MediaFastForward:[57433,'u'], MediaRewind:[57434,'u'],
+    MediaTrackNext:[57435,'u'], MediaTrackPrevious:[57436,'u'], MediaRecord:[57437,'u'],
+    AudioVolumeDown:[57438,'u'], AudioVolumeUp:[57439,'u'], AudioVolumeMute:[57440,'u'],
+  };
+  [11,12,13,14,15,17,18,19,20,21,23,24].forEach((n,i) => functional['F'+(i+1)] = [n,'~']);
+  for (let i=13;i<=35;i++) functional['F'+i] = [57376+i-13,'u'];
+  const punctuation = {
+    Backquote:['`','~'], Minus:['-','_'], Equal:['=','+'], BracketLeft:['[','{'],
+    BracketRight:[']','}'], Backslash:['\\','|'], Semicolon:[';',':'], Quote:["'",'"'],
+    Comma:[',','<'], Period:['.','>'], Slash:['/','?'], Space:[' ',' '],
+  };
+  const modifiers = {Shift:[1,57441], Control:[4,57442], Alt:[2,57443], Meta:[8,57444],
+    OS:[8,57444], Super:[8,57444], Hyper:[16,57445], AltGraph:[0,57453]};
+  const has = (object,key) => Object.prototype.hasOwnProperty.call(object,key);
+  const lock = (e,name) => Boolean(e.getModifierState?.(name));
+  function physicalCode(e) {
+    if (e.code && e.code !== 'Unidentified') return e.code;
+    if (e.keyCode>=65 && e.keyCode<=90) return 'Key'+String.fromCharCode(e.keyCode);
+    if (e.keyCode>=48 && e.keyCode<=57) return 'Digit'+String.fromCharCode(e.keyCode);
+    return ({32:'Space',186:'Semicolon',187:'Equal',188:'Comma',189:'Minus',190:'Period',
+      191:'Slash',192:'Backquote',219:'BracketLeft',220:'Backslash',221:'BracketRight',222:'Quote'})[e.keyCode] || '';
+  }
+  function baseCharacter(e, android) {
+    const code=physicalCode(e);
+    // Android's Alt accent conversion must not turn an E/I/N/U shortcut into a dead key.
+    const recover=android && e.altKey && !lock(e,'AltGraph');
+    if (recover || ([...e.key || ''].length===1 && e.key.codePointAt(0)<32)) {
+      if (/^Key[A-Z]$/.test(code)) return code.slice(3).toLowerCase();
+      if (/^Digit[0-9]$/.test(code)) return code.slice(5);
+      if (has(punctuation,code)) return punctuation[code][0];
+    }
+    if ([...e.key || ''].length!==1) return null;
+    if (e.shiftKey) {
+      if (has(punctuation,code) && punctuation[code][1]===e.key) return punctuation[code][0];
+      if (/^Digit[0-9]$/.test(code) && ')!@#$%^&*('[Number(code.slice(5))]===e.key) return code.slice(5);
+    }
+    const lower=e.key.toLowerCase();
+    return [...lower].length===1 ? lower : e.key;
+  }
+  function keyDefinition(e, flags, android) {
+    if (has(modifiers,e.key)) {
+      const [bit,left]=modifiers[e.key];
+      const right=e.location===2 || /Right$/.test(e.code || '');
+      return {number:left+(right && e.key!=='AltGraph'?6:0),suffix:'u',modifier:bit};
+    }
+    if ((flags & 9) && (e.location===3 || /^Numpad/.test(e.code || ''))) {
+      const numpad={NumpadDecimal:57409,NumpadDivide:57410,NumpadMultiply:57411,
+        NumpadSubtract:57412,NumpadAdd:57413,NumpadEnter:57414,NumpadEqual:57415,
+        NumpadComma:57416};
+      const nav={ArrowLeft:57417,ArrowRight:57418,ArrowUp:57419,ArrowDown:57420,
+        PageUp:57421,PageDown:57422,Home:57423,End:57424,Insert:57425,Delete:57426,Clear:57427};
+      const number=has(nav,e.key)?nav[e.key]:/^Numpad[0-9]$/.test(e.code || '')
+        ?57399+Number(e.code.slice(6)):numpad[e.code];
+      if (number) return {number,suffix:'u'};
+    }
+    if (has(functional,e.key)) {
+      const [number,suffix]=functional[e.key];
+      return {number,suffix,recovery:['Enter','Tab','Backspace'].includes(e.key)};
+    }
+    const ch=baseCharacter(e,android);
+    return ch===null?null:{number:ch.codePointAt(0),suffix:'u',text:true};
+  }
+  class KittyKeyboard {
+    constructor(term, {android=false}={}) {
+      this.term=term; this.android=android; this.disposables=[];
+      this.metaKeys=new Set(); this.down=new Map(); this.suppressed=new Set(); this.reset();
+      const register=(prefix,fn) => this.disposables.push(term.parser.registerCsiHandler({prefix,final:'u'},p=>{fn(p);return true;}));
+      const value=(p,i,fallback=0) => Number.isInteger(p[i])?p[i]:fallback;
+      register('?',()=>term.input(`\x1b[?${this.flags}u`,false));
+      register('>',p=>{const s=this.state;s.stack.push(s.flags);if(s.stack.length>32)s.stack.shift();s.flags=value(p,0)&SUPPORTED;});
+      register('<',p=>{const s=this.state;let count=Math.min(value(p,0)||1,33);while(count--)s.flags=s.stack.pop()??0;});
+      register('=',p=>{const s=this.state,f=value(p,0)&SUPPORTED,m=value(p,1)||1;if(m===1)s.flags=f;else if(m===2)s.flags|=f;else if(m===3)s.flags&=~f;});
+      this.disposables.push(term.parser.registerEscHandler({final:'c'},()=>{this.reset();return false;}));
+      this.disposables.push(term.parser.registerCsiHandler({intermediates:'!',final:'p'},()=>{this.reset();return false;}));
+    }
+    get state() { return this.states[this.term.buffer.active.type==='alternate'?'alternate':'normal']; }
+    get flags() { return this.state.flags; }
+    reset() {
+      this.states={normal:{flags:0,stack:[]},alternate:{flags:0,stack:[]}};
+      this.clearHeld(false);
+    }
+    clearHeld(report=true) {
+      // Release keys reported to the client before losing focus, avoiding stuck remote keys.
+      if (report && (this.flags & 2)) for (const key of this.down.values()) {
+        if(key.reported) this.term.input(this.sequence(key.def,0,3),true);
+      }
+      this.metaKeys.clear();this.down.clear();this.suppressed.clear();this.suppressKeypress=false;
+    }
+    attach(element) {
+      const doc=element.ownerDocument, win=doc.defaultView;
+      const blur=()=>this.clearHeld();
+      const visibility=()=>{if(doc.hidden)this.clearHeld();};
+      element.addEventListener('blur',blur);win.addEventListener('blur',blur);
+      doc.addEventListener('visibilitychange',visibility);
+      this.disposables.push({dispose:()=>{element.removeEventListener('blur',blur);win.removeEventListener('blur',blur);doc.removeEventListener('visibilitychange',visibility);}});
+    }
+    dispose() {this.clearHeld(false);for(const d of this.disposables)d.dispose();}
+    sequence(def,bits,type) {
+      const event=(this.flags&2) && type!==1?':'+type:'';
+      const mods=bits+1;
+      if(def.suffix!=='u' && mods===1 && !event)
+        return '\x1b['+(def.number===1?'':def.number)+def.suffix;
+      return `\x1b[${def.number}${mods!==1||event?';'+mods+event:''}${def.suffix}`;
+    }
+    handle(event) {
+      if (!['keydown','keyup','keypress'].includes(event.type)) return true;
+      const identity=physicalCode(event)||event.key;
+      const metaKey=['Meta','OS','Super'].includes(event.key);
+      if(this.android && metaKey) {
+        if(event.type==='keydown')this.metaKeys.add(event.code||String(event.location||0));
+        if(event.type==='keyup')this.metaKeys.delete(event.code||String(event.location||0));
+      }
+      // Patch only this terminal's Android event, preserving the native DOM event.
+      if(this.android && this.metaKeys.size && !event.metaKey) {
+        const original=event.getModifierState?.bind(event);
+        Object.defineProperties(event,{
+          metaKey:{configurable:true,value:true},
+          getModifierState:{configurable:true,value:name=>name==='Meta'||Boolean(original?.(name))},
+        });
+      }
+      if(!this.flags || this.term.options.disableStdin) return true;
+      const consume=()=>{event.preventDefault();event.stopPropagation();return false;};
+      if(event.type==='keypress')return this.suppressKeypress?consume():true;
+      let previous=this.down.get(identity);
+      if(event.type==='keyup') {
+        // Some Android IMEs emit only the release of an Alt dead key. Recover
+        // that chord here too, never falling back to legacy ESC text in Kitty mode.
+        if(!previous && this.android && event.altKey && event.key==='Dead' &&
+           !event.isComposing && !lock(event,'AltGraph') && (this.flags&9)) {
+          const def=keyDefinition(event,this.flags,this.android);
+          if(def) {
+            this.term.input(this.sequence(def,this.bits(event),1),true);
+            previous={def,reported:true};this.suppressed.add(identity);
+          }
+        }
+        this.down.delete(identity);
+        const suppressed=this.suppressed.delete(identity);
+        this.suppressKeypress=false;
+        if(previous?.reported && (this.flags&2)) {
+          let bits=this.bits(event);
+          if(previous.def.modifier && ![...this.down.values()].some(k=>k.def.modifier===previous.def.modifier)) bits &= ~previous.def.modifier;
+          if(metaKey && this.metaKeys.size) bits|=8;
+          this.term.input(this.sequence(previous.def,bits,3),true);
+        }
+        return suppressed?consume():true;
+      }
+      this.suppressKeypress=false;
+      if(event.isComposing || event.keyCode===229 && event.key==='Unidentified')return true;
+      if(event.key==='Dead' && !(this.android && event.altKey && !lock(event,'AltGraph')))return true;
+      const def=keyDefinition(event,this.flags,this.android);
+      if(!def)return true;
+      let bits=this.bits(event);
+      if(def.modifier!==undefined) {
+        if(!(this.flags&8))return true;
+        bits|=def.modifier;
+      }
+      const all=Boolean(this.flags&8);
+      // Enter/Tab/Backspace remain recovery keys unless modified or report-all is requested.
+      if(!all && def.recovery && !(bits&~192))return true;
+      const shortcut=Boolean(bits&62);
+      if(def.text && !all && !(this.flags&1 && shortcut))return true;
+      // With only event reporting requested, leave legacy printable shortcuts untouched.
+      if(def.text && !all && !(this.flags&1))return true;
+      const type=event.repeat?2:1;
+      this.down.set(identity,{def,reported:!(def.recovery && !all)});this.suppressed.add(identity);this.suppressKeypress=true;
+      this.term.input(this.sequence(def,bits,type),true);
+      return consume();
+    }
+    bits(e) {
+      const altgr=lock(e,'AltGraph');
+      return (e.shiftKey?1:0)|(!altgr&&e.altKey?2:0)|(!altgr&&e.ctrlKey?4:0)|
+        (e.metaKey || this.android&&this.metaKeys.size?8:0)|
+        (lock(e,'Hyper')?16:0)|(lock(e,'CapsLock')?64:0)|(lock(e,'NumLock')?128:0);
+    }
+  }
+  const api={KittyKeyboard,SUPPORTED};
+  if(typeof module==='object' && module.exports)module.exports=api;
+  else root.GoTTYKittyKeyboard=api;
+})(globalThis);

package/initramfs/lib/bunterm/raw-protocol.js

@@ -0,0 +1,33 @@
+// Buninu private extension; not a registered Kitty pixel format.
+export const BGRA_FORMAT = 0x42475241;
+export function preferredPixelFormat(display, littleEndian = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1) {
+  if (!littleEndian || display?.bitsPerPixel !== 32) return 'png';
+  const f=display.fields;
+  const channel=(field,offset)=>field?.offset===offset&&field.length===8&&!field.msbRight;
+  const alpha=f?.transp;
+  if(alpha?.length && !channel(alpha,24))return 'png';
+  if(!channel(f?.green,8))return 'png';
+  if(channel(f?.red,16)&&channel(f?.blue,0))return 'bgra';
+  if(channel(f?.red,0)&&channel(f?.blue,16))return 'rgba';
+  return 'png';
+}
+// Only the native renderer advertises these formats; browser jsgotty is unchanged.
+export function bgraParser(Base,display) {
+  return class extends Base {
+    _resolveImageData(control,payload) {
+      const bytes=super._resolveImageData(control,payload);
+      if(Number(control.f)===BGRA_FORMAT){
+        const w=Number(control.s),h=Number(control.v);
+        if(!Number.isInteger(w)||!Number.isInteger(h)||w<1||h<1||w*h>16777216||bytes.length!==w*h*4)
+          throw Error('Invalid BGRA dimensions or byte count');
+      }
+      return bytes;
+    }
+    _parsePacket(packet,cursor) {
+      const result=super._parsePacket(packet,cursor);
+      if(result?.kind==='query'&&Number(result.control.f)===BGRA_FORMAT&&result.responseMessage==='OK')
+        result.responseMessage='OK Buninu1 '+preferredPixelFormat(display);
+      return result;
+    }
+  };
+}

package/initramfs/lib/bunterm/renderer.js

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

package/initramfs/lib/bunterm/selection.js

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