buninu-linux 0.9.56 → 0.11.56

package/initramfs/usr/lib/bootstrap/lib/seed.js

@@ -0,0 +1,148 @@
+import {
+  chmodSync, cpSync, mkdirSync, readFileSync, readdirSync,
+  renameSync, symlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import {
+  bootstrap, bun, download, elfInterpreter, run, sha256,
+  validateElf, write,
+} from "./common.js";
+
+const tools = [
+  "bin/tar", "bin/unzip", "usr/bin/env",
+  "lib/crc32.js", "lib/document.js", "lib/tar-strip.js", "lib/tar-exclude.js",
+  "usr/share/doc/buninu-linux/tar.md",
+];
+const shell = "buninu/apps/bunmsh/";
+
+function addTree(files, directory, prefix) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name), target = prefix + entry.name;
+    if (entry.isDirectory()) addTree(files, path, target + "/");
+    else files.set(target, readFileSync(path)); // Resolve library/source symlinks.
+  }
+}
+
+export function localSeed(arch) {
+  const files = new Map();
+  for (const path of tools) files.set(path, readFileSync("/" + path));
+  addTree(files, "/" + shell, shell);
+  for (const name of ["libgcc_s.so.1", "libstdc++.so.6"]) {
+    let bytes;
+    try { bytes = readFileSync("/lib/" + name); }
+    catch (error) { if (error.code !== "ENOENT") throw error; bytes = readFileSync("/usr/lib/" + name); }
+    files.set("usr/lib/" + name, bytes);
+  }
+  files.set(`lib/ld-musl-${arch}.so.1`, readFileSync(`/lib/ld-musl-${arch}.so.1`));
+  files.set("bin/bun", readFileSync("/bin/bun"));
+  files.set("etc/resolv.conf", readFileSync("/etc/resolv.conf"));
+  return files;
+}
+
+export async function releaseSeed(arch, work) {
+  const tarball = await download("buninu-linux@0.9.56");
+  // Bun's archive reader works in-process; no host tar is required.
+  const entries = await new Bun.Archive(readFileSync(tarball)).files();
+  const get = async name => {
+    const file = entries.get("package/" + name);
+    if (!file) throw new Error(`Pinned buninu-linux tarball is missing ${name}`);
+    return Buffer.from(await file.arrayBuffer());
+  };
+  const files = new Map();
+  for (const path of tools) files.set(path, await get("initramfs/" + path));
+  for (const [name, file] of entries) {
+    const prefix = "package/initramfs/";
+    if (name.startsWith(prefix + shell)) files.set(name.slice(prefix.length), Buffer.from(await file.arrayBuffer()));
+  }
+  for (const name of ["libgcc_s.so.1", "libstdc++.so.6"]) {
+    files.set("usr/lib/" + name, await get(`native/${arch}/lib/${name}`));
+  }
+  const loader = `ld-musl-${arch}.so.1`;
+  files.set("lib/" + loader, await get(`native/${arch}/lib/${loader}`));
+  files.set("etc/resolv.conf", await get("initramfs/etc/resolv.conf"));
+
+  console.log("② Extracting pinned musl-bun");
+  const build = arch === "aarch64" ? "bun-linux-aarch64-musl" : "bun-linux-x64-musl-baseline";
+  const zip = await download(`${build}@1.4.2`);
+  // unzip is a CLI with top-level process.exit; invoke it separately.
+  for (const path of ["bin/unzip", "lib/crc32.js"]) write(join(work, path), files.get(path));
+  await run([bun(), join(work, "bin/unzip"), zip, `${build}/bun`, "-d", work]);
+  files.set("bin/bun", readFileSync(join(work, build, "bun")));
+  return files;
+}
+
+export function validateSeed(files, arch) {
+  const loader = `lib/ld-musl-${arch}.so.1`;
+  for (const name of ["bin/bun", loader, "usr/lib/libgcc_s.so.1", "usr/lib/libstdc++.so.6"]) {
+    validateElf(name, files.get(name), arch);
+  }
+  if (elfInterpreter(files.get("bin/bun")) !== "/" + loader) throw new Error("Bun must use the target musl loader");
+  for (const name of ["index.js", "package.json", "src/main.js"]) {
+    if (!files.has(shell + name)) throw new Error(`Missing bunmsh ${name}`);
+  }
+  for (const name of files.keys()) {
+    if (name.includes("\\") || name.includes("\0") || name.split("/").some(p => ["", ".", ".."].includes(p))) {
+      throw new Error(`Unsafe seed path: ${name}`);
+    }
+  }
+}
+
+export function writeSeed(root, arch, files, origin) {
+  mkdirSync(root);
+  for (const name of ["bin", "lib", "etc", "usr/lib", "usr/bin", "tmp", "root", "dev", "proc", "sys", "run"]) {
+    mkdirSync(join(root, name), { recursive: true });
+  }
+  for (const [name, bytes] of files) {
+    const executable = name.startsWith("bin/") || name.startsWith("usr/bin/")
+      || name === shell + "index.js" || /\.so\.[16]$/.test(name);
+    write(join(root, name), bytes, executable ? 0o755 : 0o644);
+  }
+  chmodSync(join(root, "tmp"), 0o1777);
+  write(join(root, "bin/sh"), `#!/bin/bun
+// Guest entry shell; build stages use their own shell and explicit PATH.
+const paths = [
+  "/bootstrap/result/bin",
+  "/bootstrap/toolchain/bin",
+  ...(process.env.PATH || "/bin:/usr/bin").split(":"),
+];
+process.env.PATH = [...new Set(paths)].join(":");
+await import("/buninu/apps/bunmsh/src/main.js");
+`, 0o755);
+  symlinkSync(`../../lib/ld-musl-${arch}.so.1`, join(root, "usr/lib/libc.so"));
+  symlinkSync("libgcc_s.so.1", join(root, "usr/lib/libgcc_s.so"));
+  symlinkSync("libc.so", join(root, "usr/lib/libm.so"));
+  write(join(root, "etc/buninu-bootstrap.json"), JSON.stringify({ format: 1, arch, origin }, null, 2) + "\n");
+}
+
+const sources = [
+  ["musl-1.2.6.tar.gz", "d585fd3b613c66151fc3249e8ed44f77020cb5e6c1e635a616d3f9f82460512a"],
+  ["tinycc-05f0faf-upstream.tar.gz", "300d4fd6fc4a7294403e17bfd29201954410ac2baa94f189526f6bef83524c19"],
+  ["tinycc-local-bootstrap-files.tar.gz", "59216479774f3c61b06420ca9b03ad4b8dcbdbb242d2d236d2daace135e35d59"],
+];
+
+export function sourceArchives() {
+  return sources.map(([name, hash]) => {
+    const bytes = readFileSync(join(bootstrap, "sources", name));
+    if (sha256(bytes) !== hash) throw new Error(`Bundled source hash mismatch: ${name}`);
+    return new Bun.Archive(bytes);
+  });
+}
+
+export async function installSources(root, archives) {
+  const src = join(root, "bootstrap/src");
+  mkdirSync(src, { recursive: true });
+  await archives[0].extract(src);
+  renameSync(join(src, "musl-1.2.6"), join(src, "musl"));
+  await archives[1].extract(src);
+  renameSync(join(src, "tinycc-05f0faf"), join(src, "tinycc"));
+  await archives[2].extract(root);
+  // The overlay provides the cc wrapper. It becomes usable at stage 4.
+  chmodSync(join(root, "bin/cc"), 0o755);
+  // Copy the recipes/helpers, but do not duplicate the extracted tarballs.
+  const target = join(root, "bootstrap");
+  mkdirSync(target, { recursive: true });
+  const stages = readdirSync(bootstrap).filter(name => /^(?:[1-9]|1[0-2])\..*\.js$/.test(name));
+  for (const name of [...stages, "lib", "README.md", "downloads.md", "NOTICE.md", "LICENSE", "LICENSES"]) {
+    cpSync(join(bootstrap, name), join(target, name), { recursive: true, errorOnExist: true, force: false });
+  }
+}

package/initramfs/usr/lib/bootstrap/lib/startup-check.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+static int initialized;
+__attribute__((constructor)) static void init(void) { initialized = 37; }
+__attribute__((destructor)) static void fini(void) { puts("destructor OK"); }
+int main(int argc, char **argv) {
+    if (initialized != 37) return 1;
+    if (argc != 3 || strcmp(argv[1], "hello") || strcmp(argv[2], "two words")) return 2;
+    const char *value = getenv("CRT_TEST");
+    if (!value || strcmp(value,"seed-free")) return 3;
+    puts("argc/argv, environment, constructor OK");
+    return 42;
+}

package/initramfs/usr/lib/bootstrap/lib/tcc-build.js

@@ -0,0 +1,53 @@
+// Standalone TinyCC build used by stage 4 inside the target musl rootfs.
+import { chmodSync, cpSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { bun, run } from "./common.js";
+
+export async function buildTcc() {
+  const root = "/bootstrap/src/tinycc";
+  if (!["x64", "arm64"].includes(process.arch)) throw new Error("Unsupported architecture");
+  const work = "/bootstrap/build/tinycc";
+  const runtime = "/bootstrap/toolchain/lib/tcc";
+  mkdirSync(work, { recursive: true });
+  mkdirSync(runtime, { recursive: true });
+  mkdirSync("/bootstrap/toolchain/bin", { recursive: true });
+  cpSync(join(root, "include"), join(runtime, "include"), { recursive: true });
+  const stage1 = "/bootstrap/toolchain/bin/tcc";
+  const stage2 = join(work, "tcc-stage2");
+  const flags = ["-B/bootstrap/toolchain/lib/tcc", "-nostdinc", "-I/usr/include", "-I/bootstrap/toolchain/lib/tcc/include", "-L/usr/lib", "-L/lib"];
+
+  console.log("1. Build standalone TinyCC using Bun.cc");
+  await run([bun(), join(root, "bun-bootstrap.js"), join(root, "bun-tcc-cli.c"), stage1, "0"]);
+  await run([stage1, "-v"]);
+
+  if (process.arch === "x64") {
+    console.log("2. Build x64 helpers for programs compiled by cc");
+    const objects = [];
+    for (const name of ["libtcc1", "va_list"]) {
+      const object = join(work, `${name}.o`);
+      await run([stage1, ...flags, "-c", join(root, "lib", `${name}.c`), "-o", object]);
+      objects.push(object);
+    }
+    await run([stage1, "-ar", "rcs", join(runtime, "libbootstrap-tcc-x64.a"), ...objects]);
+  }
+
+  console.log("3. Rebuild TinyCC with stage1");
+  await run([stage1, ...flags, join(root, "bun-tcc-cli.c"), "-lgcc_s", "-o", stage2]);
+  const a = await Bun.file(stage1).bytes();
+  const b = await Bun.file(stage2).bytes();
+  if (!Buffer.from(a).equals(Buffer.from(b))) throw new Error("stage1/stage2 differ");
+  console.log("stage1/stage2 byte-identical: true");
+
+  if (!existsSync("/bin/cc")) throw new Error("Extract the overlay's bin/cc first");
+  chmodSync("/bin/cc", 0o755);
+  console.log("4. Compile and run the libc smoke test through cc");
+  await run(["/bin/cc", join(root, "bun-hello-libc.c"), "-o", join(work, "hello-cc")]);
+  await run([join(work, "hello-cc")]);
+  if (process.arch === "x64") {
+    console.log("5. Check x64 conversions and variadic calls");
+    await run(["/bin/cc", join(root, "bun-runtime-check.c"), "-o", join(work, "runtime-check")]);
+    await run([join(work, "runtime-check")]);
+  }
+  console.log("Ready: /bin/cc (TinyCC stage1)");
+}
+

package/initramfs/usr/share/doc/buninu-linux/bunterm.md

@@ -82,7 +82,10 @@ Every pointing device under `/dev/input/event*` is opened and an arrow is
 drawn on the screen. Clicks, drags and wheel notches reach the program as
 the xterm mouse sequences it asked for: nothing is sent unless the program
 enabled reporting (`DECSET 1000`, `1002` or `1003`), and what is sent follows
-the mode it chose, SGR (`1006`) included. `jsmdcui`, `micro`, `htop`, `vim`
+the mode it chose, including SGR cell coordinates (`1006`) and SGR pixel
+coordinates (`1016`). Mode 1016 also answers DECRQM queries; pixel positions
+exclude the framebuffer margins and preserve movement within a cell.
+CSI 14t/16t report the content and cell dimensions in those same pixel units. `jsmdcui`, `micro`, `htop`, `vim`
 and anything else that speaks the protocol work with no configuration.
 
 When the program is not reading the mouse, the wheel scrolls instead: back

package/initramfs/usr/share/doc/buninu-linux/chroot.md

@@ -11,7 +11,7 @@ every mount it made when the command exits.
 
 ```sh
 chroot NEWROOT [COMMAND [ARGUMENT...]]
-chroot [-n] [-k] [-v] NEWROOT [COMMAND [ARGUMENT...]]
+chroot [-n] [-k] [-v] [-b HOST[:GUEST]] [--shared-tmp] NEWROOT [COMMAND [ARGUMENT...]]
 chroot -h | --help
 ```
 
@@ -30,7 +30,7 @@ With no COMMAND it runs `$SHELL` if that exists inside NEWROOT, otherwise
 | `/tmp` | `tmpfs` | scratch space that does not touch the root filesystem |
 | `/etc/resolv.conf` | bind of the host's file | name resolution, without editing anything inside |
 
-A mount point that already exists as a mount is left alone. A directory that
+For automatic mounts, a destination that is already mounted is left alone. A directory that
 is missing is created; if the root filesystem is read-only and that fails,
 that one mount is skipped and the rest still happen — use `-v` to see which.
 
@@ -42,11 +42,30 @@ host's `/dev` with it.
 
 | Option | Meaning |
 |---|---|
-| `-n`, `--no-mount` | Do not mount anything: the behaviour of the traditional `chroot`. Note that Bun itself cannot start without `/proc` and `/dev/urandom`, so `-n` suits statically linked programs. |
+| `-n`, `--no-mount` | Skip automatic system mounts; explicit `-b` mounts still apply. Without binds, this is the behaviour of the traditional `chroot`. Note that Bun itself cannot start without `/proc` and `/dev/urandom`, so `-n` suits statically linked programs. |
+| `-b HOST[:GUEST]`, `--bind HOST[:GUEST]` | Bind a host directory or file into the new root; repeat for multiple paths. Without GUEST, use HOST’s absolute path inside the guest. |
+| `--shared-tmp` | Equivalent to `-b "$TMPDIR:/tmp"`; TMPDIR must be set and exist. Replaces the automatic `/tmp` tmpfs. |
 | `-k`, `--keep-mounts` | Leave the mounts in place after the command exits, to enter the same root again cheaply. Clean up later with `umount -R`. |
 | `-v`, `--verbose` | Report every mount and unmount. |
 | `--` | End of options; everything after it is NEWROOT and COMMAND. |
 
+Bind options must appear before NEWROOT. Host paths may be relative to the
+current directory; guest paths must be absolute. Missing destination directories
+and file placeholders are created. Guest symlinks are resolved relative to
+NEWROOT, including absolute symlinks. Binding over the guest root `/` is rejected.
+
+Explicit binds replace automatic mounts at or below their destination. Directories
+are bound recursively and made slave mounts, like `/dev`; files use a plain bind.
+A repeated destination uses the last argument, so a later `-b HOST:/tmp` can
+override `--shared-tmp` (and vice versa). Parent binds are applied before children.
+Explicit bind failures abort with status 125 and clean up this invocation's mounts,
+even with `-k`. Existing mounts may be covered by a new explicit bind and are
+revealed again when it is removed. Source data is shared, not copied.
+
+`--shared-tmp` only adds the bind; it does not rewrite environment variables.
+If the host's TMPDIR path is different from `/tmp`, applications in the guest may
+need `TMPDIR=/tmp` in their environment.
+
 ## Examples
 
 ```sh
@@ -63,6 +82,21 @@ chroot -v /mnt /bin/sh -c 'ls /proc | head -3'
 # Traditional behaviour: nothing is mounted for you
 chroot -n /mnt /bin/sh
 
+# Share a host directory at a different guest path
+chroot -b /home/user/project:/work /mnt /bin/sh
+
+# Share the same absolute path inside the guest
+chroot -b /home/user/project /mnt /bin/sh
+
+# Share files, or multiple paths
+chroot -b /home/user/project:/work -b /etc/hosts:/etc/hosts /mnt /bin/sh
+
+# Share the host temporary directory (including Unix sockets)
+export TMPDIR=/tmp
+chroot --shared-tmp /mnt /bin/sh
+# Equivalent explicit bind:
+chroot -b "$TMPDIR:/tmp" /mnt /bin/sh
+
 # Keep the mounts for repeated visits
 chroot -k /mnt /bin/sh -c 'true'
 chroot -k /mnt

package/package.json

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

package/scripts/npm-packages.md

@@ -1,14 +1,19 @@
 # npm packages
 # Latest versions checked on 2026-10-11; SHA-256 pins verified against registry SHA-512 integrity.
 # buninu-browser updated and verified on 2026-10-12.
+# casty 1.3.6 and buninu-land 0.1.2 verified on 2026-10-16.
 
 "buninu-browser@0.2.3":
   - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.2.3.tgz
   - sha256:0f7c9cd9df689d7b0900fdf3172851125ebd8aba12bed555be7e091d427146e8
 
-"@drxiaozhi/casty@1.3.4":
-  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.3.4.tgz
-  - sha256:1899179d173702721c2f6e8bbffab51ca3421e899ac59c58b2588cfc342fa0df
+"buninu-land@0.1.2":
+  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.1.2.tgz
+  - sha256:0b682e1d57f953d9fa9415369c320e4e35bf7575c2859673c26a0789f5369490
+
+"@drxiaozhi/casty@1.3.6":
+  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.3.6.tgz
+  - sha256:2b5f84e3a63c2c16fa92dc88faa43eec54edc2fe69154e5270af3cd9e7f472b8
 
 "@drxiaozhi/jspulse@0.2.1":
   - https://registry.npmjs.org/@drxiaozhi/jspulse/-/jspulse-0.2.1.tgz

package/test/bootstrap.test.js

@@ -0,0 +1,65 @@
+// Run with Bun inside bunproot or the Buninu Linux VM.
+import { afterAll, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  assertAbsent, bootstrap, download, hasBuninuId, normalizeArch, options,
+} from "../initramfs/usr/lib/bootstrap/lib/common.js";
+
+const work = mkdtempSync(join(tmpdir(), "bootstrap-test-"));
+afterAll(() => rmSync(work, { recursive: true, force: true }));
+
+test("architecture aliases and optional destination", () => {
+  for (const alias of ["a", "arm64", "aarch64"]) {
+    expect(options([alias])).toEqual({ arch: "aarch64", rootfs: resolve("roota") });
+  }
+  for (const alias of ["x", "x64", "x86_64", "x86-64"]) {
+    expect(options([alias])).toEqual({ arch: "x86_64", rootfs: resolve("rootx") });
+  }
+  const arch = normalizeArch(process.arch);
+  expect(options([])).toEqual({ arch, rootfs: resolve(arch === "aarch64" ? "roota" : "rootx") });
+  expect(options(["./a path's root"])).toEqual({ arch, rootfs: resolve("./a path's root") });
+  expect(options(["x", "./custom"])).toEqual({ arch: "x86_64", rootfs: resolve("custom") });
+  expect(() => options(["--arch", "x"])).toThrow();
+  expect(() => options(["x", "one", "two"])).toThrow();
+  expect(() => normalizeArch("riscv64")).toThrow();
+});
+
+test("local mode requires the exact ID, never NAME or a substring", () => {
+  for (const value of ["buninu-linux", '"buninu-linux"', "'buninu-linux'"]) {
+    expect(hasBuninuId(`NAME="Buninu Linux"\nID=${value}\n`)).toBe(true);
+  }
+  for (const text of [
+    'NAME="Buninu Linux"\nID=alpine\n',
+    'ID_LIKE=buninu-linux\n', '# ID=buninu-linux\n',
+    'ID=buninu-linux-other\n', 'ID=buninu-linux\nID=alpine\n',
+    'ID="$(echo buninu-linux)"\n',
+  ]) expect(hasBuninuId(text)).toBe(false);
+});
+
+test("existing destinations, including dangling links, are refused", () => {
+  const file = join(work, "file"), link = join(work, "link");
+  writeFileSync(file, "keep me");
+  symlinkSync("missing", link);
+  expect(() => assertAbsent(file)).toThrow("Refusing existing destination");
+  expect(() => assertAbsent(link)).toThrow("Refusing existing destination");
+  expect(() => assertAbsent(join(work, "new"))).not.toThrow();
+  expect(readFileSync(file, "utf8")).toBe("keep me");
+});
+
+test("a corrupt cached tarball is rejected before extraction or refetch", async () => {
+  const old = process.env.XDG_CACHE_HOME;
+  process.env.XDG_CACHE_HOME = work;
+  try {
+    const [url, pin] = Bun.YAML.parse(readFileSync(join(bootstrap, "downloads.md"), "utf8"))["buninu-linux@0.9.56"];
+    const cache = join(work, "buninu-bootstrap");
+    mkdirSync(cache);
+    writeFileSync(join(cache, pin.slice(7) + "-" + new URL(url).pathname.split("/").at(-1)), "corrupt");
+    await expect(download("buninu-linux@0.9.56")).rejects.toThrow("Cached file hash mismatch");
+    await expect(download("unlisted@version")).rejects.toThrow("Missing or invalid download pin");
+  } finally {
+    if (old === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = old;
+  }
+});

package/test/bunterm-pixelmouse.test.js

@@ -0,0 +1,27 @@
+import {test,expect} from 'bun:test';
+import {Terminal} from '../initramfs/lib/xterm/xterm-headless.mjs';
+import {terminalMouseEvent} from '../initramfs/lib/bunterm/pointer-report.js';
+test('bunterm negotiates 1016 and emits real pixel press, release and same-cell motion',async()=>{
+ const term=new Terminal({cols:80,rows:24,allowProposedApi:true}),out=[];term.onData(s=>out.push(s));
+ const write=s=>new Promise(r=>term.write(s,r));
+ const renderer={offsetX:5,offsetY:7,cellWidth:10,cellHeight:20};
+ const send=(x,y,action)=>term._core.coreMouseService.triggerMouseEvent(terminalMouseEvent({x,y},renderer,0,action));
+ try{
+ await write('\x1b[?1016$p');expect(out.pop()).toBe('\x1b[?1016;2$y');
+ await write('\x1b[?1003h\x1b[?1006h\x1b[?1016h\x1b[?1016$p');expect(out.pop()).toBe('\x1b[?1016;1$y');
+ send(30,68,1);expect(out.pop()).toBe('\x1b[<0;25;61M');
+ send(30,68,0);expect(out.pop()).toBe('\x1b[<0;25;61m');
+ send(31,68,32);expect(out.pop()).toBe('\x1b[<32;26;61M');
+ send(32,68,32);expect(out.pop()).toBe('\x1b[<32;27;61M');
+ await write('\x1b[?1016l\x1b[?1006h');send(30,68,1);expect(out.pop()).toBe('\x1b[<0;3;4M');
+ }finally{term.dispose();}
+});
+
+test('geometry queries use terminal content pixels and exclude framebuffer margins',async()=>{
+ const {attachGeometry}=await import('../initramfs/lib/bunterm/geometry.js');
+ const term=new Terminal({cols:80,rows:24,allowProposedApi:true}),out=[];
+ const renderer={offsetX:5,offsetY:7,cellWidth:10,cellHeight:20};
+ const handler=attachGeometry({term,renderer,reply:s=>out.push(s)});
+ try{await new Promise(r=>term.write('\x1b[14t\x1b[16t',r));expect(out).toEqual(['\x1b[4;480;800t','\x1b[6;20;10t']);}
+ finally{handler.dispose();term.dispose();}
+});

package/test/chroot-bind.test.js

@@ -0,0 +1,70 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,mkdirSync,writeFileSync,readFileSync,symlinkSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {parseChrootArguments,resolveBindings,resolveGuestPath} from '../initramfs/lib/chroot-options.js';
+
+test('chroot bind arguments expand shared tmp, repeat, and stop at NEWROOT',()=>{
+ const result=parseChrootArguments(['-n','-b','/host:/guest','--shared-tmp','--bind=/same','/root','echo','-b','unchanged'],{TMPDIR:'/host temp'});
+ expect(result.options).toMatchObject({mount:false,binds:['/host:/guest','/host temp:/tmp','/same']});
+ expect(result.positional).toEqual(['/root','echo','-b','unchanged']);
+ expect(()=>parseChrootArguments(['--shared-tmp','/root'],{})).toThrow('TMPDIR');
+ expect(()=>parseChrootArguments(['-b'])).toThrow('requires');
+ expect(()=>parseChrootArguments(['--bind='])).toThrow('requires');
+ expect(parseChrootArguments(['--','-root','sh']).positional).toEqual(['-root','sh']);
+});
+
+test('bind resolution preserves same-path destinations and confines guest symlinks',()=>{
+ const dir=mkdtempSync(join(tmpdir(),'buninu-bind-path-'));
+ try{
+  mkdirSync(join(dir,'root'));mkdirSync(join(dir,'host'));writeFileSync(join(dir,'file'),'data');
+  const binds=resolveBindings(['host','file:/etc/config','host:/tmp','file:/tmp'],dir);
+  expect(binds.find(b=>b.inside===join(dir,'host'))?.source).toBe(join(dir,'host'));
+  expect(binds.find(b=>b.inside==='/tmp')?.file).toBe(true);
+  expect(()=>resolveBindings(['host:relative'],dir)).toThrow('absolute');
+  expect(()=>resolveBindings(['host:/'],dir)).toThrow('root');
+  expect(()=>resolveBindings(['missing:/ok'],dir)).toThrow();
+  symlinkSync('/run/tmp',join(dir,'root/tmp'));
+  expect(resolveGuestPath(join(dir,'root'),'/tmp')).toBe('/run/tmp');
+  symlinkSync('../../outside',join(dir,'root/escape'));
+  expect(resolveGuestPath(join(dir,'root'),'/escape')).toBe('/outside');
+ }finally{rmSync(dir,{recursive:true,force:true});}
+});
+
+// Execute the actual CLI with recorded syscall bindings. No host mounts or
+// chroot occur; this also exercises failure cleanup and the -n interaction.
+async function invoke(argumentsFor,env={}) {
+ const dir=mkdtempSync(join(tmpdir(),'buninu-bind-cli-')),root=join(dir,'root'),host=join(dir,'host'),log=join(dir,'calls');
+ mkdirSync(root);mkdirSync(host);mkdirSync(join(dir,'fail'));writeFileSync(join(dir,'file'),'data');
+ const mock=join(dir,'libc.js');
+ writeFileSync(mock,`import {appendFileSync} from 'node:fs';
+ const record=(name,...args)=>appendFileSync(${JSON.stringify(log)},JSON.stringify([name,...args.map(a=>typeof a==='bigint'?String(a):a)])+'\\n');
+ export const ptr=x=>x,cString=x=>x,errno=()=>1,strerror=()=> 'mock mount denied',Errno={EINVAL:22,EPERM:1};
+ export const libc={symbols:{mount:(...a)=>{record('mount',...a);return a[0]?.endsWith('/fail')?-1:0;},umount2:(...a)=>{record('umount',...a);return 0;},chroot:(...a)=>{record('chroot',...a);return 0;}}};`);
+ const source=readFileSync(new URL('../initramfs/bin/chroot',import.meta.url),'utf8')
+  .replace('"../lib/dlopen.js"',JSON.stringify(mock))
+  .replace('"../lib/chroot-options.js"',JSON.stringify(new URL('../initramfs/lib/chroot-options.js',import.meta.url).pathname))
+  .replace('import { showDocument } from "../lib/document.js";','const showDocument=async()=>{};');
+ const entry=join(dir,'chroot.mjs');writeFileSync(entry,source);
+ try{
+  const child=Bun.spawn([process.execPath,entry,...argumentsFor({dir,root,host}),root,'/bin/true'],{env:{...process.env,...env,TMPDIR:host},stdout:'pipe',stderr:'pipe'});
+  const stderr=new Response(child.stderr).text();const status=await child.exited;
+  return {status,stderr:await stderr,calls:readFileSync(log,'utf8').trim().split('\n').map(JSON.parse),root,host,dir};
+ }finally{rmSync(dir,{recursive:true,force:true});}
+}
+
+test('explicit binds work with -n, create files, and unwind in reverse depth order',async()=>{
+ const r=await invoke(({dir,host})=>['-n','-b',`${host}:/work`,'-b',`${dir}/file:/work/config/file`]);
+ expect(r.status).toBe(0);
+ expect(r.calls.filter(c=>c[0]==='mount'&&c[1]===r.host)[0]).toEqual(['mount',r.host,r.root+'/work','none','20480',null]);
+ expect(r.calls.filter(c=>c[0]==='umount').map(c=>c[1])).toEqual(['/work/config/file','/work']);
+});
+test('shared tmp replaces default tmpfs and bind failure cleans up even with -k',async()=>{
+ const shared=await invoke(()=>['--shared-tmp']);expect(shared.status).toBe(0);
+ expect(shared.calls.some(c=>c[0]==='mount'&&c[1]===shared.host&&c[2]===shared.root+'/tmp')).toBe(true);
+ expect(shared.calls.some(c=>c[0]==='mount'&&c[1]==='tmpfs'&&c[2]===shared.root+'/tmp')).toBe(false);
+ const failure=await invoke(({host,dir})=>['-n','-k','-b',`${host}:/first`,'-b',`${dir}/fail:/second`]);
+ expect(failure.status).toBe(125);expect(failure.stderr).toContain('mock mount denied');
+ expect(failure.calls.some(c=>c[0]==='chroot')).toBe(false);
+ expect(failure.calls.filter(c=>c[0]==='umount').map(c=>c[1])).toEqual([failure.root+'/first']);
+});

package/test/fetch-npm.test.js

@@ -21,9 +21,9 @@ const server = Bun.serve({
 afterAll(() => { server.stop(true); rmSync(work, { recursive: true, force: true }); });
 const url = `http://127.0.0.1:${server.port}/archive`;
 
-test("four exact registry pins share an architecture-independent cache", () => {
+test("five exact registry pins share an architecture-independent cache", () => {
   expect(npmPackages.map(({ name, version }) => `${name}@${version}`)).toEqual([
-    "buninu-browser@0.2.3", "@drxiaozhi/casty@1.3.4",
+    "buninu-browser@0.2.3", "buninu-land@0.1.2", "@drxiaozhi/casty@1.3.6",
     "@drxiaozhi/jspulse@0.2.1", "@drxiaozhi/jspinyin@0.1.1",
   ]);
   expect(basename(npmDownloadsDir)).toBe("npm");

package/test/stage-npm.test.js

@@ -16,7 +16,7 @@ const fresh = () => { const dir = join(work, String(sequence++)); mkdirSync(dir)
 async function fixture() {
   const downloadsDir = fresh();
   const packages = [];
-  for (const name of ["buninu-browser", "@drxiaozhi/casty", "@drxiaozhi/jspulse", "@drxiaozhi/jspinyin"]) {
+  for (const name of ["buninu-browser", "buninu-land", "@drxiaozhi/casty", "@drxiaozhi/jspulse", "@drxiaozhi/jspinyin"]) {
     const bin = name.split("/").pop();
     const data = await new Bun.Archive({
       "package/package.json": JSON.stringify({ name, version: "1.0.0", type: "module", bin: { [bin]: "index.js" } }),
@@ -104,6 +104,39 @@ test("distribution launcher ensures resources then forwards to local casty witho
   expect(JSON.parse(result.stdout)).toEqual({ args: ["https://example.test", "--", "--chromium"], engine: join(browser, "buninu-browser.js") });
 });
 
+test("land launcher selects bundled casty and preserves package frontend dispatch", async () => {
+  const cfg = await fixture(), root = fresh();
+  stageNpm(root, cfg);
+  const land = join(root, "usr/lib/node_modules/buninu-land");
+  mkdirSync(join(root, "bin"));
+  const launcher = join(root, "bin/buninu-land");
+  copyFileSync(new URL("../initramfs/bin/buninu-land", import.meta.url), launcher);
+  writeFileSync(join(land, "index.js"), `
+    export const chooseFrontend = args => ({
+      frontend: !args.length || args[0] === '--casty' || args[0] === 'about:blank' ? 'casty' : 'other',
+      args: args[0] === '--casty' ? args.slice(1) : args,
+    });
+    if (import.meta.main) console.log(JSON.stringify({ package: true, args: process.argv.slice(2) }));
+  `);
+  writeFileSync(join(root, "usr/lib/node_modules/@drxiaozhi/casty/index.js"),
+    "console.log(JSON.stringify({args:process.argv.slice(2),engine:process.env.CASTY_BROWSER}));");
+  for (const args of [[], ['about:blank'], ['--casty', '--', '--socket=wayland-test']]) {
+    const result = spawnSync(process.execPath, [launcher, ...args], {
+      encoding: "utf8", env: { ...process.env, CASTY_BROWSER: '/previous/browser' },
+    });
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout)).toEqual({
+      args: args[0] === '--casty' ? args.slice(1) : args,
+      engine: join(land, "compositor.js"),
+    });
+  }
+  for (const args of [['--headless', '--help'], ['--help'], ['--version'], ['--docs'], ['--gtk']]) {
+    const result = spawnSync(process.execPath, [launcher, ...args], { encoding: "utf8" });
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout)).toEqual({ package: true, args });
+  }
+});
+
 test.skipIf(!npmPackages.every(pkg => existsSync(join(npmDownloadsDir, pkg.archive))))("real cached pins: JS and shell staging agree; browser headless help starts", () => {
   const js = fresh(), shell = fresh();
   stageNpm(js);
@@ -127,4 +160,12 @@ test.skipIf(!npmPackages.every(pkg => existsSync(join(npmDownloadsDir, pkg.archi
   const help = spawnSync(process.execPath, [join(js, "bin/buninu-browser"), "--headless", "--help"], { encoding: "utf8", timeout: 15000 });
   expect(help.status).toBe(0);
   expect(help.stdout).toContain("Usage");
+  copyFileSync(new URL("../initramfs/bin/buninu-land", import.meta.url), join(js, "bin/buninu-land"));
+  for (const args of [["--help"], ["--headless", "--help"], ["--version"]]) {
+    const landHelp = spawnSync(process.execPath, [join(js, "bin/buninu-land"), ...args], { encoding: "utf8", timeout: 15000 });
+    expect(landHelp.status).toBe(0);
+    expect(landHelp.stdout).toContain(args[0] === "--version" ? "0.1.2" : args[0] === "--headless" ? "Wayland compositor" : "Usage");
+  }
+  expect(existsSync(join(js, "usr/lib/node_modules/buninu-land/vendor/canvaskit/canvaskit.wasm"))).toBe(true);
+  expect(existsSync(join(js, "usr/lib/node_modules/buninu-land/LICENSES/hyprland.txt"))).toBe(true);
 }, 30000);