buninu-linux 0.14.57 → 0.16.59

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

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import {ownMapping, retainMapping} from "../mapped-frame.js";
+// 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 {
+    constructor(...args) {
+      super(...args);
+      // The parser cache and renderer have independent lifetimes. Replacing a
+      // cache entry must not detach a frame still being drawn or handled.
+      this.images = new MappedImages(this.images);
+      this.mappingReads = [];
+      this.disposed = false;
+    }
+
+    dispose() {
+      if (this.disposed) return;
+      this.disposed = true;
+      this.images.clear();
+      this.transfers.clear();
+      this.pending = Buffer.alloc(0);
+      for (const release of this.mappingReads) release?.();
+      this.mappingReads = [];
+    }
+
+    _readImageFile(control,payloadText,deleteAfterRead) {
+      // Only complete raw temporary frames are immutable producer handoffs.
+      // Ordinary files, compressed/partial transfers keep the copying reader.
+      const format=Number(control.f);
+      if(!deleteAfterRead || ![32,BGRA_FORMAT].includes(format) || control.O || control.S || control.o || typeof Bun.mmap!=="function")
+        return super._readImageFile(control,payloadText,deleteAfterRead);
+      const path=fs.realpathSync(Buffer.from(payloadText,"base64").toString("utf8"));
+      const stat=fs.statSync(path),w=Number(control.s),h=Number(control.v);
+      if(!this._isSafeTempGraphicsPath(path)||!stat.isFile()||!Number.isInteger(w)||!Number.isInteger(h)||w<1||h<1||w*h>16777216||stat.size!==w*h*4)
+        return super._readImageFile(control,payloadText,deleteAfterRead);
+      let bytes;
+      try { bytes=Bun.mmap(path,{shared:false}); }
+      catch { return super._readImageFile(control,payloadText,deleteAfterRead); }
+      // Keep the mapping through parsing, even for queries/errors that do not
+      // enter the image cache. Never truncate/reuse producer files.
+      this.mappingReads.push(ownMapping(bytes));
+      try { fs.unlinkSync(path); } catch {}
+      return Buffer.from(bytes.buffer,bytes.byteOffset,bytes.byteLength);
+    }
+
+    _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) {
+      if (this.disposed) return null;
+      const previousReads = this.mappingReads;
+      this.mappingReads = [];
+      try {
+        const result=super._parsePacket(packet,cursor);
+        const release = retainMapping(result?.image?.data);
+        // The consumer uses `using` while awaiting image handling/ACKs. This
+        // protects the result even if the parser cache is replaced or closed.
+        if (release) result[Symbol.dispose] = release;
+        if(result?.kind==='query'&&Number(result.control.f)===BGRA_FORMAT&&result.responseMessage==='OK')
+          result.responseMessage='OK Buninu1 '+preferredPixelFormat(display);
+        return result;
+      } finally {
+        for (const release of this.mappingReads) release?.();
+        this.mappingReads = previousReads;
+      }
+    }
+  };
+}
+
+class MappedImages extends Map {
+  constructor(entries) {
+    super();
+    this.releases = new Map();
+    for (const [id, image] of entries) this.set(id, image);
+  }
+  set(id, image) {
+    const release = retainMapping(image?.data);
+    this.delete(id);
+    super.set(id, image);
+    if (release) this.releases.set(id, release);
+    return this;
+  }
+  delete(id) {
+    this.releases.get(id)?.();
+    this.releases.delete(id);
+    return super.delete(id);
+  }
+  clear() {
+    for (const release of this.releases.values()) release();
+    this.releases.clear();
+    super.clear();
+  }
+}

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();
   }
@@ -322,15 +348,24 @@ export class Renderer {
     }
   }
 
-  drawRow(line, row) {
-    const { canvas } = this;
-    canvas.drawRect(this.cellRect(0, row, this.columns, 1), this.paintFor(this.background));
-    if (!line) return;
-    for (let column = 0; column < this.columns; column++) {
-      const cell = line.getCell(column);
-      if (!cell) break;
-      this.drawCell(cell, column, row);
+  drawRow(line, row, hidden = []) {
+    const draw = (first, end) => {
+      if(end<=first)return;
+      this.canvas.drawRect(this.cellRect(first,row,end-first,1),this.paintFor(this.background));
+      if(!line)return;
+      for(let column=first;column<end;column++){
+        const cell=line.getCell(column);if(!cell)break;
+        this.drawCell(cell,column,row);
+      }
+    };
+    // Retain two boundary cells for wide glyphs and italic overhang. Interior
+    // pixels will be replaced by the opaque image; omit their background too.
+    let column=0;
+    for(const [first,end] of hidden.map(([a,b])=>[a+2,b-2]).sort((a,b)=>a[0]-b[0])){
+      draw(column,Math.min(this.columns,first));
+      column=Math.max(column,end);
     }
+    draw(column,this.columns);
   }
 
   drawCursor(line, x, y) {
@@ -395,25 +430,54 @@ 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-height
+    // rows, scaling, transparency and unsupported layouts remain unchanged.
+    const coveredRows = new Set(), coveredSpans = new Map();
+    const previousSpans = this.rawCoveredSpans ?? new Map();
+    const previouslyCovered = this.rawCoveredRows ?? new Set();
+    for (const {image, rect, source} of images) {
+      const bounds = source || [0, 0, image.width(), image.height()];
+      if (!this.screen.canDrawRawImage?.(image, rect, bounds)) continue;
+      const left=Math.max(0,Math.ceil((rect[0]-this.offsetX)/this.cellWidth));
+      const right=Math.min(this.columns,Math.floor((rect[2]-this.offsetX)/this.cellWidth));
+      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++) {
+        if(left===0 && right===this.columns)coveredRows.add(row);
+        else if(right-left>4){
+          const spans=coveredSpans.get(row)??[];spans.push([left,right]);coveredSpans.set(row,spans);
+        }
+      }
+    }
     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)
+          || (coveredSpans.get(row)?.length??0)!==(previousSpans.get(row)?.length??0)
+          || coveredSpans.get(row)?.some(([a,b],i)=>a!==previousSpans.get(row)?.[i]?.[0]||b!==previousSpans.get(row)?.[i]?.[1])) {
         dirty.push(row);
         this.rowHashes[row] = hash;
       }
     }
+    this.rawCoveredRows = coveredRows;
+    this.rawCoveredSpans = coveredSpans;
     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 +485,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, coveredSpans.get(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 +522,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));
+      }
+    },
+  };
+}