buninu-linux 0.3.0 → 0.4.0

package/initramfs/bin/top

@@ -0,0 +1,129 @@
+#!/bin/bun
+// top — periodically render snapshots and process lines supplied by ps.
+
+import { showDocument } from "../lib/document.js";
+import {
+  CLOCK_TICKS,
+  formatProcessHeader,
+  formatProcessLine,
+  prepareProcessFormat,
+  readProcessSnapshot,
+} from "./ps";
+
+const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const fields = ["pid", "user", "pri", "ni", "vsz", "rss", "state", "%cpu", "%mem", "time", "comm"];
+
+const uptimeText = (seconds) => {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  return `${days ? `${days} day${days === 1 ? "" : "s"}, ` : ""}${hours}:${String(minutes).padStart(2, "0")}`;
+};
+
+const memoryText = (memory) => {
+  const total = memory.MemTotal ?? 0;
+  const free = memory.MemFree ?? 0;
+  const cache = (memory.Buffers ?? 0) + (memory.Cached ?? 0) + (memory.SReclaimable ?? 0);
+  return `MiB Mem : ${(total / 1024).toFixed(1)} total, ${(free / 1024).toFixed(1)} free, ${((total - free - cache) / 1024).toFixed(1)} used, ${(cache / 1024).toFixed(1)} buff/cache`;
+};
+
+const intervalRows = (snapshot, previous) => {
+  if (!previous) return snapshot.processes;
+  const elapsed = Math.max(0.001, (snapshot.at - previous.at) / 1000);
+  const oldTicks = new Map(previous.processes.map((row) => [row.pid, row.ticks]));
+  return snapshot.processes.map((row) => ({
+    ...row,
+    cpu: Math.max(0, row.ticks - (oldTicks.get(row.pid) ?? row.ticks)) / CLOCK_TICKS / elapsed * 100,
+  }));
+};
+
+const render = (snapshot, previous, sort, batch) => {
+  const rows = intervalRows(snapshot, previous);
+  rows.sort(sort === "memory"
+    ? (a, b) => b.memory - a.memory || a.pid - b.pid
+    : sort === "pid" ? (a, b) => a.pid - b.pid : (a, b) => b.cpu - a.cpu || a.pid - b.pid);
+  const states = { running: 0, sleeping: 0, stopped: 0, zombie: 0 };
+  for (const row of rows) {
+    if (row.state[0] === "R") states.running++;
+    else if (row.state[0] === "T") states.stopped++;
+    else if (row.state[0] === "Z") states.zombie++;
+    else states.sleeping++;
+  }
+  const total = previous ? snapshot.cpu.total - previous.cpu.total : snapshot.cpu.total;
+  const idleTicks = previous ? snapshot.cpu.idle - previous.cpu.idle : snapshot.cpu.idle;
+  const idle = total > 0 ? idleTicks / total * 100 : 0;
+  const clock = new Date().toLocaleTimeString("en-US", { hour12: false });
+  const lines = [
+    `top - ${clock} up ${uptimeText(snapshot.uptime)}, load average: ${snapshot.loadAverage.map((v) => v.toFixed(2)).join(", ")}`,
+    `Tasks: ${rows.length} total, ${states.running} running, ${states.sleeping} sleeping, ${states.stopped} stopped, ${states.zombie} zombie`,
+    `%Cpu(s): ${(100 - idle).toFixed(1)} used, ${idle.toFixed(1)} id`,
+    memoryText(snapshot.memory),
+    "",
+  ];
+  const format = prepareProcessFormat(rows, fields);
+  lines.push(formatProcessHeader(format));
+  // Some early boot consoles report a TTY size of 0x0. Treat that as
+  // unknown; otherwise Math.max(1, 0 - headers) displays only one process
+  // and makes it look as if the snapshot contained only top itself.
+  const terminalRows = Number(process.stdout.rows);
+  const screenRows = Number.isFinite(terminalRows) && terminalRows > lines.length
+    ? terminalRows
+    : 24;
+  const limit = batch ? rows.length : Math.max(1, screenRows - lines.length);
+  for (const row of rows.slice(0, limit)) lines.push(formatProcessLine(row, format));
+  return lines.join("\n");
+};
+
+async function main(argv) {
+  let delay = 3;
+  let iterations = Infinity;
+  let batch = false;
+  for (let index = 0; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") return showDocument("top");
+    if (argument === "-b") { batch = true; continue; }
+    if (argument === "-d") { delay = Number(argv[++index]); continue; }
+    if (argument === "-n") { iterations = Number(argv[++index]); continue; }
+    throw new Error(`top: unsupported option '${argument}'`);
+  }
+  if (!(delay > 0) || !(iterations > 0)) throw new Error("top: -d and -n require positive numbers");
+  let quit = false;
+  let sort = "cpu";
+  const interactive = !batch && process.stdin.isTTY && process.stdout.isTTY;
+  const cleanup = () => {
+    if (interactive) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\x1b[?25h\n");
+    }
+  };
+  if (interactive) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (key) => {
+      if (key === "q" || key === "\u0003") quit = true;
+      else if (key === "P") sort = "cpu";
+      else if (key === "M") sort = "memory";
+      else if (key === "N") sort = "pid";
+    });
+    process.stdout.write("\x1b[?25l");
+    process.on("exit", cleanup);
+  } else if (!batch && iterations === Infinity) iterations = 1;
+
+  let previous = null;
+  try {
+    for (let count = 0; count < iterations && !quit; count++) {
+      const snapshot = readProcessSnapshot();
+      const output = render(snapshot, previous, sort, batch);
+      process.stdout.write(`${interactive ? "\x1b[H\x1b[2J" : ""}${output}\n`);
+      previous = snapshot;
+      if (count + 1 < iterations && !quit) await sleep(delay * 1000);
+    }
+  } finally { cleanup(); }
+}
+
+if (import.meta.main) {
+  try { await main(process.argv.slice(2)); }
+  catch (error) { console.error(error.message); process.exit(1); }
+}

package/initramfs/bin/umount

@@ -2,7 +2,8 @@
 // umount — unmount a filesystem. `umount --help` renders
 // /usr/share/doc/buninu-linux/umount.md.
 
-import { libc, cString, ptr, errno, strerror, Errno, showDocument } from "../lib/dlopen.js";
+import { libc, cString, ptr, errno, strerror, Errno } from "../lib/dlopen.js";
+import { showDocument } from "../lib/document.js";
 
 const MNT = { FORCE: 1, DETACH: 2, EXPIRE: 4, NOFOLLOW: 8 };
 

package/initramfs/buninu/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.4.15 - 2026-09-22
+
+### Changed
+
+- Sync jsgotty to 1.1.12
+  * Export `BunPtyBackend` from `gotty.js`, the PTY layer built on
+    `Bun.spawn({ terminal })`, so other programs can run a command on a
+    pseudo-terminal without their own FFI. Buninu Linux's `bunterm`, a
+    graphical terminal on the framebuffer, is its first user, together with
+    the already exported `KittyGraphicsParser`
+
+### Fixed
+
+- jsgotty: a chunked kitty graphics transfer whose first chunk names an
+  image id (`i=`) is now continued by later chunks that carry only `m=`, as
+  the protocol allows. Previously those chunks were treated as new anonymous
+  transfers, so the image never completed. jsgotty's own `showimg` repeats
+  the id in every chunk and was unaffected; `kitten icat`, timg, chafa and
+  similar clients were
+
+## 0.4.13 - 2026-09-22
+
+### Changed
+
+- Sync bunmsh to 0.3.9
+  * `Ctrl-U` removes and saves the text before the cursor; pressing it again
+    at the beginning of the line restores it. `Ctrl-K` independently toggles
+    the text after the cursor when at the end of the line
+  * Unquoted pathname patterns follow directory symbolic links used as
+    intermediate path components, as traditional shells do, so patterns such
+    as `/sys/class/net/*/device` pass through sysfs class links
+  * The fallback `ls`/`lsfancy` lists a glob's files as one listing instead
+    of one section per file, honors `--`, and follows a command-line symlink
+    to a directory
+- Sync jsmdcui to 0.19.2
+  * Pressing `Ctrl-W` twice quickly switches to the next tab like `Alt-T`
+    from either an editor or a terminal pane; at the rightmost tab, when every
+    tab holds only terminal panes, it opens a new editor tab instead of
+    cycling back
+
 ## 0.4.12 - 2026-09-20
 
 ### Fixed

package/initramfs/buninu/apps/bunmsh/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.3.9] - 2026-09-22
+
+### Fixed
+
+- Make pathname expansion follow directory symbolic links used as intermediate
+  path components, matching traditional shell behaviour. `Bun.Glob` disables
+  that traversal by default, so patterns such as `./*/*.js` silently skipped
+  a matching directory symlink, and sysfs patterns such as
+  `/sys/class/net/*/device` failed to pass through class-device links. bunmsh
+  now enables `followSymlinks` while scanning; a symlink matched as the final
+  component is still passed to the command as a symlink.
+
+- Stop the fallback `ls`/`lsfancy` from printing every glob-expanded file as
+  a directory section. `builtin ls L*` previously expanded the glob
+  correctly, but multiple operands unconditionally received `filename:`
+  headings and blank separators. Only directories whose contents are being
+  listed now receive section headings; multiple ordinary files form one
+  continuous listing and retain their full operand paths rather than being
+  reduced to basenames.
+
+- Honor `--` in `ls`/`lsfancy`, so names such as `-odd` after it are operands
+  rather than option clusters. Also follow a command-line symlink to a
+  directory for ordinary and recursive listings, as traditional `ls` does;
+  `-d`, `-l`, and `-F` continue to inspect the symlink itself.
+
+## [0.3.8] - 2026-09-21
+
+### Added
+
+- Make `Ctrl-U` and `Ctrl-K` toggle their edits in the interactive line
+  editor. `Ctrl-U` saves the text removed before the cursor and restores it
+  when pressed again at the beginning of the line; `Ctrl-K` does the same for
+  text after the cursor when pressed again at the end. Each shortcut keeps an
+  independent saved value, and control bytes inside bracketed paste remain
+  literal pasted content rather than triggering either action.
+
 ## [0.3.7] - 2026-09-20
 
 ### Fixed

package/initramfs/buninu/apps/bunmsh/README.md

@@ -476,6 +476,13 @@ Bun.e, Bun.file("/tm     # -> a path, completed inside the string
 
 - `Ctrl-D`: On an empty input line, sends EOF and exits the interactive shell.
 
+- `Ctrl-U`: Removes and saves everything before the cursor. Press it again
+  while the cursor is at the beginning to restore that saved prefix.
+
+- `Ctrl-K`: Removes and saves everything after the cursor. Press it again
+  while the cursor is at the end to restore that saved suffix. Its saved text
+  is independent from `Ctrl-U`.
+
 - `Ctrl-T`: Calls `builtin tab` without adding a command to history. It creates
   a tab when only one exists, or switches to the next tab otherwise. Any
   command text currently being edited is preserved.

package/initramfs/buninu/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

package/initramfs/buninu/apps/bunmsh/src/fancy-ls.js

@@ -1,5 +1,5 @@
-import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
-import { basename, isAbsolute, resolve } from "node:path";
+import { existsSync, lstatSync, readdirSync, readlinkSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 
 const IMAGE = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "ico", "avif", "heic"]);
 const MUSIC = new Set(["mp3", "wav", "flac", "ogg", "m4a", "aac", "opus", "mid", "midi"]);
@@ -120,9 +120,11 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
     recursive: false, time: false, reverse: false, size: false, one: false, classify: false,
   };
   const operands = [];
+  let parseOptions = true;
   for (const argument of argv.slice(1)) {
-    if (argument === "--color=auto" || argument === "--color" || argument === "--") continue;
-    if (/^-[^-]/.test(argument)) {
+    if (parseOptions && argument === "--") { parseOptions = false; continue; }
+    if (parseOptions && (argument === "--color=auto" || argument === "--color")) continue;
+    if (parseOptions && /^-[^-]/.test(argument)) {
       for (const flag of argument.slice(1)) {
         if (flag === "a") options.all = true;
         else if (flag === "A") options.almostAll = true;
@@ -142,15 +144,30 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
   if (!operands.length) operands.push(".");
   let status = 0, stdout = "", stderr = "";
   const visited = new Set();
-  const show = (operand, heading = operands.length > 1) => {
+  let previousWasDirectory = false;
+  const show = (operand, heading = operands.length > 1, separate = true) => {
     const path = isAbsolute(operand) ? operand : resolve(state.cwd, operand);
     try {
       const stats = lstatSync(path);
+      let listingDirectory = stats.isDirectory() && !options.directory;
+      // GNU/POSIX-style ls follows a command-line symlink to a directory for
+      // an ordinary listing and for -R. -d, -l, and -F request information
+      // about the link itself instead. A broken link simply cannot qualify.
+      if (stats.isSymbolicLink() && !options.directory && !options.long && !options.classify) {
+        try { listingDirectory = statSync(path).isDirectory(); } catch {}
+      }
+      // Multiple file operands are one listing, not a series of directory
+      // sections. Only actual directory contents receive `name:` headings
+      // and blank section separators.
+      if (separate && stdout && (listingDirectory || previousWasDirectory)) stdout += "\n";
       let entries;
-      if (!stats.isDirectory() || options.directory)
-        entries = [{ name: basename(operand) || operand, stats, path }];
+      if (!listingDirectory)
+        // Preserve the operand spelling just like traditional ls. A glob such
+        // as ./*/*.js has already expanded to paths, and reducing each one to
+        // basename would lose the information that distinguishes its parent.
+        entries = [{ name: operand, stats, path }];
       else entries = listDirectory(path, options);
-      if (heading) stdout += `${operand}:\n`;
+      if (heading && listingDirectory) stdout += `${operand}:\n`;
       const rendered = entries.map((entry) => displayEntry(entry, options));
       if (options.long) {
         for (let i = 0; i < entries.length; i++) {
@@ -164,23 +181,21 @@ export function fancyLs(argv, state, terminal = Boolean(process.stdout.isTTY)) {
       } else stdout += terminal && !options.one
         ? columns(rendered, process.stdout.columns ?? 80)
         : `${rendered.join("\n")}${rendered.length ? "\n" : ""}`;
-      if (options.recursive && stats.isDirectory() && !options.directory) {
+      if (options.recursive && listingDirectory) {
         for (const entry of entries) if (entry.stats.isDirectory() && entry.name !== "." && entry.name !== "..") {
           const child = resolve(path, entry.name);
           if (visited.has(child)) continue;
           visited.add(child);
           stdout += "\n";
-          show(`${operand.replace(/\/$/, "")}/${entry.name}`, true);
+          show(`${operand.replace(/\/$/, "")}/${entry.name}`, true, false);
         }
       }
+      previousWasDirectory = listingDirectory;
     } catch (error) {
       status = 1;
       stderr += `bunmsh: ${argv[0]}: ${operand}: ${error.message}\n`;
     }
   };
-  for (let i = 0; i < operands.length; i++) {
-    if (i) stdout += "\n";
-    show(operands[i]);
-  }
+  for (const operand of operands) show(operand);
   return { status, stdout, stderr };
 }

package/initramfs/buninu/apps/bunmsh/src/line-edit.js

@@ -0,0 +1,43 @@
+export function toggleSavedText(line, cursor, saved, side) {
+  line = String(line ?? "");
+  cursor = Math.max(0, Math.min(line.length, Number.isFinite(cursor) ? cursor : line.length));
+  saved = String(saved ?? "");
+
+  if (side === "head") {
+    if (cursor > 0) {
+      return {
+        line: line.slice(cursor),
+        cursor: 0,
+        saved: line.slice(0, cursor),
+        changed: true,
+      };
+    }
+    if (saved) {
+      return {
+        line: saved + line,
+        cursor: saved.length,
+        saved: "",
+        changed: true,
+      };
+    }
+  } else if (side === "tail") {
+    if (cursor < line.length) {
+      return {
+        line: line.slice(0, cursor),
+        cursor,
+        saved: line.slice(cursor),
+        changed: true,
+      };
+    }
+    if (saved) {
+      return {
+        line: line + saved,
+        cursor,
+        saved: "",
+        changed: true,
+      };
+    }
+  }
+
+  return { line, cursor, saved, changed: false };
+}

package/initramfs/buninu/apps/bunmsh/src/main.js

@@ -29,6 +29,7 @@ import { importedHistory, readlineHistory, saveBunmshHistory } from "./history.j
 import pkg from "../package.json" with { type:"json" }
 import { MOUSE_OFF, MOUSE_ON, PASTE_OFF, PASTE_ON, mouseInput } from "./mouse.js";
 import { homeRelativePath } from "./environment.js";
+import { toggleSavedText } from "./line-edit.js";
 
 const VERSION = `
 ${pkg.name}: ${pkg.description}
@@ -223,6 +224,8 @@ async function interactive(state) {
   let lastTabClick = null;
   let mouseCommandRunning = false;
   let foregroundCommand = false;
+  let savedHead = "";
+  let savedTail = "";
   let promptAbort = null;
   // Set by onPaste (below) when a bracketed paste contains a newline, and
   // consumed by the main loop's readline.question() catch block right after
@@ -332,6 +335,17 @@ async function interactive(state) {
     const key = { name: delta > 0 ? "right" : "left" };
     for (let n = 0; n < Math.abs(delta); n++) readline.write(null, key);
   };
+  const toggleLineText = (side) => {
+    if (!readline || foregroundCommand) return;
+    const saved = side === "head" ? savedHead : savedTail;
+    const result = toggleSavedText(readline.line, readline.cursor, saved, side);
+    if (side === "head") savedHead = result.saved;
+    else savedTail = result.saved;
+    if (!result.changed) return;
+    readline.line = result.line;
+    readline.cursor = result.cursor;
+    readline.prompt(true);
+  };
   const filteredInput = terminal ? mouseInput((mouse) => {
     if (!mouse.press || (mouse.button & 3) !== 0 || (mouse.button & 32)) return;
     pendingClick = { ...mouse, at: Date.now() };
@@ -384,7 +398,7 @@ async function interactive(state) {
     else if (shortcut === "lsfancy") runFancyShortcut();
     else if (shortcut === "lsfancy-parent") runFancyShortcut([".."]);
     else if (shortcut === "tab-close") runTabShortcut(["x"]);
-  }, onPaste) : process.stdin;
+  }, onPaste, toggleLineText) : process.stdin;
   const completer = (line) => {
     commandIndex.refreshIfChanged(state);
     if (javascriptLine(line)) {

package/initramfs/buninu/apps/bunmsh/src/mouse.js

@@ -21,7 +21,13 @@ function partialMarkerSuffixLength(text, marker) {
   return 0;
 }
 
-export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onPaste = () => {}) {
+export function mouseInput(
+  onMouse,
+  onCursorPosition,
+  onShortcut = () => {},
+  onPaste = () => {},
+  onEditShortcut = () => {},
+) {
   const decoder = new StringDecoder("utf8");
   let pending = "";
   // Bracketed paste (\x1b[200~ ... \x1b[201~): everything between the
@@ -48,6 +54,25 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         source = source.replace(/\x1bc/g, () => { onShortcut("tab-close"); return ""; });
       }
       let output = "";
+      const flushOutput = () => {
+        if (!output) return;
+        this.push(output);
+        output = "";
+      };
+      const appendPlainText = (text) => {
+        let start = 0;
+        for (let index = 0; index < text.length; index++) {
+          const side = text[index] === "\x15" ? "head"
+            : text[index] === "\x0b" ? "tail"
+            : null;
+          if (!side) continue;
+          output += text.slice(start, index);
+          flushOutput();
+          onEditShortcut(side);
+          start = index + 1;
+        }
+        output += text.slice(start);
+      };
       while (source) {
         if (pasting) {
           const end = source.indexOf(PASTE_END);
@@ -66,8 +91,8 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
           continue;
         }
         const escape = source.indexOf("\x1b[");
-        if (escape < 0) { output += source; break; }
-        output += source.slice(0, escape);
+        if (escape < 0) { appendPlainText(source); break; }
+        appendPlainText(source.slice(0, escape));
         source = source.slice(escape);
         if (source.startsWith(PASTE_START)) {
           pasting = true;
@@ -93,7 +118,7 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         output += source.slice(0, 2);
         source = source.slice(2);
       }
-      if (output) this.push(output);
+      flushOutput();
       done();
     },
   });

package/initramfs/buninu/apps/bunmsh/src/shell.js

@@ -787,7 +787,15 @@ async function pathnameFields(field, state) {
     return ch;
   }).join("");
   const glob = new Bun.Glob(pattern);
-  const matches = [...glob.scanSync({ cwd: state.cwd, dot: false, onlyFiles: false })].sort();
+  // Shell pathname expansion follows a directory symlink used as an
+  // intermediate path component. Bun.Glob defaults this off, which makes
+  // patterns such as /sys/class/*/device silently miss sysfs class links.
+  const matches = [...glob.scanSync({
+    cwd: state.cwd,
+    dot: false,
+    onlyFiles: false,
+    followSymlinks: true,
+  })].sort();
   return matches.length ? matches : [value];
 }
 

package/initramfs/buninu/apps/bunmsh/test/shell1.test.js

@@ -53,6 +53,7 @@ import { fancyLs } from "../src/fancy-ls.js";
 import { MOUSE_OFF, MOUSE_ON, mouseInput } from "../src/mouse.js";
 import { canonicalEnvironment, environmentValue, homeRelativePath } from "../src/environment.js";
 import { findIsRegularBuiltin } from "../src/find.js";
+import { toggleSavedText } from "../src/line-edit.js";
 
 async function run(source, options = {}) {
   const state = createState({
@@ -181,6 +182,36 @@ describe("completion", () => {
     ]);
   });
 
+  test("toggles independently saved Ctrl-U heads and Ctrl-K tails", () => {
+    const cutHead = toggleSavedText("headtail", 4, "", "head");
+    expect(cutHead).toEqual({ line: "tail", cursor: 0, saved: "head", changed: true });
+    expect(toggleSavedText(cutHead.line, cutHead.cursor, cutHead.saved, "head"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+
+    const cutTail = toggleSavedText("headtail", 4, "", "tail");
+    expect(cutTail).toEqual({ line: "head", cursor: 4, saved: "tail", changed: true });
+    expect(toggleSavedText(cutTail.line, cutTail.cursor, cutTail.saved, "tail"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+  });
+
+  test("intercepts Ctrl-U and Ctrl-K outside bracketed paste", async () => {
+    const edits = [];
+    const pasted = [];
+    let forwarded = "";
+    const input = mouseInput(() => {}, () => {}, () => {},
+      (text) => pasted.push(text),
+      (side) => edits.push({ side, forwarded }));
+    input.on("data", (chunk) => { forwarded += chunk.toString(); });
+    input.end("abc\x15def\x0b\x1b[200~x\x15y\x0bz\x1b[201~");
+    await new Promise((resolve) => input.once("end", resolve));
+    expect(edits).toEqual([
+      { side: "head", forwarded: "abc" },
+      { side: "tail", forwarded: "abcdef" },
+    ]);
+    expect(forwarded).toBe("abcdef");
+    expect(pasted).toEqual(["x\x15y\x0bz"]);
+  });
+
   test("imports Bash and Fish history by default and can be disabled", async () => {
     expect(parseBashHistory("#1720000000\necho bash\n\nshared\n"))
       .toEqual(["echo bash", "shared"]);
@@ -575,6 +606,7 @@ describe("execution", () => {
       mkdirSync(join(cwd, "targetdir"));
       symlinkSync("target.txt", join(cwd, "link_ok"));
       symlinkSync("targetdir", join(cwd, "link_dir"));
+      await Bun.write(join(cwd, "targetdir", "inside.js"), "export {};\n");
       symlinkSync("/nonexistent/path", join(cwd, "link_broken"));
       symlinkSync("loop_b", join(cwd, "loop_a"));
       symlinkSync("loop_a", join(cwd, "loop_b"));
@@ -597,6 +629,15 @@ describe("execution", () => {
       const plain = await run("builtin lsfancy", { cwd });
       expect(plain.stdout).toContain("🔗 link_ok");
       expect(plain.stdout).toContain("🚫 link_broken");
+
+      // A command-line link to a directory is followed for an ordinary
+      // listing, but -l, -d, and -F inspect/classify the link itself.
+      const followed = await run("builtin lsfancy link_dir", { cwd });
+      expect(followed.stdout).toContain("inside.js");
+      const linkLong = await run("builtin lsfancy -l link_dir", { cwd });
+      expect(linkLong.stdout).toContain("link_dir -> targetdir");
+      expect((await run("builtin lsfancy -d link_dir", { cwd })).stdout).toContain("🔗 link_dir");
+      expect((await run("builtin lsfancy -F link_dir", { cwd })).stdout).toContain("link_dir@");
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
@@ -624,6 +665,35 @@ describe("execution", () => {
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
+  test("builtin ls lists glob-expanded files as files, not directory sections", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "bunmsh-ls-glob-"));
+    try {
+      await Bun.write(join(cwd, "first.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "final.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "other.txt"), "other\n");
+      const output = await run("builtin ls f*.sh", { cwd });
+      expect(output).toMatchObject({ status: 0, stderr: "" });
+      expect(output.stdout).toContain("first.sh");
+      expect(output.stdout).toContain("final.sh");
+      expect(output.stdout).not.toContain("other.txt");
+      expect(output.stdout).not.toContain("first.sh:");
+      expect(output.stdout).not.toContain("final.sh:");
+      expect(output.stdout).not.toContain("\n\n");
+
+      await Bun.write(join(cwd, "-odd"), "odd\n");
+      const afterDoubleDash = await run("builtin ls -- -odd", { cwd });
+      expect(afterDoubleDash).toMatchObject({ status: 0, stderr: "" });
+      expect(afterDoubleDash.stdout).toContain("-odd");
+
+      mkdirSync(join(cwd, ".hidden-target"));
+      await Bun.write(join(cwd, ".hidden-target", "through-link.js"), "export {};\n");
+      symlinkSync(".hidden-target", join(cwd, "class-link"));
+      const throughLink = await run("builtin ls ./*/*.js", { cwd });
+      expect(throughLink).toMatchObject({ status: 0, stderr: "" });
+      expect(throughLink.stdout).toContain("./class-link/through-link.js");
+    } finally { rmSync(cwd, { recursive: true, force: true }); }
+  });
+
   test("fallback find filters paths and supports both -exec modes", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "bunmsh-find-"));
     try {

package/initramfs/buninu/apps/jsgotty/gotty.js

@@ -1173,9 +1173,9 @@ class KittyGraphicsParser {
 
     if (control.m === "1") {
       this.transfers.set(key, existing);
-      if (!control.i && !control.I) {
-        this.implicitTransferKey = key;
-      }
+      //  Later chunks of a transfer only need m=; they continue the transfer
+      //  in progress whether or not its first chunk named an image id.
+      this.implicitTransferKey = key;
       return null;
     }
 
@@ -3314,6 +3314,7 @@ async function bootstrap() {
 
 module.exports.CursorStateTracker = CursorStateTracker;
 module.exports.KittyGraphicsParser = KittyGraphicsParser;
+module.exports.BunPtyBackend = BunPtyBackend;
 module.exports.webSocketOriginAllowed = webSocketOriginAllowed;
 
 if (require.main === module) {

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.11",
+  "version": "1.1.12",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/initramfs/buninu/apps/jsmdcui/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable user-visible changes to jsmdcui are documented here.
 
+## [0.19.2] - 2026-09-21
+
+### Added
+
+- Quickly pressing `Ctrl-W` twice now switches to the next tab like `Alt-T`
+  from either an editor or terminal pane. A single press retains its existing
+  next-pane behavior. At the rightmost tab, when every tab contains only
+  terminal panes, the double press creates a new editor tab instead of cycling
+  back, ensuring keyboard-only access to editing and other non-terminal work.
+
 ## [0.19.0] - 2026-08-24
 
 ### Fixed