buninu-linux 0.7.5 → 0.8.55

package/test/fetch-npm.test.js

@@ -0,0 +1,92 @@
+import { afterAll, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { download } from "../scripts/fetch.js";
+import { fetchNpm, npmDownloadsDir, npmPackages, parseNpmPins } from "../scripts/fetch-npm.js";
+
+const work = mkdtempSync(join(tmpdir(), "buninu-fetch-npm-"));
+const body = Buffer.from("isolated archive-download fixture");
+const sha256 = createHash("sha256").update(body).digest("hex");
+let requests = 0;
+const server = Bun.serve({
+  hostname: "127.0.0.1", port: 0,
+  fetch(request) {
+    requests++;
+    return new URL(request.url).pathname === "/missing"
+      ? new Response("missing", { status: 404 }) : new Response(body);
+  },
+});
+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", () => {
+  expect(npmPackages.map(({ name, version }) => `${name}@${version}`)).toEqual([
+    "buninu-browser@0.2.2", "@drxiaozhi/casty@1.3.4",
+    "@drxiaozhi/jspulse@0.2.1", "@drxiaozhi/jspinyin@0.1.1",
+  ]);
+  expect(basename(npmDownloadsDir)).toBe("npm");
+  for (const pkg of npmPackages) {
+    expect(new URL(pkg.url).hostname).toBe("registry.npmjs.org");
+    expect(pkg.url).toContain(`-${pkg.version}.tgz`);
+    expect(pkg.sha256).toMatch(/^[a-f0-9]{64}$/);
+  }
+});
+
+test("fetchNpm only delegates pinned downloads, without extracting or executing packages", async () => {
+  const calls = [];
+  const result = await fetchNpm({ downloadsDir: work, downloadFile: async (cfg, url, archive, sha256) => {
+    calls.push({ cfg, url, archive, sha256 });
+    return join(cfg.downloadsDir, archive);
+  } });
+  expect(calls).toEqual(npmPackages.map(({ url, archive, sha256 }) => ({ cfg: { downloadsDir: work }, url, archive, sha256 })));
+  expect(result).toEqual(npmPackages.map(({ archive }) => join(work, archive)));
+  for (const path of result) expect(existsSync(path)).toBe(false);
+});
+
+test("rejects malformed pins, floating versions, unsafe cache names and duplicate archives", () => {
+  const block = `"example@1.0.0":\n  - https://registry.npmjs.org/example/-/example-1.0.0.tgz\n  - sha256:${sha256}`;
+  for (const [from, to] of [["@1.0.0", "@latest"], ["@1.0.0", "@^1.0.0"], ["example@", "../bad@"], ["registry.npmjs.org", "example.invalid"], [sha256, "bad"], ['"example@1.0.0"', "example@1.0.0"]]) {
+    expect(() => parseNpmPins(block.replace(from, to))).toThrow();
+  }
+  expect(() => parseNpmPins(`${block}\n\n${block}`)).toThrow();
+  expect(() => parseNpmPins(block.split("\n").slice(0, 2).join("\n"))).toThrow();
+  expect(() => parseNpmPins("")).toThrow();
+  expect(parseNpmPins(`# Comment\r\n\r\n${block.replaceAll("\n", "\r\n")}\r\n`)[0].archive).toBe("example-1.0.0.tgz");
+});
+
+test("the Markdown manifest is directly parseable as YAML", () => {
+  const text = readFileSync(new URL("../scripts/npm-packages.md", import.meta.url), "utf8");
+  const yaml = Bun.YAML.parse(text);
+  for (const pin of npmPackages) {
+    expect(yaml[`${pin.name}@${pin.version}`]).toEqual([pin.url, `sha256:${pin.sha256}`]);
+  }
+});
+
+test("valid cache is reused without a request; corrupt cache is repaired", async () => {
+  const archive = "cache.tgz";
+  const path = join(work, archive);
+  const before = requests;
+  await download({ downloadsDir: work }, url, archive, sha256);
+  expect(requests).toBe(before + 1);
+  expect(readFileSync(path).equals(body)).toBe(true);
+  await download({ downloadsDir: work }, url, archive, sha256);
+  expect(requests).toBe(before + 1);
+  writeFileSync(path, "corrupt");
+  await download({ downloadsDir: work }, url, archive, sha256);
+  expect(requests).toBe(before + 2);
+  expect(readFileSync(path).equals(body)).toBe(true);
+  expect(existsSync(path + ".part")).toBe(false);
+});
+
+test("hash mismatch rejects the download and never promotes the partial archive", async () => {
+  await expect(download({ downloadsDir: work }, url, "bad.tgz", "0".repeat(64))).rejects.toThrow("SHA-256");
+  expect(existsSync(join(work, "bad.tgz"))).toBe(false);
+  expect(existsSync(join(work, "bad.tgz.part"))).toBe(false);
+});
+
+test("HTTP failures do not create a final archive", async () => {
+  await expect(download({ downloadsDir: work }, `http://127.0.0.1:${server.port}/missing`, "missing.tgz", sha256)).rejects.toThrow("HTTP 404");
+  expect(existsSync(join(work, "missing.tgz"))).toBe(false);
+});

package/test/host/Dockerfile

@@ -1,11 +1,13 @@
-# The "ordinary Debian 13 machine" host-test.sh builds and boots the guests on:
-# the README's build packages for both guests, QEMU with OVMF and AAVMF, node
+# The Debian-based Bun host that host-test.sh builds and boots the guests on:
+# the README's build packages for both guests, QEMU with OVMF and AAVMF, Bun
 # to run index.js, git to clone the checkout and expect to drive the serial
 # console. Built for linux/amd64 or linux/arm64, whichever host is simulated.
-FROM debian:13-slim
+FROM oven/bun:1.4.2
+USER root
+ENTRYPOINT []
 RUN apt-get update && apt-get install -y --no-install-recommends \
       binutils-mingw-w64-x86-64 binutils-aarch64-linux-gnu cpio curl dosfstools fakeroot mtools parted unzip \
-      ca-certificates git nodejs expect \
+      ca-certificates git expect \
       qemu-system-x86 ovmf qemu-system-arm qemu-efi-aarch64 \
     && rm -rf /var/lib/apt/lists/*
 

package/test/host/boot-test.exp

@@ -1,5 +1,5 @@
 #!/usr/bin/expect -f
-# Boots vda.img with `node ./index.js -r --arch <arch>` and drives the serial
+# Boots vda.img with `bun ./index.js -r --arch <arch>` and drives the serial
 # console: the REPL, the Buninu shell, eth0, PID 1, a tmpfs mount, a fetch from
 # inside the guest and poweroff. Each step waits for the output it expects, so
 # a hang or a wrong answer fails with a message instead of racing ahead.
@@ -36,7 +36,7 @@ proc step {what line pattern} {
 
 cd $checkout
 set start [clock seconds]
-spawn node ./index.js -r --arch $arch
+spawn bun ./index.js -r --arch $arch
 
 set timeout $boot_timeout
 expect {

package/test/host/host-test.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Builds and boots both guests on a fresh Debian 13 host of either CPU, in
+# Builds and boots both guests on a fresh Debian-based Bun host of either CPU, in
 # Docker:
 #
 #   test/host/host-test.sh [amd64|arm64]
@@ -8,7 +8,7 @@
 # emulated and takes a few times longer. The container (./Dockerfile) has the
 # README's build packages and QEMU. It clones the committed HEAD of this
 # checkout, so uncommitted changes to the project are not tested, then builds
-# with the host toolchain rather than --docker and boots each guest through
+# with the default JS tools rather than nested --docker and boots each guest through
 # boot-test.exp. The exit status is 0 only when every step passed.
 #
 #   GUESTS="aarch64"         which guests to test (default: x86_64 aarch64)

package/test/host/in-container.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
-# Runs inside the container host-test.sh starts: an ordinary Debian 13 machine
+# Runs inside the container host-test.sh starts: a Debian-based Bun environment
 # of the chosen CPU. Clones the committed HEAD of the checkout mounted at
-# /repo, builds each guest with the host toolchain (no --docker), boots it
+# /repo, builds each guest with the default JS tools (no nested --docker), boots it
 # through boot-test.exp, and checks that the builds leave git status clean.
 set -euo pipefail
 
@@ -9,7 +9,7 @@ here=$(cd "$(dirname "$0")" && pwd)
 guests=${GUESTS:-x86_64 aarch64}
 kvm=no
 if [ -r /dev/kvm ] && [ -w /dev/kvm ]; then kvm=yes; fi
-echo "### host: $(uname -sm), node $(node --version), /dev/kvm: $kvm"
+echo "### host: $(uname -sm), bun $(bun --version), /dev/kvm: $kvm"
 
 git config --global --add safe.directory '*'
 git clone --quiet /repo /work
@@ -27,7 +27,7 @@ for guest in $guests; do
     echo "### $guest: fetch + build ${BUILD_FLAGS:-}"
     log=/tmp/build-$guest.log
     # BUILD_FLAGS is split on purpose: it holds flags such as --linux-lts.
-    if node ./index.js -fb --arch "$guest" ${BUILD_FLAGS:-} > "$log" 2>&1; then
+    if bun ./index.js -fb --arch "$guest" ${BUILD_FLAGS:-} > "$log" 2>&1; then
         grep -E '^==>|^Fetched|^Built|^Packed|^note' "$log" || true
     else
         echo "### FAIL: $guest build; last lines:"

package/test/js-tools-selection.test.js

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { jsToolsEnabled } from "../scripts/js-tools.js";
+
+test("JS tools default on and only explicit 0/off/false disable them", () => {
+  for (const value of [null, "", "1", "on", "true", "yes", "no", "2", " "])
+    expect(jsToolsEnabled(value)).toBe(true);
+  for (const value of ["0", "off", "false", "OFF", "False", " false ", "\t0\n"])
+    expect(jsToolsEnabled(value)).toBe(false);
+  const previous = process.env.BUNINU_JS_TOOLS;
+  try {
+    delete process.env.BUNINU_JS_TOOLS;
+    expect(jsToolsEnabled()).toBe(true);
+    process.env.BUNINU_JS_TOOLS = "off";
+    expect(jsToolsEnabled()).toBe(false);
+  } finally {
+    if (previous === undefined) delete process.env.BUNINU_JS_TOOLS;
+    else process.env.BUNINU_JS_TOOLS = previous;
+  }
+});

package/test/npm-launchers.test.js

@@ -0,0 +1,59 @@
+import { afterAll, expect, test } from "bun:test";
+import { copyFileSync, lstatSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = mkdtempSync(join(tmpdir(), "buninu-npm-launchers-"));
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+mkdirSync(join(root, "bin"));
+
+for (const [name, entry] of [["jspulse", "jspulse.js"]]) {
+  test(`${name}: physical import launcher preserves arguments, cwd, environment and exit status`, () => {
+    const source = new URL(`../initramfs/bin/${name}`, import.meta.url);
+    expect(lstatSync(source).isFile()).toBe(true);
+    expect(lstatSync(source).mode & 0o111).toBe(0o111);
+    const launcher = join(root, "bin", name);
+    copyFileSync(source, launcher);
+    const pkg = join(root, "usr/lib/node_modules/@drxiaozhi", name);
+    mkdirSync(pkg, { recursive: true });
+    writeFileSync(join(pkg, entry), `
+      console.log(JSON.stringify({args: process.argv.slice(2), cwd: process.cwd(),
+        marker: process.env.BUNINU_LAUNCHER_TEST, dir: import.meta.dir}));
+      process.exit(17);
+    `);
+    const args = ["--help", "value with spaces", "--", "-p", "4714"];
+    const result = spawnSync(process.execPath, [launcher, ...args], {
+      cwd: root, env: { ...process.env, BUNINU_LAUNCHER_TEST: "preserved" }, encoding: "utf8",
+    });
+    expect(result.status).toBe(17);
+    expect(JSON.parse(result.stdout)).toEqual({ args, cwd: root, marker: "preserved", dir: pkg });
+  });
+}
+
+test("jspinyin bypasses upstream bun x and forwards arguments to system jsmdcui with im.md", () => {
+  const source = new URL("../initramfs/bin/jspinyin", import.meta.url);
+  expect(lstatSync(source).isFile()).toBe(true);
+  expect(lstatSync(source).mode & 0o111).toBe(0o111);
+  const launcher = join(root, "bin/jspinyin");
+  copyFileSync(source, launcher);
+  const pkg = join(root, "usr/lib/node_modules/@drxiaozhi/jspinyin");
+  mkdirSync(pkg, { recursive: true });
+  writeFileSync(join(pkg, "index.js"), "throw new Error('upstream launcher must not run');");
+  writeFileSync(join(pkg, "im.md"), "# input method");
+  const system = join(root, "buninu/apps/jsmdcui/src");
+  mkdirSync(system, { recursive: true });
+  writeFileSync(join(system, "index.js"), `
+    console.log(JSON.stringify({args: process.argv.slice(2), cwd: process.cwd(),
+      marker: process.env.BUNINU_LAUNCHER_TEST, dir: import.meta.dir}));
+    process.exit(23);
+  `);
+  const args = ["--remote-debugging-port=9222", "value with spaces"];
+  const result = spawnSync(process.execPath, [launcher, ...args], {
+    cwd: root, env: { ...process.env, BUNINU_LAUNCHER_TEST: "preserved" }, encoding: "utf8",
+  });
+  expect(result.status).toBe(23);
+  expect(JSON.parse(result.stdout)).toEqual({
+    args: ["--tui", ...args, join(pkg, "im.md")], cwd: root, marker: "preserved", dir: system,
+  });
+});

package/test/stage-npm.test.js

@@ -0,0 +1,130 @@
+import { afterAll, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { stageNpm } from "../scripts/stage-npm.js";
+import { npmPackages, npmDownloadsDir } from "../scripts/fetch-npm.js";
+import { ensureBrowserResources } from "../initramfs/lib/browser-resources.js";
+
+const work = mkdtempSync(join(tmpdir(), "buninu-stage-npm-"));
+afterAll(() => rmSync(work, { recursive: true, force: true }));
+let sequence = 0;
+const fresh = () => { const dir = join(work, String(sequence++)); mkdirSync(dir); return dir; };
+
+async function fixture() {
+  const downloadsDir = fresh();
+  const packages = [];
+  for (const name of ["buninu-browser", "@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" } }),
+      "package/index.js": "#!/usr/bin/env bun\n",
+      "package/LICENSE": "keep license",
+      "package/usr/README.md": "keep resource documentation",
+      "package/usr/lib/canvaskit/data": "only browser excludes this",
+      "package/usr/share/fonts/data": "only browser excludes this",
+      "package/lib/data": "keep data",
+    }, { compress: "gzip" }).bytes();
+    const archive = bin + ".tgz";
+    writeFileSync(join(downloadsDir, archive), data);
+    packages.push({ name, version: "1.0.0", archive, sha256: createHash("sha256").update(data).digest("hex") });
+  }
+  return { downloadsDir, packages };
+}
+
+test("stages standard scoped layout, manifest, bins and browser-only exclusion", async () => {
+  const cfg = await fixture(), root = fresh();
+  stageNpm(root, cfg);
+  const lib = join(root, "usr/lib");
+  expect(JSON.parse(readFileSync(join(lib, "package.json"))).dependencies)
+    .toEqual(Object.fromEntries(cfg.packages.map(p => [p.name, p.version])));
+  for (const pkg of cfg.packages) {
+    const dir = join(lib, "node_modules", pkg.name);
+    expect(readFileSync(join(dir, "LICENSE"), "utf8")).toBe("keep license");
+    expect(existsSync(join(dir, "package"))).toBe(false);
+    expect(readFileSync(join(dir, "usr/README.md"), "utf8")).toBe("keep resource documentation");
+    expect(existsSync(join(dir, "usr/lib/canvaskit"))).toBe(pkg.name !== "buninu-browser");
+    expect(existsSync(join(dir, "usr/share/fonts"))).toBe(pkg.name !== "buninu-browser");
+    expect(statSync(join(dir, "index.js")).mode & 0o111).toBe(0o111);
+    expect(readlinkSync(join(lib, "node_modules/.bin", pkg.name.split("/").pop())))
+      .toBe(`../${pkg.name}/index.js`);
+  }
+  expect(() => stageNpm(root, cfg)).toThrow("already exists");
+});
+
+test("rejects missing/corrupt cache before writing a staging destination", async () => {
+  const cfg = await fixture(), root = fresh();
+  writeFileSync(join(cfg.downloadsDir, cfg.packages[3].archive), "corrupt");
+  expect(() => stageNpm(root, cfg)).toThrow("SHA-256 mismatch");
+  expect(existsSync(join(root, "usr"))).toBe(false);
+  rmSync(join(cfg.downloadsDir, cfg.packages[3].archive));
+  expect(() => stageNpm(root, cfg)).toThrow("fetch stage");
+});
+
+test("resource links use distinct relative destinations, repeat safely and preserve npm resources", () => {
+  const root = fresh();
+  mkdirSync(join(root, "lib/canvaskit"), { recursive: true });
+  mkdirSync(join(root, "usr/share/fonts"), { recursive: true });
+  const browser = join(root, "usr/lib/node_modules/buninu-browser");
+  mkdirSync(browser, { recursive: true });
+  ensureBrowserResources(browser, root);
+  ensureBrowserResources(browser, root);
+  for (const [local, shared] of [["usr/lib/canvaskit", "lib/canvaskit"], ["usr/share/fonts", "usr/share/fonts"]]) {
+    const link = join(browser, local), target = readlinkSync(link);
+    expect(target.startsWith("/")).toBe(false);
+    expect(resolve(link, "..", target)).toBe(join(root, shared));
+    expect(statSync(link).isDirectory()).toBe(true);
+  }
+  const fonts = join(browser, "usr/share/fonts");
+  rmSync(fonts); mkdirSync(fonts); writeFileSync(join(fonts, "custom"), "preserved");
+  ensureBrowserResources(browser, root);
+  expect(readFileSync(join(fonts, "custom"), "utf8")).toBe("preserved");
+});
+
+test("distribution launcher ensures resources then forwards to local casty without bunx", async () => {
+  const cfg = await fixture(), root = fresh();
+  stageNpm(root, cfg);
+  const browser = join(root, "usr/lib/node_modules/buninu-browser");
+  mkdirSync(join(root, "lib/canvaskit"), { recursive: true });
+  mkdirSync(join(root, "usr/share/fonts"), { recursive: true });
+  mkdirSync(join(root, "bin"));
+  copyFileSync(new URL("../initramfs/bin/buninu-browser", import.meta.url), join(root, "bin/buninu-browser"));
+  copyFileSync(new URL("../initramfs/lib/browser-resources.js", import.meta.url), join(root, "lib/browser-resources.js"));
+  writeFileSync(join(browser, "index.js"), `
+    import { statSync } from 'node:fs';
+    if (!statSync(import.meta.dir + '/usr/lib/canvaskit').isDirectory()) throw Error('missing');
+    export const chooseFrontend = args => ({ frontend: 'casty', args: args[0] === '--casty' ? args.slice(1) : args });
+  `);
+  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}));");
+  const result = spawnSync(process.execPath, [join(root, "bin/buninu-browser"), "--casty", "https://example.test", "--", "--chromium"], { encoding: "utf8" });
+  expect(result.status).toBe(0);
+  expect(JSON.parse(result.stdout)).toEqual({ args: ["https://example.test", "--", "--chromium"], engine: join(browser, "buninu-browser.js") });
+});
+
+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);
+  const result = spawnSync("bash", [join(import.meta.dir, "../scripts/stage-npm.sh"), shell], { encoding: "utf8" });
+  expect(result.status).toBe(0);
+  expect(readFileSync(join(shell, "usr/lib/package.json"), "utf8")).toBe(readFileSync(join(js, "usr/lib/package.json"), "utf8"));
+  for (const root of [js, shell]) {
+    expect(existsSync(join(root, "usr/lib/node_modules/buninu-browser/usr/README.md"))).toBe(true);
+    expect(existsSync(join(root, "usr/lib/node_modules/buninu-browser/usr/lib/canvaskit"))).toBe(false);
+    expect(existsSync(join(root, "usr/lib/node_modules/buninu-browser/usr/share/fonts"))).toBe(false);
+    for (const pkg of npmPackages) {
+      const info = JSON.parse(readFileSync(join(root, "usr/lib/node_modules", pkg.name, "package.json")));
+      expect([info.name, info.version]).toEqual([pkg.name, pkg.version]);
+    }
+  }
+  mkdirSync(join(js, "lib")); mkdirSync(join(js, "usr/share")); mkdirSync(join(js, "bin"));
+  symlinkSync(resolve(import.meta.dir, "../initramfs/lib/canvaskit"), join(js, "lib/canvaskit"));
+  symlinkSync(resolve(import.meta.dir, "../initramfs/usr/share/fonts"), join(js, "usr/share/fonts"));
+  copyFileSync(new URL("../initramfs/bin/buninu-browser", import.meta.url), join(js, "bin/buninu-browser"));
+  copyFileSync(new URL("../initramfs/lib/browser-resources.js", import.meta.url), join(js, "lib/browser-resources.js"));
+  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");
+}, 30000);

package/test/tar-strip.test.js

@@ -0,0 +1,218 @@
+import { afterAll, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { strippedName } from "../initramfs/lib/tar-strip.js";
+import { excludeMatcher } from "../initramfs/lib/tar-exclude.js";
+
+const work = mkdtempSync(join(tmpdir(), "buninu-tar-strip-"));
+const cli = join(import.meta.dir, "../initramfs/bin/tar");
+afterAll(() => rmSync(work, { recursive: true, force: true }));
+let sequence = 0;
+const run = (args, input) => spawnSync(process.execPath, [cli, ...args], { input, encoding: "utf8" });
+
+// Small ustar fixtures, including links and extension headers Bun.Archive
+// cannot create. All extraction is confined to this test's private directory.
+function tar(entries) {
+  const chunks = [];
+  for (const { name, data = "", type = "0", target = "" } of entries) {
+    const body = Buffer.from(data);
+    const header = Buffer.alloc(512);
+    header.write(name, 0, 100);
+    header.write("0000644\0", 100);
+    header.write("0000000\0", 108);
+    header.write("0000000\0", 116);
+    header.write(body.length.toString(8).padStart(11, "0") + "\0", 124);
+    header.write("00000000000\0", 136);
+    header.fill(32, 148, 156);
+    header.write(type, 156);
+    header.write(target, 157, 100);
+    header.write("ustar\0", 257);
+    header.write("00", 263);
+    const sum = header.reduce((a, b) => a + b, 0);
+    header.write(sum.toString(8).padStart(6, "0") + "\0 ", 148);
+    chunks.push(header, body, Buffer.alloc((512 - body.length % 512) % 512));
+  }
+  return Buffer.concat([...chunks, Buffer.alloc(1024)]);
+}
+
+const payload = tar([
+  { name: "top.txt", data: "skip" },
+  { name: "package/", type: "5" },
+  { name: "package/empty/", type: "5" },
+  { name: "package/lib/a.txt", data: "hello" },
+  { name: "package/hard", type: "1", target: "package/lib/a.txt" },
+  { name: "package/sym", type: "2", target: "lib/a.txt" },
+  { name: "package/absolute", type: "2", target: "/bin/busybox" },
+]);
+
+function extract(bytes, flags = ["--strip-components=1"], stdin = false) {
+  const dir = join(work, String(sequence++));
+  const archive = dir + ".tar";
+  writeFileSync(archive, bytes);
+  const result = run(["-xf", stdin ? "-" : archive, "-C", dir, ...flags], stdin ? bytes : undefined);
+  return { dir, archive, ...result };
+}
+
+test("exclude matches path boundaries, ancestors, dot paths and wildcard patterns", () => {
+  const excluded = excludeMatcher(["package/usr/", "*.map", ".wh.*"]);
+  for (const name of ["package/usr", "./package/usr/a/b", "package/lib/a.map", "package/.wh.foo"])
+    expect(excluded(name)).toBe(true);
+  for (const name of ["package/usr2/a", "package/user/a", "package/lib/a.js"])
+    expect(excluded(name)).toBe(false);
+});
+
+test("exclude works before strip, with zero strip, compression and stdin", () => {
+  const bytes = tar([
+    { name: "package/usr/deep/data", data: "excluded without a directory header" },
+    { name: "package/usr/link", type: "2", target: "/outside" },
+    { name: "package/keep[*].js", data: "keep literal name" },
+    { name: "package/usr2/data", data: "keep boundary" },
+    { name: "package/debug.map", data: "exclude repeated pattern" },
+    { name: "package/hard", type: "1", target: "package/usr/deep/data" },
+  ]);
+  for (const strip of [0, 1]) {
+    for (const input of [bytes, Bun.gzipSync(bytes), Bun.zstdCompressSync(bytes)]) {
+      const result = extract(input, [`--strip-components=${strip}`, "--exclude=package/usr", "--exclude", "*.map"], true);
+      expect(result.status).toBe(0);
+      const root = strip ? result.dir : join(result.dir, "package");
+      expect(readFileSync(join(root, "keep[*].js"), "utf8")).toBe("keep literal name");
+      expect(existsSync(join(root, "usr"))).toBe(false);
+      expect(existsSync(join(root, "hard"))).toBe(false);
+      expect(existsSync(join(root, "debug.map"))).toBe(false);
+      expect(existsSync(join(root, "usr2/data"))).toBe(true);
+    }
+  }
+});
+
+test("exclude handles listing, all excluded, member selection and missing arguments", () => {
+  const result = extract(payload, ["--exclude=*"]);
+  expect(result.status).toBe(0);
+  expect(existsSync(join(result.dir, "package"))).toBe(false);
+  const listed = run(["-tf", result.archive, "--exclude=package"]);
+  expect(listed.status).toBe(0);
+  expect(listed.stdout.trim()).toBe("top.txt");
+  const selected = extract(payload, ["--strip-components=1", "package/lib", "--exclude=package/lib"]);
+  expect(selected.status).toBe(0);
+  expect(existsSync(join(selected.dir, "lib"))).toBe(false);
+  expect(run(["-xf", "unused", "--exclude"]).status).toBe(2);
+});
+
+test("exclude skips creation subtrees and never overwrites excluded destination files", () => {
+  const source = extract(payload, []);
+  const created = join(work, "exclude-create.tar");
+  expect(run(["-cf", created, "-C", source.dir, "--exclude=package/lib", "package/lib", "top.txt"]).status).toBe(0);
+  expect(run(["-tf", created]).stdout.trim()).toBe("top.txt");
+  const dest = join(work, "exclude-existing");
+  mkdirSync(join(dest, "package/lib"), { recursive: true });
+  writeFileSync(join(dest, "package/lib/a.txt"), "original");
+  const result = run(["-xf", source.archive, "-C", dest, "--exclude=package/lib"]);
+  expect(result.status).toBe(0);
+  expect(readFileSync(join(dest, "package/lib/a.txt"), "utf8")).toBe("original");
+  expect(existsSync(join(dest, "package/hard"))).toBe(false);
+});
+
+test("strips npm prefix, preserves empty directories and both link types", () => {
+  const result = extract(payload);
+  expect(result.status).toBe(0);
+  expect(readFileSync(join(result.dir, "lib/a.txt"), "utf8")).toBe("hello");
+  expect(existsSync(join(result.dir, "top.txt"))).toBe(false);
+  expect(existsSync(join(result.dir, "package"))).toBe(false);
+  expect(statSync(join(result.dir, "empty")).isDirectory()).toBe(true);
+  expect(statSync(join(result.dir, "hard")).ino).toBe(statSync(join(result.dir, "lib/a.txt")).ino);
+  expect(readlinkSync(join(result.dir, "sym"))).toBe("lib/a.txt");
+  expect(readlinkSync(join(result.dir, "absolute"))).toBe("/bin/busybox");
+});
+
+test("space form, gzip/zstd, stdin, and member filtering before stripping", () => {
+  for (const bytes of [payload, Bun.gzipSync(payload), Bun.zstdCompressSync(payload)]) {
+    const result = extract(bytes, ["--strip-components", "2", "package/lib"], true);
+    expect(result.status).toBe(0);
+    expect(readFileSync(join(result.dir, "a.txt"), "utf8")).toBe("hello");
+    expect(existsSync(join(result.dir, "hard"))).toBe(false);
+  }
+});
+
+test("default and explicit zero preserve the original Bun.Archive layout", () => {
+  for (const flags of [[], ["--strip-components=0"]]) {
+    const result = extract(payload, flags);
+    expect(result.status).toBe(0);
+    expect(readFileSync(join(result.dir, "package/lib/a.txt"), "utf8")).toBe("hello");
+    expect(readFileSync(join(result.dir, "top.txt"), "utf8")).toBe("skip");
+    expect(readlinkSync(join(result.dir, "package/sym"))).toBe("lib/a.txt");
+  }
+});
+
+test("listing keeps original names and excessive stripping skips members", () => {
+  const result = extract(payload, ["--strip-components=99"]);
+  expect(result.status).toBe(0);
+  expect(existsSync(join(result.dir, "lib"))).toBe(false);
+  const listed = run(["-tf", result.archive, "--strip-components=1"]);
+  expect(listed.status).toBe(0);
+  expect(listed.stdout).toContain("package/lib/a.txt");
+});
+
+test("rejects malformed counts and missing arguments", () => {
+  for (const count of ["", "-1", "1.5", "abc", "9007199254740992"]) {
+    expect(run(["-xf", "unused", `--strip-components=${count}`]).status).toBe(2);
+  }
+  expect(run(["-xf", "unused", "--strip-components"]).status).toBe(2);
+});
+
+test("dot prefix counts, and GNU long names survive stripping", () => {
+  expect(strippedName("./package/a", 1)).toBe("package/a");
+  expect(strippedName("package//lib/a", 1)).toBe("lib/a");
+  const long = "x".repeat(120);
+  const result = extract(tar([
+    { name: "././@LongLink", type: "L", data: `package/${long}\0` },
+    { name: "placeholder", data: "long" },
+    { name: "./package/dot", data: "dot" },
+  ]));
+  expect(result.status).toBe(0);
+  expect(readFileSync(join(result.dir, long), "utf8")).toBe("long");
+  expect(readFileSync(join(result.dir, "package/dot"), "utf8")).toBe("dot");
+});
+
+test("refuses traversal before stripping and unsafe hardlink targets", () => {
+  for (const entries of [
+    [{ name: "../escape", data: "bad" }],
+    [{ name: "package/../escape", data: "bad" }],
+    [{ name: "package/hard", type: "1", target: "../outside" }],
+  ]) expect(extract(tar(entries)).status).toBe(2);
+});
+
+test("PAX names and forward hardlink chains use stripped destinations", () => {
+  const record = (key, value) => {
+    const tail = ` ${key}=${value}\n`;
+    let length = tail.length + 1;
+    while (String(length).length + tail.length !== length) length = String(length).length + tail.length;
+    return `${length}${tail}`;
+  };
+  const result = extract(tar([
+    { name: "package/first", type: "1", target: "package/second" },
+    { name: "package/second", type: "1", target: "package/actual" },
+    { name: "pax", type: "x", data: record("path", "package/actual") },
+    { name: "placeholder", data: "pax" },
+  ]));
+  expect(result.status).toBe(0);
+  expect(readFileSync(join(result.dir, "first"), "utf8")).toBe("pax");
+  expect(statSync(join(result.dir, "first")).ino).toBe(statSync(join(result.dir, "actual")).ino);
+});
+
+test("does not follow a pre-existing symlink parent or an archive symlink parent", () => {
+  const out = join(work, "symlink-output");
+  const outside = join(work, "outside");
+  mkdirSync(out); mkdirSync(outside);
+  symlinkSync(outside, join(out, "lib"));
+  const archive = join(work, "symlink.tar");
+  writeFileSync(archive, payload);
+  expect(run(["-xf", archive, "-C", out, "--strip-components=1"]).status).toBe(2);
+  expect(existsSync(join(outside, "a.txt"))).toBe(false);
+  const result = extract(tar([
+    { name: "package/link", type: "2", target: outside },
+    { name: "package/link/nested", type: "2", target: "anything" },
+  ]));
+  expect(result.status).toBe(2);
+  expect(existsSync(join(outside, "nested"))).toBe(false);
+});

package/test/top-memory.test.js

@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test";
+import { memoryText } from "../initramfs/lib/top-memory.js";
+
+test("used follows MemAvailable rather than subtracting all cache", () => {
+  expect(memoryText({ MemTotal: 1024000, MemFree: 102400, MemAvailable: 307200,
+    Buffers: 10240, Cached: 512000, SReclaimable: 20480 }))
+    .toBe("MiB Mem : 1000.0 total, 100.0 free, 700.0 used, 530.0 buff/cache, 300.0 available");
+});
+
+test("zero available is a real value, not a missing field", () => {
+  expect(memoryText({ MemTotal: 1024000, MemFree: 102400, MemAvailable: 0 }))
+    .toContain("1000.0 used, 0.0 buff/cache, 0.0 available");
+});
+
+test("missing available uses free conservatively and labels available n/a", () => {
+  expect(memoryText({ MemTotal: 1024000, MemFree: 102400, Cached: 512000 }))
+    .toContain("900.0 used, 500.0 buff/cache, n/a available");
+  expect(memoryText({})).toBe("MiB Mem : 0.0 total, 0.0 free, 0.0 used, 0.0 buff/cache, n/a available");
+});
+
+test("used cannot become negative with an inconsistent snapshot", () => {
+  expect(memoryText({ MemTotal: 1024, MemAvailable: 2048 })).toContain("0.0 used");
+});