buninu-linux 0.15.58 → 0.16.59

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

@@ -1,3 +1,5 @@
+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) {
@@ -14,6 +16,45 @@ export function preferredPixelFormat(display, littleEndian = new Uint8Array(new
 // 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){
@@ -24,10 +65,47 @@ export function bgraParser(Base,display) {
       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;
+      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

@@ -348,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) {
@@ -425,28 +434,38 @@ export class Renderer {
     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();
+    // 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 (rect[0] > this.offsetX || rect[2] < this.offsetX + this.columns * this.cellWidth
-          || !this.screen.canDrawRawImage?.(image, rect, bounds)) continue;
+      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++) coveredRows.add(row);
+      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 = 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)) {
+          || 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;
@@ -477,7 +496,7 @@ export class Renderer {
     this.dirtyAll = false;
     dirty.sort((a, b) => a - b);
     for (const row of dirty) {
-      if (!coveredRows.has(row)) this.drawRow(buffer.getLine(top + row), row);
+      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);

package/initramfs/lib/bunterm/terminal.js

@@ -93,6 +93,7 @@ export const createSession = ({
   });
 
   let frameTimer = null;
+  let lastPaintTime = -Infinity;
   let active = true;
   let blinkOn = true;
   const cursorHidden = () => Boolean(term._core?.coreService?.isCursorHidden);
@@ -108,6 +109,7 @@ export const createSession = ({
     if (frameTimer) clearTimeout(frameTimer);
     frameTimer = null;
     if (!active) return false;
+    lastPaintTime = performance.now();
     const buffer = term.buffer.active;
     // cursorY counts from the buffer's base, so a scrolled-back viewport
     // moves the cursor down the screen and eventually off it.
@@ -129,7 +131,9 @@ export const createSession = ({
   };
   const requestFrame = () => {
     if (!active) return;
-    frameTimer ??= setTimeout(paint, 16);
+    // Limit paint starts, rather than adding 16 ms after every arriving frame.
+    // Slow rendering already consumes the interval; keep one pending paint.
+    frameTimer ??= setTimeout(paint, Math.max(0, 16 - (performance.now() - lastPaintTime)));
   };
   const changed = () => { renderer.invalidate(); requestFrame(); };
   const selection = createSelection(term, renderer, changed);
@@ -198,8 +202,10 @@ export const createSession = ({
   let queue = Promise.resolve();
   const pump = (chunk) => {
     queue = queue.then(async () => {
+      if (closed) return;
       const { events } = kitty.consume(chunk);
       for (const event of events) {
+        if (closed) return;
         if (event.kind === "plain") {
           // A selection is a snapshot of the displayed cells. Drop it before
           // output scrolls/replaces those cells, rather than copying stale rows.
@@ -210,8 +216,11 @@ export const createSession = ({
         const buffer = term.buffer.active;
         const graphic = kitty.parsePacket(event.packet, { row: buffer.cursorY + 1, col: buffer.cursorX + 1 });
         if (!graphic) continue;
+        using frame = graphic[Symbol.dispose] ? graphic : null;
         const motion = await images.handle(graphic);
+        if (closed) return;
         if (motion) await writeTerminal(term, motion);
+        if (closed) return;
         const ack = kitty.acknowledge(graphic);
         if (ack) backend.write(Buffer.from(ack, "utf8"));
       }
@@ -386,6 +395,7 @@ export const createSession = ({
     keyboardProtocol = null;
     pointerDevice?.close();
     pointerDevice = null;
+    kitty.dispose();
     images.delete();
     renderer.delete();
     term.dispose();

package/initramfs/lib/fbdev.js

@@ -283,11 +283,17 @@ export const syncFramebuffer = (display, native = {
 
 export const flush = (display) => {
   const visibleBytes = display.width * display.bytesPerPixel;
-  for (let y = 0; y < display.height; y++) {
-    const row = display.pixels.subarray(y * display.stride, y * display.stride + visibleBytes);
-    const position = (y + display.yOffset) * display.stride
-      + display.xOffset * display.bytesPerPixel;
-    display.memory.set(row, position);
+  if (display.xOffset === 0 && display.stride === visibleBytes) {
+    // Contiguous visible rows need one bulk copy, not one JS call per row.
+    display.memory.set(display.pixels.subarray(0, display.height * display.stride),
+      display.yOffset * display.stride);
+  } else {
+    for (let y = 0; y < display.height; y++) {
+      const row = display.pixels.subarray(y * display.stride, y * display.stride + visibleBytes);
+      const position = (y + display.yOffset) * display.stride
+        + display.xOffset * display.bytesPerPixel;
+      display.memory.set(row, position);
+    }
   }
   syncFramebuffer(display);
 };

package/initramfs/lib/mapped-frame.js

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

package/initramfs/lib/raw-image.js

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

package/package.json

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

package/scripts/arch.js

@@ -16,8 +16,8 @@ export const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 const pins = {
   x86_64: {
-    linuxVirtSha256: "1eec55004cf7167c914c8839f46691d2bc82767e20466bff51eb45d06f8e90cc",
-    linuxLtsSha256: "af399fba75cafb2940fc2853eb73ba2289aa463228f33541cd3010334a30992b",
+    linuxVirtSha256: "73ad4774ca26c196103a00e2fb8d28ed02de4c08c11fad96e903da03dcb085f4",
+    linuxLtsSha256: "ae0a669a08c90ef971996f81f1bcb6f7ca8211ad62624ad8c5b57412c3f1def8",
     muslSha256: "573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71",
     stubSha256: "8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9",
     libstdcppSha256: "14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6",
@@ -32,8 +32,8 @@ const pins = {
     serialMajor: 4,
   },
   aarch64: {
-    linuxVirtSha256: "b46c51ddf572d85b2ba7b9adfaa64f4c38fc490c93d97a20ffd2418d51284085",
-    linuxLtsSha256: "65ab581dd6773e2b1b6831dac50142518b2f2083668f164f68ebfcd00d1763c4",
+    linuxVirtSha256: "89b68fc32d61a1483ab0d9db78b5a06144ac115fe2ee8102cb4ad7987f46d524",
+    linuxLtsSha256: "f6387970517083d5f08abacbf81baf1d70e1baa8fe4c2783469f45bb0751075c",
     muslSha256: "5e9674b7f41152fe2119093b5cb4c13eaaadb19c2d5422b2d7267913e663ee6e",
     stubSha256: "a1823d2d7082db555d528f82c1809f276c818aeb5b40f198f4565f104e055c38",
     libstdcppSha256: "2302e766d4e4926038ec166ecb85837ee884576115236ddb565e3a5fca4a11d7",
@@ -68,7 +68,7 @@ export const config = ({
   // The Alpine repository keeps only the newest build of a package, so a pin
   // stops downloading when Alpine bumps it; the hashes then fail loudly.
   const alpineBase = `${mirror}/v3.24/main/${arch}`;
-  const kernelVersion = "6.18.58";
+  const kernelVersion = "6.18.59";
   const kernelRelease = `${kernelVersion}-0-${flavor}`;
   const bunVersion = "1.4.2";
   const downloadsDir = join(rootDir, "downloads", arch);

package/scripts/arch.sh

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

package/scripts/npm-packages.md

@@ -1,19 +1,20 @@
 # npm packages
 # Latest versions checked on 2026-10-11; SHA-256 pins verified against registry SHA-512 integrity.
-# buninu-browser 0.3.0, buninu-land 0.2.0, casty 1.4.1, and jspulse 0.2.3 verified on 2026-10-22.
+# buninu-browser 0.6.0, buninu-land 0.3.1, and casty 1.5.1 verified on 2026-10-29.
+# jspulse 0.2.3 verified on 2026-10-22.
 # jspinyin 0.2.0 verified on 2026-10-22.
 
-"buninu-browser@0.3.0":
-  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.3.0.tgz
-  - sha256:4590c523f76ce7c3a079894b80a541b788c95895036d0094c0e98c2acc6d5179
+"buninu-browser@0.6.0":
+  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.6.0.tgz
+  - sha256:81929d903239f615f6265e0b8bf52cc36e34c622486c517bc58d70078c28f72c
 
-"buninu-land@0.2.0":
-  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.2.0.tgz
-  - sha256:543098c9f934fe4d723ca65b5a0c8a0bd11a04268228c23c3272073dc4549b56
+"buninu-land@0.3.1":
+  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.3.1.tgz
+  - sha256:6a2df4b52e12bd20972b195903b72a8a1fdefb62a60391c5f090764283731d22
 
-"@drxiaozhi/casty@1.4.1":
-  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.4.1.tgz
-  - sha256:0179c699a82202dc3d84f8736c8d88b29941d87995d6c6b554fd534daa70d280
+"@drxiaozhi/casty@1.5.1":
+  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.5.1.tgz
+  - sha256:821b9ca5e726afa691c4761d9ec917f862bb1a14592a7e590713c5fc735f71fa
 
 "@drxiaozhi/jspulse@0.2.3":
   - https://registry.npmjs.org/@drxiaozhi/jspulse/-/jspulse-0.2.3.tgz

package/test/bunterm-image-bytes.test.js

@@ -53,3 +53,18 @@ test('raw RGBA bytes pass directly to CanvasKit', async () => {
   expect(received).toBe(image.data);
   expect(received.equals(pixels)).toBe(true);
 });
+
+import {rawImageOpaque} from '../initramfs/lib/raw-image.js';
+test('raw opacity checks every pixel in aligned and unaligned byte views', () => {
+  for (const length of [0, 1, 7, 8, 9, 15, 16, 17, 33]) for (const offset of [0, 1, 4]) {
+    const storage = new Uint8Array(length * 4 + offset);
+    const pixels = storage.subarray(offset);
+    for (let i = 3; i < pixels.length; i += 4) pixels[i] = 255;
+    expect(rawImageOpaque({pixels})).toBe(true);
+    for (let i = 3; i < pixels.length; i += 4) {
+      pixels[i] = 254;
+      expect(rawImageOpaque({pixels})).toBe(false);
+      pixels[i] = 255;
+    }
+  }
+});

package/test/bunterm-mapped-lifetime.test.js

@@ -0,0 +1,147 @@
+import {test, expect} from 'bun:test';
+import fs from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {createRequire} from 'node:module';
+import {bgraParser, BGRA_FORMAT} from '../initramfs/lib/bunterm/raw-protocol.js';
+import {ownMapping, retainMapping} from '../initramfs/lib/mapped-frame.js';
+import {createRawImage, rawImageData, skiaImage} from '../initramfs/lib/raw-image.js';
+import {ImageStore} from '../initramfs/lib/bunterm/images.js';
+const {KittyGraphicsParser} = createRequire(import.meta.url)('../initramfs/buninu/apps/jsgotty/gotty.js');
+const CK = {ColorType:{RGBA_8888:1,BGRA_8888:2}};
+function fixture() {
+  const dir=fs.mkdtempSync(join(tmpdir(),'tty-graphics-protocol-lifetime-'));
+  const parser=new (bgraParser(KittyGraphicsParser))({binaryData:true});
+  const term={buffer:{active:{type:'alternate',baseY:0,cursorY:0,cursorX:0,viewportY:0}}};
+  const store=new ImageStore({CanvasKit:CK,term,renderer:{cellWidth:1,cellHeight:1,offsetX:0,offsetY:0,rows:10,invalidateRows(){}}});
+  const parse=(control,payload='')=>parser.parsePacket(Buffer.from(control+';'+payload),{row:1,col:1});
+  let serial=0;
+  return {parser,store,parse,frame(id=1,format=BGRA_FORMAT){
+    const path=join(dir,'frame'+serial++);fs.writeFileSync(path,Buffer.from([1,2,3,255]));
+    return parse(`a=T,t=t,f=${format},s=1,v=1,i=${id},C=1`,Buffer.from(path).toString('base64'));
+  },close(){parser.dispose();store.delete();fs.rmSync(dir,{recursive:true,force:true});}};
+}
+
+test('replacement protects parser results and renderer until their independent owners release',async()=>{
+  const f=fixture();
+  try {
+    using first=f.frame();const bytes=first.image.data;
+    await f.store.handle(first);
+    using second=f.frame();
+    expect(bytes.byteLength).toBe(4); // parser replaced, renderer/result still own old frame
+    await f.store.handle(second);
+    expect(bytes.byteLength).toBe(4); // result is still borrowed
+    first[Symbol.dispose]();first[Symbol.dispose]();
+    expect(bytes.byteLength).toBe(0);
+    const next=second.image.data;
+    f.parser.dispose();second[Symbol.dispose]();
+    expect(next.byteLength).toBe(4); // renderer outlives parser
+    f.store.delete();expect(next.byteLength).toBe(0);
+  } finally {f.close();}
+});
+
+test('multiple placements and lowercase deletion retain pixels for re-placement',async()=>{
+  const f=fixture();
+  try {
+    using first=f.frame(1,32);const bytes=first.image.data;
+    await f.store.handle(first);first[Symbol.dispose]();
+    using second=f.parse('a=p,i=1,p=two,C=1');await f.store.handle(second);second[Symbol.dispose]();
+    expect(f.store.visible()).toHaveLength(2);
+    await f.store.handle(f.parse('a=d,d=i,i=1,p=two'));
+    expect(f.store.visible()).toHaveLength(1);expect(bytes.byteLength).toBe(4);
+    await f.store.handle(f.parse('a=d,d=a'));
+    expect(f.store.visible()).toHaveLength(0);expect(bytes.byteLength).toBe(4);
+    using again=f.parse('a=p,i=1,C=1');await f.store.handle(again);again[Symbol.dispose]();
+    expect(rawImageData(f.store.visible()[0].image).pixels[0]).toBe(1);
+    await f.store.handle(f.parse('a=d,d=A'));
+    expect(bytes.byteLength).toBe(0);
+  } finally {f.close();}
+});
+
+test('queued frames survive replacement and parser shutdown before consumer handles them',async()=>{
+  const f=fixture();
+  try {
+    using first=f.frame();using second=f.frame();f.parser.dispose();
+    await f.store.handle(first);first[Symbol.dispose]();
+    expect(first.image.data.byteLength).toBe(4);
+    await f.store.handle(second);expect(first.image.data.byteLength).toBe(0);
+    second[Symbol.dispose]();f.store.delete();expect(second.image.data.byteLength).toBe(0);
+    expect(f.frame()).toBeNull();
+  } finally {f.close();}
+});
+
+test('closing while decode awaits cannot repopulate the image store',async()=>{
+  const f=fixture();
+  try {
+    using first=f.frame();const handling=f.store.handle(first);
+    f.store.delete();f.parser.dispose();await handling;
+    expect(f.store.images.size).toBe(0);expect(f.store.placements.size).toBe(0);
+    first[Symbol.dispose]();expect(first.image.data.byteLength).toBe(0);
+  } finally {f.close();}
+});
+
+test('using releases a borrowed frame when processing throws; ordinary buffers never detach',()=>{
+  const f=fixture();let bytes;
+  try {
+    expect(()=>{using first=f.frame();bytes=first.image.data;f.parser.dispose();throw Error('test');}).toThrow('test');
+    expect(bytes.byteLength).toBe(0);
+    const ordinary=Buffer.alloc(4);const image=createRawImage(CK,ordinary,1,1,1);
+    image.delete();expect(ordinary.byteLength).toBe(4);
+  } finally {f.close();}
+});
+
+test('failed/unsupported transfer falls back to GC without breaking cleanup',()=>{
+  for(const transfer of [undefined,()=>{throw Error('not detachable');}]){
+    const bytes=new Uint8Array(4);Object.defineProperty(bytes.buffer,'transfer',{value:transfer});
+    const release=ownMapping(bytes),other=retainMapping(bytes);
+    release();expect(bytes.byteLength).toBe(4);
+    expect(()=>{other();other();release();}).not.toThrow();
+    expect(bytes.byteLength).toBe(4);
+  }
+});
+
+test('query/error mappings are released even though they never enter the image cache',()=>{
+  const f=fixture();const mapped=[];
+  const read=f.parser._readImageFile.bind(f.parser);
+  f.parser._readImageFile=(...args)=>{const bytes=read(...args);mapped.push(bytes);return bytes;};
+  try {
+    // A query validates its file then drops its data. Exercise the same packet
+    // cleanup on an exception after the read, before the cache can retain it.
+    for(const fail of [false,true]){
+      const path=join(tmpdir(),'tty-graphics-protocol-query-'+process.pid);fs.writeFileSync(path,Buffer.from([1,2,3,255]));
+      const resolve=f.parser._resolveImageData.bind(f.parser);
+      if(fail)f.parser._resolveImageData=(...args)=>{resolve(...args);throw Error('validation failed');};
+      const result=f.parse(`a=q,t=t,f=${BGRA_FORMAT},s=1,v=1,i=7`,Buffer.from(path).toString('base64'));
+      expect(result.responseMessage).toStartWith(fail?'ERROR:':'OK');
+      expect(mapped.at(-1).byteLength).toBe(0);
+    }
+    expect(f.parser.images.size).toBe(0);
+  } finally {f.close();}
+});
+
+test('materialized Skia images and mapped bytes both release even if Skia cleanup throws',()=>{
+  const bytes=new Uint8Array(4),owner=ownMapping(bytes);
+  const image=createRawImage({...CK,AlphaType:{Unpremul:1},ColorSpace:{SRGB:1},MakeImage(){return {delete(){throw Error('Skia cleanup');}};}},bytes,1,1,1);
+  owner();skiaImage(image);
+  expect(()=>image.delete()).toThrow('Skia cleanup');expect(bytes.byteLength).toBe(0);
+  expect(()=>image.delete()).not.toThrow();
+});
+
+test('repeated mapped replacements unmap promptly without waiting for a GC',async()=>{
+  const f=fixture();let previous;
+  try {
+    for(let i=0;i<200;i++){
+      using frame=f.frame();await f.store.handle(frame);
+      if(previous)expect(previous.byteLength).toBe(0);
+      previous=frame.image.data;
+      expect(previous[3]).toBe(255);
+    }
+    f.parser.dispose();f.store.delete();expect(previous.byteLength).toBe(0);
+    if(process.platform==='linux'){
+      const maps=fs.readFileSync('/proc/self/maps','utf8');
+      // Files were unlinked at read time; lingering mappings would still have
+      // their original name followed by '(deleted)' here.
+      expect(maps.split('\n').filter(line=>line.includes('tty-graphics-protocol-lifetime-'))).toHaveLength(0);
+    }
+  } finally {f.close();}
+});

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

@@ -17,3 +17,23 @@ test('native preference follows framebuffer bitfields; browser parser remains un
  const bad=fb();bad.fields.red.msbRight=1;
  expect(preferredPixelFormat(bad)).toBe('png');expect(preferredPixelFormat(fb(),false)).toBe('png');
 });
+
+import fs from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+test('raw temporary mappings survive unlink; regular and partial files retain copying behavior',()=>{
+ const dir=fs.mkdtempSync(join(tmpdir(),'tty-graphics-protocol-mmap-'));
+ const parser=new (bgraParser(KittyGraphicsParser,fb()))({binaryData:true});
+ const bytes=Buffer.from([1,2,3,255,4,5,6,255]);
+ try{
+  for(const format of [32,BGRA_FORMAT]){
+   const path=join(dir,'frame');fs.writeFileSync(path,bytes);
+   const got=parser._readImageFile({f:String(format),s:'2',v:'1'},Buffer.from(path).toString('base64'),true);
+   expect(fs.existsSync(path)).toBe(false);expect(got).toEqual(bytes);
+  }
+  const path=join(dir,'regular');fs.writeFileSync(path,bytes);
+  const payload=Buffer.from(path).toString('base64'),control={f:String(BGRA_FORMAT),s:'2',v:'1'};
+  expect(parser._readImageFile(control,payload,false)).toEqual(bytes);expect(fs.existsSync(path)).toBe(true);
+  expect(parser._readImageFile({...control,O:'4',S:'4'},payload,true)).toEqual(bytes.subarray(4));
+ }finally{parser.dispose();fs.rmSync(dir,{recursive:true,force:true});}
+});