buninu-linux 0.7.4 → 0.7.55

package/NOTICE.md

@@ -103,83 +103,83 @@ the built image redistributes them.
 - License: GPL-2.0-only WITH Linux-syscall-note
 - See: `LICENSES/GPL-2.0.txt` and `LICENSES/Linux-syscall-note.txt`
 
-Linux 6.18.53 as packaged by Alpine Linux 3.24 from the `linux-lts` aport.
-The default build uses package `linux-virt`, version 6.18.53-r0.
-`--linux-lts` and `--real` use package `linux-lts`, version 6.18.53-r0.
+Linux 6.18.55 as packaged by Alpine Linux 3.24 from the `linux-lts` aport.
+The default build uses package `linux-virt`, version 6.18.55-r0.
+`--linux-lts` and `--real` use package `linux-lts`, version 6.18.55-r0.
 Each comes from the x86_64 or aarch64 repository to match `--arch`. All
 listed modules are the selected package's `.ko.gz` files decompressed without
 modification.
 
-- Upstream source: https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.18.53.tar.xz
+- Upstream source: https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.18.55.tar.xz
 - Alpine build recipe, configuration and patches (Corresponding Source),
-  pinned to the commit shipping 6.18.53-r0 (the same for both architectures):
-  https://gitlab.alpinelinux.org/alpine/aports/-/blob/00abeb21803f818099833e761976a578dd1c0380/main/linux-lts/APKBUILD
+  pinned to the commit shipping 6.18.55-r0 (the same for both architectures):
+  https://gitlab.alpinelinux.org/alpine/aports/-/blob/52fae6d7d56f3958f32e5bf9121a7536524b9ef4/main/linux-lts/APKBUILD
 - Packages:
-  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64/linux-virt-6.18.53-r0.apk
-  SHA-256 `cad859cc46342e18002621fdde166bf2cd520dfec5e781d241de7d13e53970d6`
-  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64/linux-lts-6.18.53-r0.apk
-  SHA-256 `8e3cfdd1d98e0e70c2e70a8c299ed3cd1e0939d60ad7bbd1da1cf241d794490b`
-  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/aarch64/linux-virt-6.18.53-r0.apk
-  SHA-256 `fea61b7fd5e72e626d771f9798df56c83db658d0e221044f06fc28aacf5a118b`
-  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/aarch64/linux-lts-6.18.53-r0.apk
-  SHA-256 `46885041022ea11afa1e07c40199c74146bf72d362368a844338af0c162e365c`
+  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64/linux-virt-6.18.55-r0.apk
+  SHA-256 `a941c15fc5db26b6692fd0140fa0970da76cb12aadf3dc8306c419f21bd39c93`
+  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64/linux-lts-6.18.55-r0.apk
+  SHA-256 `02ba9491d4cc110707de64ed03dd7e2fa5c93fdd851979c244ceb018785a9eea`
+  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/aarch64/linux-virt-6.18.55-r0.apk
+  SHA-256 `c7fb892408d7fe163a18671e5c7816752976d1c67fd17794dfba794aa0d6c1ac`
+  https://dl-cdn.alpinelinux.org/alpine/v3.24/main/aarch64/linux-lts-6.18.55-r0.apk
+  SHA-256 `31aeae56fa527b2fb4fdd4aefbd693cbec210a8cbfd4ea7597a1773b832e9f83`
 
 SHA-256 of files in the default x86_64 `linux-virt` image:
 
 ```text
-kernel/x86_64/vmlinuz-virt   3b6e001d41938fdf4fab7d87826fc40dfab733973a5ef96a14c892dbdec87502
-failover.ko                  f52f8dedf68be2a228e84d796170471c7103d88910a14e2307484fe94c4d1a11
-net_failover.ko              8fe715d813a1e795cf0b46d54fd67f6c625dfabf1a4eebfeec96ae34f8aab0b1
-virtio_net.ko                cdf49d6216ba92313d3e40f065c326d86eae654bcbb811ac53e7c2613e686f1e
+kernel/x86_64/vmlinuz-virt   fcee60bd42bdcc5f165278e092de0bb00d969843be326f7bd9a9602c2f52de9e
+failover.ko                  75d408861dd0ee89bf94753c9f2fff0f3831a6f76eaab8870d186910e6e2924b
+net_failover.ko              4db140c0f8e32a31e95f56f35af62e5279864104f57d30af0684c75e3505bdd5
+virtio_net.ko                f2867d641f808b7f5d7d4eb972c72398902589a83b48f6f7a174b844717da117
 ```
 
 SHA-256 of files in an x86_64 `--linux-lts` image:
 
 ```text
-kernel/x86_64/vmlinuz-lts   1b2ba2cad7973637f0f5589f845f7b773e73920e69d26785d2ff21c6c8995dc7
-failover.ko                 0fcd683e5023a3910bac2d2eb02eff349ce00d81b572f4a9093a0c70fc1c77f3
-net_failover.ko             613809bd8d4c283b7a2b9dba5d8466cc36f478772a86e8c89de5e792bce69207
-virtio_net.ko               1fb4ce7a0b546933b1e40d67b3570aec808307dcafead342d3f4bcd5a0523b7c
-virtio_ring.ko              eba2c109827a5d3b0e869505268a68d72cd6f2f9cc68778b66145c0503d9561f
-virtio.ko                   00d107d78dc1d47a4eea335c6d6b28026ae2c783a9b7629f2cc080bdbc8d2dc3
-virtio_pci_legacy_dev.ko    370b8ad3521cbd3934c78eacc5965b20eff29c55c7fcded023c75c5d21424841
-virtio_pci_modern_dev.ko    572d719ccad98342ebce909b8dac65ef64379c3a6c97e2d1fb38ff66950d9322
-virtio_pci.ko               e64039e30729e535b3ce9394249c79147bab27dfd20b7cf9914cd635dda95fc3
+kernel/x86_64/vmlinuz-lts   6c85e6375814c51257a3d1b21c3c4c02803231d42e42c1a3d50236bf543cbeba
+failover.ko                 b563c6734384c5c41ed1b227a221a3e7b511bca743e583dd33d6f85405a8df07
+net_failover.ko             4ee36e32ed5db502125b57d237b5db31509c7b9c9a49ca9221b704fcfcd80b1c
+virtio_net.ko               4aa2b98c0fed35be473ff22f4d3f89cb184ca13e6605dd9e8a68b5854eba7b6a
+virtio_ring.ko              ed1c704eddca74e4f68164efc62b65f8e8a8276b7ebb2eeb0185326dbd093603
+virtio.ko                   986cab65ecfce9c6291cc54598301ede8e8e2eca521a82dfbaf6dcf76ec6f8c6
+virtio_pci_legacy_dev.ko    dedd092324e5d23ac218dfa2aad3fa8bc2f0b49e54c1763423627c75a8c4e907
+virtio_pci_modern_dev.ko    855221097ff07f0981d4e9fbb4200a0628a154826f37299d1434811f21902388
+virtio_pci.ko               aee0a18cce24968d1e06c026a056e570b3039884b900385f019410a751ea8a44
 ```
 
 `--real` additionally includes the following modules from that same
 x86_64 `linux-lts` package for physical xHCI controllers and USB HID keyboards:
 
 ```text
-usb-common.ko               3c7f2f1de34cafbf64fa3528862539cbe8cd3830cd97110e8401b510835c8761
-usbcore.ko                  0fce52fd1836304d48d25ef322558f27304ea9247c5b234f8ac2ecb9d8f00597
-xhci-hcd.ko                 22e687fe561127ea4cd1aba21058cbf253d0541ccf315555004f5a94ed7ab727
-xhci-pci.ko                 82eb0ea3869da82d1762130a738f2ff3ae6d77b16670f69f7f09cff4e8f3e360
-xhci-pci-renesas.ko         07df52a6ee408723938bc8a32cb4a2bfe4cbcf014ff48d23fd7f7ab41c201f6f
-hid.ko                      fbe4561a8dd65cd26160cbe9b7c5af23c7920044771e2e08a8aee6aa71141053
-hid-generic.ko              acfda4f50e19c055e5d719ebc2b9b8f8c6c076552592dfaabccbe128a9862694
-usbhid.ko                   12d3648467db87c2904a11a076c17768d8d51c28fe8ec41046e7d961592a81f1
+usb-common.ko               38a461cdee1e8dd82985fedbd050d3a496825c5b59c66dc3305c5508c93fb0e4
+usbcore.ko                  18949ea4cab0f98846f4fea192c9ebe9892c5504f6750529a4db8c1a718fdd3b
+xhci-hcd.ko                 aed7f3e8d2f1e2d722fb625fcd68adce5212a30ce1a25a934832177594670543
+xhci-pci.ko                 8959b6c1790ac1b656308278313f78cf4fde8b811456a42579b467a8196515b8
+xhci-pci-renesas.ko         3aa013b9ca71ee5bd16b30efb1f68aa2c29ac84cf15dd92caf413f7577fc36cf
+hid.ko                      e3fecc9b96b44d1c572337a937927291c3219d43a00a357049a1285ab57f5bbe
+hid-generic.ko              a3d76a35904f26d8bb8d5bff115de12a1cb966c3e428e529767dde28c24e4421
+usbhid.ko                   6b50c4a6037fa740b3f576d5bf362bdad7aa86ebc8da5e1777e69c03ed70f703
 ```
 
 SHA-256 of files in the default aarch64 `linux-virt` image:
 
 ```text
-kernel/aarch64/vmlinuz-virt  9884ee00ecfff6a0dc9821cc9981b3aca74f741950704776b4335b1e076d96e6
-failover.ko                  61b052e5ed3ef01bc6f71d84acb79bfe8cf2e5168f625fce76630dec14bf8b99
-net_failover.ko              a0b150f46c7e9aa48156a8b94916ab65a4d8947143b381af56da677436584259
-virtio_net.ko                e9c007778d2b0a7d4986cd04b724965a01ffee05ada92f75ce13bf59bef2491c
+kernel/aarch64/vmlinuz-virt  af8ad21e222dbff8c89909e1ef7b8b7607dd58188b2f3067128aac4f646d212d
+failover.ko                  aff1648d08436515b509c3c848049e44540ff0d26afc113a496db961f6871df6
+net_failover.ko              4461014c041c8cbdfc881c0d820361014a491547b694d36425d084ab9008a33f
+virtio_net.ko                7b6e3c89d666419d336990688711c4d6b0cab91e5934a7bd99e6d8dcc5caa40b
 ```
 
 SHA-256 of files in an aarch64 `--linux-lts` image:
 
 ```text
-kernel/aarch64/vmlinuz-lts  00426cce3a4b2b4972043eeb68a3a2af5645eb7a50ca853c375e41944ac66d27
-failover.ko                 b9bea5bb0c956b58faf0f803a205dafd889bfda75e7c59d234f60e65145fbec8
-net_failover.ko             d8eb3087b75aba891e93327c6c43f37362cfe49421b7cabfd12f57a34d5c215a
-virtio_net.ko               10e73397bbb424b4bdb86781297f6fc30b13091e9a77fc7059e4861c09ef609d
-virtio_pci_legacy_dev.ko    476c6762743b9a5789200a31ee339173610f975b42e588914aabf41d8ade2958
-virtio_pci_modern_dev.ko    595618d12b67c67a0f29c406f6578d10d010024ac83014855672fd3fd695d6ed
-virtio_pci.ko               545a599cb7136a509a33cd3b52e80a8cd2bfa10668b0e766dc52872ce07d510b
+kernel/aarch64/vmlinuz-lts  6c6625bc5ba59136101414d09efbeaaed000517e654a75157f42565cec15abad
+failover.ko                 1f10c1ac74c6d35f745227899372b1b6656a3197436d9c72e0bb39a19779c3a6
+net_failover.ko             5815342b859f820adfd90ffdddde689c73f0e6fcc34efbc9ada8beabb2fd37b2
+virtio_net.ko               2ef9114dea6b40bd9d2e1460c6be94859b5527af5479928cfd90a66eff843bab
+virtio_pci_legacy_dev.ko    be6654a06cfb30f2598b184f7a2b2372314c5a5325a984b73a7ef9a3c39e7eb3
+virtio_pci_modern_dev.ko    d88219ed14678c0aba06a882d6cf43b0ad9462eeae09638b6382ba5601b5a8c4
+virtio_pci.ko               6bdafb0472d289e2ca6dfc63bf2cb2e54e1258e9c4774317ca1c7df059dfb31e
 ```
 
 ### linuxx64.efi.stub and linuxaa64.efi.stub

package/README.md

@@ -64,16 +64,23 @@
 - This guide builds a bootable `buninu-linux-<version>.img`
 - The documented build environment is Debian 13 under Termux PRoot
 - A regular Debian installation works as well.
+  * Experimental Alpine support now!
 - For a source checkout, clone into the Termux home so native Termux and PRoot
   can share it; `~` differs between them, but the absolute path is the same.
 
 ### Steps
 
-- Before anything, install Bun in Debian first:
+- Before anything, install Bun in Debian/Alpine first:
 
 ```sh
+# Debian/Ubuntu
 apt update
 apt install curl unzip
+
+# Alpine
+apk update
+apk add curl unzip bash libgcc libstdc++
+
 curl -fsSL https://bun.sh/install | bash
 ```
 
@@ -85,8 +92,12 @@ Install the build tools, enter a directory where
 you want to keep the finished image, then run the published package:
 
 ```sh
+# Debian/Ubuntu
 apt install binutils-mingw-w64-x86-64 cpio curl dosfstools fakeroot mtools parted unzip
 
+# Alpine
+apk add bash coreutils tar curl unzip parted dosfstools mtools libgcc libstdc++
+
 mkdir -p /data/data/com.termux/files/home/buninu-build
 cd /data/data/com.termux/files/home/buninu-build
 
@@ -94,7 +105,14 @@ export PATH=$HOME/.bun/bin:$PATH
 
 bun x buninu-linux --version
 
+# Debian/Ubuntu
 bun x buninu-linux -fb --real --export
+
+# Alpine
+export BUNINU_JS_CPIO=1
+export BUNINU_JS_UKI=1
+bun x buninu-linux -fb --real --export
+
 ```
 
 `--export` copies the completed `vda.img` out of bunx's package directory and
@@ -890,7 +908,7 @@ initramfs/                init.js, commands, userspace: the same for every archi
 native/<arch>/            musl and the GCC runtime (committed); bun and modules (fetched)
 ```
 
-The `--real` inputs are Alpine v3.24 `linux-lts-6.18.53-r0`, musl `1.2.6-r2`,
+The `--real` inputs are Alpine v3.24 `linux-lts-6.18.55-r0`, musl `1.2.6-r2`,
 `systemd-efistub-260.2-r0`, `libstdc++`/`libgcc` `15.2.0-r5`, and Bun 1.4.2
 `linux-x64-musl-baseline`. The aarch64 guest uses the same versions from
 Alpine's aarch64 repository and Bun's `linux-aarch64-musl`. There is no BusyBox
@@ -987,7 +1005,7 @@ The physical boot chain is firmware → the UKI stub → its embedded
 and, with the currently pinned kernel, embeds this complete command line:
 
 ```text
-console=ttyS0,115200 console=tty0 REAL_MACHINE=1 panic=0 PATH=/bin KERNEL_RELEASE=6.18.53-0-lts rdinit=/bin/bun -- -e import('/init.js')
+console=ttyS0,115200 console=tty0 REAL_MACHINE=1 panic=0 PATH=/bin KERNEL_RELEASE=6.18.55-0-lts rdinit=/bin/bun -- -e import('/init.js')
 ```
 
 Serial kernel logging is retained, while the final console makes
@@ -1011,7 +1029,7 @@ the same way). Build without `--real`; this selects Alpine `linux-virt`, omits t
 module set, and puts `ttyS0` last so serial stdio owns `/dev/console`:
 
 ```text
-console=tty0 console=ttyS0,115200 panic=0 PATH=/bin KERNEL_RELEASE=6.18.53-0-virt rdinit=/bin/bun -- -e import('/init.js')
+console=tty0 console=ttyS0,115200 panic=0 PATH=/bin KERNEL_RELEASE=6.18.55-0-virt rdinit=/bin/bun -- -e import('/init.js')
 ```
 
 Build and boot it with:
@@ -1128,7 +1146,7 @@ The default `--real` image embeds this kernel command line (shown for the
 currently pinned LTS release):
 
 ```text
-console=ttyS0,115200 console=tty0 REAL_MACHINE=1 panic=0 PATH=/bin KERNEL_RELEASE=6.18.53-0-lts rdinit=/bin/bun -- -e import('/init.js')
+console=ttyS0,115200 console=tty0 REAL_MACHINE=1 panic=0 PATH=/bin KERNEL_RELEASE=6.18.55-0-lts rdinit=/bin/bun -- -e import('/init.js')
 ```
 
 The physical display (`tty0`) is the final console and therefore owns PID 1's

package/fetch-alpine.sh

@@ -1,5 +1,8 @@
 #!/usr/bin/env bash
 set -euo pipefail
+# What this script creates is packed with its modes: the same umask as
+# PRoot and most hosts, not native Termux's 0077.
+umask 022
 
 cd "$(dirname "$0")"
 

package/fetch-bun.sh

@@ -1,5 +1,8 @@
 #!/usr/bin/env bash
 set -euo pipefail
+# What this script creates is packed with its modes: the same umask as
+# PRoot and most hosts, not native Termux's 0077.
+umask 022
 
 cd "$(dirname "$0")"
 

package/index.js

@@ -120,6 +120,10 @@ initramfs/init.js needs, -r just boots what is already there. Anything after
 -- goes to qemu-system-x86_64 or qemu-system-aarch64 verbatim (for example:
 -r -- -smp 4).
 
+With BUNINU_JS_TOOLS=1 in the environment, fetch and build are done in
+JavaScript (scripts/fetch.js, scripts/build.js) and need only node or bun:
+no Debian toolchain and no Docker.
+
 Fetch and build need the Debian toolchain from README "Build environment"
 (PRoot, a Debian or Ubuntu host, or --docker); run needs QEMU (Termux
 pkg, apt, or brew install qemu). Tools missing for the stages you picked are
@@ -250,13 +254,18 @@ function hasTool(name) {
   return false;
 }
 
-const inDocker = (stage) => useDocker && stage.flag !== "run";
+// BUNINU_JS_TOOLS=1: fetch and build run scripts/fetch.js and scripts/build.js
+// in this process instead of the shell scripts, so they need no toolchain
+// and no Docker; run is unchanged.
+const jsTools = process.env.BUNINU_JS_TOOLS === "1";
+const usesJs = (stage) => jsTools && stage.flag !== "run";
+const inDocker = (stage) => useDocker && stage.flag !== "run" && !jsTools;
 
 function checkTools(selectedStages) {
   const missing = [];
   for (const stage of selectedStages) {
     const arch = stage.flag === "run" ? runArch : buildArch;
-    for (const tool of inDocker(stage) ? ["docker"] : stage.tools(arch)) {
+    for (const tool of inDocker(stage) ? ["docker"] : usesJs(stage) ? [] : stage.tools(arch)) {
       if (!hasTool(tool)) missing.push(`${tool} (for --${stage.flag})`);
     }
   }
@@ -348,12 +357,46 @@ const stageEnv = {
   ...(real && { REAL_MACHINE: "1" }),
 };
 
+// The arch.js config for the JS stages, from the same settings as stageEnv.
+const jsConfig = async (env) => (await import("./scripts/arch.js")).config({
+  arch: env.BUNINU_ARCH,
+  flavor: env.LINUX_FLAVOR,
+  real: env.REAL_MACHINE === "1",
+  mirror: env.ALPINE_MIRROR,
+});
+
+async function runJs(stage, env) {
+  const module = stage.flag === "fetch" ? "scripts/fetch.js" : "scripts/build.js";
+  console.log(`\n==> [${stage.flag} js] ${module}`);
+  try {
+    const cfg = await jsConfig(env);
+    if (stage.flag === "fetch") await (await import("./scripts/fetch.js")).fetchAll(cfg);
+    else await (await import("./scripts/build.js")).buildAll(cfg);
+  } catch (error) {
+    fail(`${module}: ${error.message}`);
+  }
+}
+
 for (const stage of ordered) {
   // run-qemu.sh builds a missing vda.img itself, which needs the build
-  // toolchain; with Docker that has to happen in the container first.
-  if (stage.flag === "run" && useDocker && !selected.has(stages[1]) &&
+  // toolchain; with Docker that has to happen in the container first, and
+  // with BUNINU_JS_TOOLS=1 scripts/build.js writes it.
+  if (stage.flag === "run" && (useDocker || jsTools) && !selected.has(stages[1]) &&
       !existsSync(resolve(rootDir, "vda.img"))) {
-    runScript(stages[1], "build-image.sh", [], { ...stageEnv, BUNINU_ARCH: runArch });
+    if (jsTools) {
+      console.log("\n==> [build js] scripts/build.js image");
+      try {
+        (await import("./scripts/build.js")).image(await jsConfig({ ...stageEnv, BUNINU_ARCH: runArch }));
+      } catch (error) {
+        fail(`scripts/build.js: ${error.message}`);
+      }
+    } else {
+      runScript(stages[1], "build-image.sh", [], { ...stageEnv, BUNINU_ARCH: runArch });
+    }
+  }
+  if (usesJs(stage)) {
+    await runJs(stage, stageEnv);
+    continue;
   }
   for (const script of stage.scripts) {
     runScript(stage, script, stage.flag === "run" ? passthrough : [], stageEnv);

package/initramfs/bin/dd

@@ -0,0 +1,126 @@
+#!/bin/bun
+// dd — copy blocks between files.
+//
+//   dd [if=FILE] [of=FILE] [bs=N] [ibs=N] [obs=N] [count=N] [skip=N] [seek=N]
+//      [conv=notrunc,sparse,sync,fsync,fdatasync,noerror] [status=none|noxfer|progress]
+//
+// N takes c (1), w (2), b (512), K/KiB, M/MiB, G/GiB (powers of 1024) or
+// kB, MB, GB (powers of 1000), and the AxB product form, as in coreutils.
+// conv=sparse seeks over output blocks that are all zero instead of writing them.
+
+import { closeSync, fstatSync, fsyncSync, ftruncateSync, openSync, readSync, writeSync } from "node:fs";
+
+const fail = (message) => {
+  console.error(`dd: ${message}`);
+  process.exit(1);
+};
+
+const multipliers = { c: 1, w: 2, b: 512, k: 1024, K: 1024, KiB: 1024, kB: 1e3, KB: 1e3, M: 1024 ** 2, MiB: 1024 ** 2, MB: 1e6, G: 1024 ** 3, GiB: 1024 ** 3, GB: 1e9 };
+const number = (name, text) => text.split("x").reduce((product, part) => {
+  const match = /^(\d+)([a-zA-Z]*)$/.exec(part);
+  if (!match || !(match[2] in { "": 1, ...multipliers })) fail(`invalid number: '${text}' for ${name}`);
+  return product * Number(match[1]) * (multipliers[match[2]] ?? 1);
+}, 1);
+
+const options = { if: null, of: null, ibs: 512, obs: 512, count: Infinity, skip: 0, seek: 0, conv: new Set(), status: "default" };
+for (const argument of process.argv.slice(2)) {
+  if (argument === "-h" || argument === "--help") {
+    console.error("Usage: dd [if=FILE] [of=FILE] [bs=N] [count=N] [skip=N] [seek=N] [conv=notrunc,sparse,...] [status=none]");
+    process.exit(0);
+  }
+  const separator = argument.indexOf("=");
+  if (separator < 0) fail(`unrecognized operand '${argument}'`);
+  const key = argument.slice(0, separator);
+  const value = argument.slice(separator + 1);
+  if (key === "if" || key === "of") options[key] = value;
+  else if (key === "bs") options.ibs = options.obs = number(key, value);
+  else if (key === "ibs" || key === "obs" || key === "count" || key === "skip" || key === "seek") options[key] = number(key, value);
+  else if (key === "conv") for (const flag of value.split(",")) {
+    if (!["notrunc", "sparse", "sync", "fsync", "fdatasync", "noerror"].includes(flag)) fail(`invalid conversion: '${flag}'`);
+    options.conv.add(flag);
+  }
+  else if (key === "status") {
+    if (!["none", "noxfer", "progress"].includes(value)) fail(`invalid status level: '${value}'`);
+    options.status = value;
+  }
+  else if (key === "iflag" || key === "oflag") {}
+  else fail(`unrecognized operand '${argument}'`);
+}
+if (options.ibs < 1 || options.obs < 1) fail("block sizes must be positive");
+
+const input = options.if === null ? 0 : (() => {
+  try { return openSync(options.if, "r"); } catch (error) { return fail(`failed to open '${options.if}': ${error.message}`); }
+})();
+const output = options.of === null ? 1 : (() => {
+  try { return openSync(options.of, options.conv.has("notrunc") ? (() => { try { openSync(options.of, "r"); return "r+"; } catch { return "w"; } })() : "a+"); }
+  catch (error) { return fail(`failed to open '${options.of}': ${error.message}`); }
+})();
+// "a+" would append; reopen read-write so writes land at explicit positions.
+const outputFd = options.of !== null && !options.conv.has("notrunc") ? (closeSync(output), openSync(options.of, "r+")) : output;
+const inputSeekable = fstatSync(input).isFile() || fstatSync(input).isBlockDevice();
+const outputSeekable = fstatSync(outputFd).isFile() || fstatSync(outputFd).isBlockDevice();
+
+let inputPosition = inputSeekable ? options.skip * options.ibs : null;
+if (!inputSeekable && options.skip) {
+  // Pipes: read and drop skip blocks.
+  const discard = Buffer.alloc(options.ibs);
+  for (let block = 0; block < options.skip; block++) if (readSync(input, discard, 0, options.ibs, null) === 0) break;
+}
+let outputPosition = options.seek * options.obs;
+// Without notrunc the output is cut at the seek point, as dd does.
+if (options.of !== null && !options.conv.has("notrunc") && fstatSync(outputFd).isFile()) ftruncateSync(outputFd, outputPosition);
+
+const stats = { fullIn: 0, partialIn: 0, fullOut: 0, partialOut: 0, bytes: 0 };
+const started = performance.now();
+const buffer = Buffer.alloc(options.ibs);
+let pending = Buffer.alloc(0);
+let skippedTail = false;
+
+const writeBlock = (block) => {
+  if (options.conv.has("sparse") && outputSeekable && block.every((byte) => byte === 0)) {
+    outputPosition += block.length;
+    skippedTail = true;
+  } else {
+    for (let offset = 0; offset < block.length;) {
+      offset += writeSync(outputFd, block, offset, block.length - offset, outputSeekable ? outputPosition + offset : null);
+    }
+    outputPosition += block.length;
+    skippedTail = false;
+  }
+  if (block.length === options.obs) stats.fullOut++; else stats.partialOut++;
+  stats.bytes += block.length;
+};
+
+for (let blocks = 0; blocks < options.count; blocks++) {
+  let count;
+  try {
+    count = readSync(input, buffer, 0, options.ibs, inputPosition);
+  } catch (error) {
+    if (!options.conv.has("noerror")) fail(`error reading '${options.if ?? "standard input"}': ${error.message}`);
+    count = 0;
+  }
+  if (count === 0) break;
+  if (inputPosition !== null) inputPosition += count;
+  if (count === options.ibs) stats.fullIn++; else stats.partialIn++;
+  let block = buffer.subarray(0, count);
+  if (options.conv.has("sync") && count < options.ibs) block = Buffer.concat([block, Buffer.alloc(options.ibs - count)]);
+  pending = Buffer.concat([pending, block]);
+  while (pending.length >= options.obs) {
+    writeBlock(pending.subarray(0, options.obs));
+    pending = pending.subarray(options.obs);
+  }
+}
+if (pending.length) writeBlock(Buffer.from(pending));
+// A sparse run at the end still has to reach the file's length.
+if (skippedTail && fstatSync(outputFd).size < outputPosition) ftruncateSync(outputFd, outputPosition);
+if (options.conv.has("fsync") || options.conv.has("fdatasync")) fsyncSync(outputFd);
+
+if (options.status !== "none") {
+  console.error(`${stats.fullIn}+${stats.partialIn} records in\n${stats.fullOut}+${stats.partialOut} records out`);
+  if (options.status !== "noxfer") {
+    const seconds = (performance.now() - started) / 1000;
+    console.error(`${stats.bytes} bytes copied, ${seconds.toFixed(3)} s, ${(stats.bytes / Math.max(seconds, 1e-9) / 1e6).toFixed(1)} MB/s`);
+  }
+}
+if (input !== 0) closeSync(input);
+if (outputFd !== 1) closeSync(outputFd);

package/initramfs/bin/gunzip

@@ -0,0 +1,6 @@
+#!/bin/bun
+// gunzip — see /lib/gzip.js.
+
+import { run } from "../lib/gzip.js";
+
+process.exit(run("gunzip", process.argv.slice(2), { decompress: true }));

package/initramfs/bin/gzip

@@ -0,0 +1,6 @@
+#!/bin/bun
+// gzip — see /lib/gzip.js.
+
+import { run } from "../lib/gzip.js";
+
+process.exit(run("gzip", process.argv.slice(2), {}));

package/initramfs/bin/mcopy

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mcopy — see /lib/mtools.js.
+
+import { mcopy } from "../lib/mtools.js";
+
+process.exit(mcopy(process.argv.slice(2)));

package/initramfs/bin/mdir

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mdir — see /lib/mtools.js.
+
+import { mdir } from "../lib/mtools.js";
+
+process.exit(mdir(process.argv.slice(2)));

package/initramfs/bin/mkfs.fat

@@ -0,0 +1,73 @@
+#!/bin/bun
+// mkfs.fat — make a FAT32 filesystem in an image file, laid out as
+// mkfs.fat 4.2 does (see /lib/fat.js).
+//
+//   mkfs.fat [-F 32] [-n LABEL] [-h HIDDEN] [-i VOLID] [-s SECTORS_PER_CLUSTER]
+//            [--invariant] [-C] FILE [BLOCKS]
+//
+// BLOCKS (1 KiB each) sizes the filesystem; -C creates FILE with that size.
+// SOURCE_DATE_EPOCH, when set, is the volume ID and the label's time, as
+// with mkfs.fat; --invariant fixes both to mkfs.fat's constants.
+
+import { closeSync, fstatSync, ftruncateSync, openSync } from "node:fs";
+import { FatError, format } from "../lib/fat.js";
+
+const fail = (message) => {
+  console.error(`mkfs.fat: ${message}`);
+  process.exit(1);
+};
+
+const usage = () => {
+  console.error(`Usage: mkfs.fat [-F 32] [-n LABEL] [-h HIDDEN] [-i VOLID] [-s SECTORS_PER_CLUSTER] [--invariant] [-C] FILE [BLOCKS]`);
+  process.exit(1);
+};
+
+const options = { label: "NO NAME", hidden: 0, volumeId: null, invariant: false, sectorsPerCluster: undefined, create: false, quiet: false };
+const operands = [];
+const argv = process.argv.slice(2);
+const value = (index, option) => {
+  if (index + 1 >= argv.length) fail(`option ${option} requires an argument`);
+  return argv[index + 1];
+};
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  if (argument === "--help") usage();
+  else if (argument === "--invariant") options.invariant = true;
+  else if (argument === "-F") { if (value(index++, "-F") !== "32") fail("only -F 32 is supported"); }
+  else if (argument === "-n") options.label = value(index++, "-n");
+  else if (argument === "-h") options.hidden = Number(value(index++, "-h"));
+  else if (argument === "-i") options.volumeId = Number.parseInt(value(index++, "-i"), 16) >>> 0;
+  else if (argument === "-s") options.sectorsPerCluster = Number(value(index++, "-s"));
+  else if (argument === "-C") options.create = true;
+  else if (argument === "-v" || argument === "-I" || argument === "-a") {}
+  else if (argument === "-q") options.quiet = true;
+  else if (argument.startsWith("-") && argument.length > 1) fail(`unknown option ${argument}`);
+  else operands.push(argument);
+}
+if (operands.length < 1 || operands.length > 2) usage();
+const [file, blocks] = operands;
+if (options.label.length > 11) fail("label can be no longer than 11 characters");
+if (!Number.isInteger(options.hidden) || options.hidden < 0) fail(`bad number of hidden sectors: ${options.hidden}`);
+if (options.sectorsPerCluster !== undefined && ![1, 2, 4, 8, 16, 32, 64, 128].includes(options.sectorsPerCluster)) fail("bad number of sectors per cluster");
+
+let fd;
+try {
+  fd = openSync(file, options.create ? "wx" : "r+");
+} catch (error) {
+  fail(`unable to open ${file}: ${error.message}`);
+}
+try {
+  if (options.create) {
+    if (!blocks) fail("-C needs BLOCKS");
+    ftruncateSync(fd, Number(blocks) * 1024);
+  }
+  const bytes = blocks ? Number(blocks) * 1024 : fstatSync(fd).size;
+  if (!Number.isFinite(bytes) || bytes <= 0) fail(`bad size for ${file}`);
+  console.log("mkfs.fat (buninu-linux /bin/mkfs.fat)");
+  format(fd, { sectors: Math.floor(bytes / 512), label: options.label, volumeId: options.volumeId, hidden: options.hidden, invariant: options.invariant, sectorsPerCluster: options.sectorsPerCluster });
+} catch (error) {
+  if (error instanceof FatError) fail(error.message);
+  throw error;
+} finally {
+  closeSync(fd);
+}

package/initramfs/bin/mmd

@@ -0,0 +1,6 @@
+#!/bin/bun
+// mmd — see /lib/mtools.js.
+
+import { mmd } from "../lib/mtools.js";
+
+process.exit(mmd(process.argv.slice(2)));