buninu-linux 0.3.1 → 0.5.1

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

@@ -0,0 +1,112 @@
+# bunterm — a graphical terminal on the Linux framebuffer
+
+`bunterm` runs a program on a pseudo-terminal and draws its screen on
+`/dev/fb0` with Skia (CanvasKit), so a real Linux console gets an
+xterm-compatible terminal with anti-aliased text, CJK, colour emoji, seamless
+box drawing and kitty graphics protocol images — no X11, Wayland or GPU.
+
+```sh
+bunterm                      # run /bin/sh on the console you are on
+bunterm /dev/tty1            # use virtual console 1 for graphics and keys
+bunterm --font-size 20
+bunterm -e bun /buninu/apps/jsmdcui/src/index.js --demo
+bunterm --no-mouse          # keyboard only
+bunterm -h
+```
+
+The program's `TERM` is `xterm-256color`, `COLORTERM=truecolor`,
+`TERM_PROGRAM=bunterm` and `JSMDCUI_KITTY_MODE=extended` (so `jsmdcui` shows
+Markdown images without `--kitty`). When it exits, the console returns to
+text mode and `bunterm` exits with its status.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `/dev/ttyN` | The virtual console to use for graphics and the keyboard. If another console is on screen, the display switches to this one first and back when `bunterm` exits. Without it the process's own console and stdin are used, so run it from a VT (not a serial line or a PTY). |
+| `-e command [argument...]` | The program to run; everything after `-e` belongs to it. Default `/bin/sh`. |
+| `--font-size N` | Font size in pixels (default 16). The cell is 0.6 × N wide and 1.16 × N tall with DejaVu Sans Mono, so 1024×768 at 16 px gives 106 × 41 cells. |
+| `--line-height F` | Multiplies the cell height (default 1). |
+| `--fb /dev/fbN` | The framebuffer device (default `/dev/fb0`). |
+| `--no-blink` | A steady cursor. |
+| `--no-mouse` | Do not attach a pointing device; nothing then reads `/dev/input`. |
+
+## What is drawn
+
+- **Text** comes from `/usr/share/fonts`: DejaVu Sans Mono (regular and
+  bold) sets the grid; Noto Sans CJK TC, Noto Color Emoji (+ Flags) and Noto
+  Sans Symbols fill in what it lacks. A glyph is centred in the one or two
+  cells the terminal assigned it; wide characters take two.
+- **Box drawing, block elements, shades and Powerline symbols** (U+2500–259F,
+  U+E0A0–E0BF, U+1FB70–1FB97) are drawn as vectors, ported from xterm.js, so
+  they join without seams at any size.
+- **Attributes**: 16 / 256 / 24-bit colours, bold (brighter for the eight base
+  colours), italic, dim, underline, strikethrough, inverse, invisible.
+- **Grapheme clusters** such as 🇹🇼 and 👨‍👩‍👧 occupy one cell each (xterm.js's
+  unicode-graphemes addon) and are shaped by Skia's paragraph engine.
+- **Images**: the kitty graphics protocol (`ESC _ G … ESC \`) with direct
+  transmission (`t=d`), PNG (`f=100`) or raw RGB/RGBA (`f=24`/`32`), zlib
+  (`o=z`), chunking (`m=`), cropping (`x,y,w,h`), sizing in cells (`c,r`),
+  cell offsets (`X,Y`), placements (`p=`), deletion (`a=d`) and queries
+  (`a=q`). An image is anchored to its line and scrolls with the text; on the
+  alternate screen it stays at its row and is removed when the program
+  leaves that screen. Any encoding Skia decodes (PNG, JPEG, WebP, GIF) is
+  accepted under `f=100`, as with jsgotty's `U=` extension.
+
+## Keyboard
+
+The console stays in the kernel's translated keyboard mode, so
+`Ctrl-Alt-F2` and friends still switch consoles; coming back repaints the
+screen. A few console-specific
+sequences are rewritten to xterm's (`F1`–`F5`, `Home`, `End`), and arrow keys
+follow the program's application cursor mode.
+
+## Mouse
+
+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`
+and anything else that speaks the protocol work with no configuration.
+
+When the program is not reading the mouse, the wheel scrolls instead: back
+through the scrollback on the normal screen, three lines per notch, and as
+arrow keys on the alternate screen, which has no scrollback and is what a
+pager expects. Typing returns to the live screen, and the text cursor is
+hidden while it is scrolled out of view.
+
+`--no-mouse` turns all of this off: the terminal then never looks at
+`/dev/input` and never loads the mouse module.
+
+`init.js` loads `evdev` and `psmouse` at boot, so a PS/2 mouse — which is
+what QEMU's q35 machine and most PCs present — has a device node ready. A USB
+mouse also needs the `usbhid` stack, which a `--real` image carries and
+`cfg.all` loads. The pointer follows relative devices (a mouse) and absolute
+ones (a tablet or touchscreen) alike; a device that cannot be opened is
+reported and the session continues without it.
+
+## Limits
+
+- Needs a framebuffer: `linux-lts` has one built in, while the default
+  `linux-virt` builds it as modules the image does not ship, so build with
+  `--linux-lts` or `--real` (efifb/simpledrm from UEFI).
+- No selection, and no keyboard way to scroll back: the wheel is it. The
+  buffer keeps 1000 lines. A program that does not enable mouse reporting
+  sees no clicks — the arrow still moves, so the pointer is visibly alive.
+  `--no-mouse` removes the pointer entirely.
+- A program that prints a terminal reply while the tty echoes (that is, one
+  not in raw mode) will see the reply echoed, as on any terminal.
+- Kitty images are drawn above text; `z` ordering below text and animation
+  frames are not implemented, and file transmission (`t=f`/`t=t`) works only
+  for files under `/tmp`, `/dev/shm` or `$TMPDIR`.
+- One framebuffer, one session. For panes and tabs run `jsmdcui` inside it.
+
+## See also
+
+- `/lib/bunterm/terminal.js` — `createSession()` and `runTerminal()`, the
+  pieces `bunterm` is built from
+- `/lib/canvas.js` — CanvasKit on the framebuffer (`canvas.md`)
+- `/lib/fbdev.js` — the framebuffer itself (`fbdev.md`)
+- `/buninu/apps/jsgotty/gotty.js` — the PTY backend and kitty packet parser
+  that are reused

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

@@ -0,0 +1,91 @@
+# canvas — CanvasKit (Skia) on the Linux framebuffer
+
+`/lib/canvas.js` runs Skia, compiled to WebAssembly as CanvasKit, on top of
+`/lib/fbdev.js`. Skia rasterizes straight into a buffer that already has the
+framebuffer's pixel layout, so a frame reaches `/dev/fb0` with one `memcpy`
+and no per-pixel conversion in JavaScript.
+
+## Drawing with Skia
+
+```js
+import { runGraphics } from "/lib/fbdev.js";
+import { loadCanvasKit, openCanvas, loadFontSet } from "/lib/canvas.js";
+
+const CanvasKit = await loadCanvasKit();
+const fonts = loadFontSet(CanvasKit, "ui");
+
+await runGraphics(async (display, { onRestore }) => {
+  const screen = openCanvas(CanvasKit, display);
+  const paint = new CanvasKit.Paint();
+  paint.setAntiAlias(true);
+  paint.setColor(CanvasKit.Color(64, 200, 255));
+  const font = new CanvasKit.Font(fonts.regular, 32);
+
+  screen.canvas.clear(CanvasKit.BLACK);
+  screen.canvas.drawCircle(display.width / 2, display.height / 2, 120, paint);
+  screen.canvas.drawText("Buninu 你好 😀", 40, 60, paint, font);
+  screen.flush();
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  screen.close();
+});
+```
+
+`screen.canvas` is a Skia `Canvas` with the full CanvasKit API: paths,
+gradients, shaders, image filters, `drawImage`, `drawGlyphs`, `Paragraph`
+layout with font fallback, PNG/JPEG decoding, and so on.
+
+## Exports
+
+| Export | Purpose |
+| --- | --- |
+| `loadCanvasKit()` | Loads `/lib/canvaskit/canvaskit.wasm` once per process and resolves to the `CanvasKit` object. The wasm heap starts at 128 MiB. |
+| `openCanvas(CanvasKit, display)` | Binds a raster surface to an open `Framebuffer`. Returns `{ canvas, surface, width, height, colorType, flush(), close() }`. While open, `display.pixels` is the surface's own memory, so `drawLine()`, `fillPolygon()` and `flush()` from `fbdev.js` keep working on the same frame. `close()` hands the last frame back to the JavaScript buffer. |
+| `pickColorType(CanvasKit, display)` | The Skia `ColorType` matching the framebuffer: `BGRA_8888` for the usual 32-bit XRGB (efifb, simpledrm), `RGBA_8888`, `RGB_565`; `null` for anything else, which `openCanvas` rejects. |
+| `loadFontSet(CanvasKit, name)` | A font set from `/usr/share/fonts/fonts.json` (`"terminal"` or `"ui"`) as `{ regular, bold, fallback, typefaces, fontMgr, families, delete() }`. `fontMgr` and `families` are what `ParagraphStyle` wants; a collection such as Noto Sans CJK registers every face and yields its preferred one (TC). |
+| `fontCatalogue()`, `fontPath(name)`, `loadFontData(name)` | The parsed `fonts.json`, a font's path, and its bytes (cached). |
+
+## Formats
+
+The framebuffer reports its channels as bit offsets. Skia can rasterize
+directly into three of the layouts Linux uses:
+
+| Framebuffer | Skia |
+| --- | --- |
+| 32 bpp, red@16 green@8 blue@0 (XRGB8888) | `BGRA_8888` |
+| 32 bpp, red@0 green@8 blue@16 (XBGR8888) | `RGBA_8888` |
+| 16 bpp, 5-6-5 | `RGB_565` |
+
+For a 24 bpp or paletted framebuffer, draw with the HTML canvas emulation
+instead and copy through `blitImageData()`:
+
+```js
+const canvas = CanvasKit.MakeCanvas(display.width, display.height);
+const ctx = canvas.getContext("2d");
+ctx.fillStyle = "#40c8ff";
+ctx.fillRect(0, 0, 200, 100);
+blitImageData(display, ctx.getImageData(0, 0, display.width, display.height));
+flush(display);
+```
+
+That path converts every pixel in JavaScript and is fine for static screens.
+
+## Fonts
+
+`/usr/share/fonts/fonts.json` lists the bundled files and two sets:
+
+| Set | Regular | Fallback order |
+| --- | --- | --- |
+| `terminal` | DejaVu Sans Mono (+ Bold) | Noto Color Emoji, Noto Color Emoji Flags, Noto Sans CJK, Noto Sans Symbols, Noto Sans Symbols2 |
+| `ui` | Roboto | Noto Sans CJK, Noto Color Emoji, Noto Color Emoji Flags, Noto Sans Symbols, Noto Sans Symbols2 |
+
+Files load on first use and are copied into the wasm heap; the CJK
+collection is 32 MiB, so a program that never draws CJK text should not
+load a set containing it. Each file's license sits beside it.
+
+## See also
+
+- `/lib/canvas.js`, `/lib/canvaskit/` (CanvasKit 0.41.1, BSD-3-Clause)
+- `/lib/fbdev.js` — `fbdev.md`
+- `/lib/bunterm/` — the terminal built on this (`bunterm.md`)
+- CanvasKit API: https://skia.org/docs/user/modules/canvaskit/

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

@@ -0,0 +1,105 @@
+# chroot — run a command inside another root directory
+
+`/bin/chroot` is a Bun script that calls `chroot(2)` and `mount(2)` through
+`/lib/dlopen.js`.
+
+Unlike the traditional `chroot`, it prepares the new root first, so a
+freshly unpacked root filesystem is usable straight away, and it undoes
+every mount it made when the command exits.
+
+## Synopsis
+
+```sh
+chroot NEWROOT [COMMAND [ARGUMENT...]]
+chroot [-n] [-k] [-v] NEWROOT [COMMAND [ARGUMENT...]]
+chroot -h | --help
+```
+
+With no COMMAND it runs `$SHELL` if that exists inside NEWROOT, otherwise
+`/bin/sh`, interactively when the terminal is one.
+
+## What it mounts
+
+| Inside NEWROOT | What | Why |
+|---|---|---|
+| `/proc` | a fresh `proc` | path resolution, `ps`, anything reading `/proc/self` |
+| `/sys` | a fresh `sysfs` | device and network information |
+| `/dev` | recursive bind of the host's `/dev`, made a slave mount | every device node, including `/dev/ptmx`, without a second devtmpfs |
+| `/dev/pts` | `devpts`, only if the bind brought none | pseudo-terminals for shells and editors |
+| `/run` | `tmpfs` | runtime state |
+| `/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
+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.
+
+Making `/dev` a slave mount means mounts appearing inside the root do not
+propagate back to the host, and unmounting it afterwards cannot take the
+host's `/dev` with it.
+
+## Options
+
+| 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. |
+| `-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. |
+
+## Examples
+
+```sh
+# Mount a disk and enter the system on it
+mount /dev/vda2 /mnt --mkdir
+chroot /mnt
+
+# Run one command and leave
+chroot /mnt /bin/bun --version
+
+# Watch what is set up and taken down
+chroot -v /mnt /bin/sh -c 'ls /proc | head -3'
+
+# Traditional behaviour: nothing is mounted for you
+chroot -n /mnt /bin/sh
+
+# Keep the mounts for repeated visits
+chroot -k /mnt /bin/sh -c 'true'
+chroot -k /mnt
+umount -R /mnt
+```
+
+## Cleanup
+
+When the command exits, every mount this invocation made is unmounted,
+deepest first, including anything that appeared under the recursive `/dev`
+bind. A mount that is still busy — a process left running inside, a shell
+with its working directory there — is detached instead (`MNT_DETACH`), so
+the kernel releases it once its last user goes away. The same cleanup runs
+if `chroot(2)` itself fails or the command cannot be started, and on
+`SIGTERM` or `SIGHUP`.
+
+`Ctrl-C` goes to the command, not to `chroot`, so the mounts are still
+removed after an interrupted program.
+
+## Limits
+
+- Needs to be superuser: `chroot(2)` requires `CAP_SYS_CHROOT`, and the
+  mounts require `CAP_SYS_ADMIN`. Buninu normally runs as root.
+- The new root must contain the program you ask for and whatever it links
+  against; `chroot /mnt /bin/sh` fails with "not found" if `/mnt/bin/sh`
+  is not there.
+- Only the filesystem view changes. Processes, network, users and the
+  hostname are shared with the host; this is not a container.
+- `-k` leaves mounts behind on purpose. `umount -R NEWROOT` removes them.
+
+## Exit status
+
+The command's own status, or `125` if `chroot` itself failed, `126` if the
+command was found but could not be run, and `127` if it was not found.
+
+## See also
+
+- Source: `/bin/chroot`
+- `mount --help`, `umount --help`
+- Shared native binding: `/lib/dlopen.js`

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

@@ -0,0 +1,113 @@
+# fbdev — draw directly on the Linux framebuffer
+
+`/lib/fbdev.js` is both an importable drawing module and a small executable
+demo. It uses `/dev/fb0`, framebuffer ioctls, a shared `mmap`, and `KDSETMODE`
+through Bun FFI; it does not require X11, Wayland, SDL, or a window manager.
+
+## Demo
+
+Run it on Buninu's physical Linux console:
+
+```sh
+bun /lib/fbdev.js
+```
+
+The demo switches the active console to graphics mode, clears the framebuffer,
+draws a cyan triangle, and waits. Press any key to restore text mode and exit.
+Ordinary failures, direct process exit, `SIGHUP`, `SIGINT`, `SIGQUIT`, and
+`SIGTERM` also restore the prior keyboard raw state and attempt to return the
+console to text mode.
+
+Each repeatable `-p`/`--points` supplies one polygon as x,y coordinate pairs:
+
+```sh
+bun /lib/fbdev.js -p '100,50 40,250 300,250'
+bun /lib/fbdev.js \
+  -p '100,50 40,250 300,250' \
+  -p '400,80 350,220 450,220'
+```
+
+Every occurrence draws a separate filled polygon. Comma and whitespace
+separators may be mixed inside its quoted value; the clearest form uses a
+comma within each `x,y` point and spaces between points. If one polygon
+contains an odd number of numeric values, its final unpaired value is ignored.
+A `-p` containing only one number is therefore ignored as a whole. Each
+non-empty polygon needs at least three complete points; more than three points
+remain one polygon rather than starting another. If no drawable `-p` remains,
+the demo draws its default triangle.
+
+## JavaScript API
+
+```js
+import {
+  openFramebuffer,
+  clear,
+  drawPoint,
+  drawLine,
+  drawLines,
+  fillPolygon,
+  flush,
+} from "/lib/fbdev.js";
+
+const display = openFramebuffer();
+try {
+  clear(display);
+  fillPolygon(display, [[100, 50], [40, 250], [300, 250]], {
+    r: 64, g: 200, b: 255, a: 255,
+  });
+  drawLine(display, 0, 0, display.width - 1, display.height - 1, {
+    r: 255, g: 255, b: 255,
+  });
+  flush(display);
+} finally {
+  display.close();
+}
+```
+
+The API uses short drawing names because it operates on a framebuffer rather
+than an X11 `Display`. Colours are `{ r, g, b, a }` objects.
+
+### Export reference
+
+| Export | Purpose |
+| --- | --- |
+| `Framebuffer`, `openFramebuffer(path?)` | Open and describe a packed-pixel framebuffer. |
+| `normalizePoints(values)` | Accept flat numbers, `[x,y]` arrays, or `{x,y}` objects. An unpaired flat value is ignored. |
+| `parsePoints(strings)` | Parse comma/whitespace-separated CLI-style coordinates. |
+| `drawPoint(display, x, y, color?)` | Draw one clipped pixel. |
+| `drawLine(display, x1, y1, x2, y2, color?)` | Draw a clipped Bresenham line. |
+| `drawLines(display, points, color?, close?)` | Join a sequence of points. |
+| `fillPolygon(display, points, color?)` | Fill a polygon with the even-odd scanline rule. |
+| `clear(display, color?)` | Fill the in-memory frame, black by default. |
+| `flush(display)` | Copy the in-memory frame to the shared `/dev/fb0` mapping and synchronize it. |
+| `blitImageData(display, imageData, x?, y?)` | Copy an RGBA `ImageData` (for example from CanvasKit's HTML canvas emulation) into the frame, converting to the framebuffer's format and clipping. |
+| `openConsole`, `setConsoleGraphics`, `setConsoleText` | Explicit Linux virtual-console control for callers that need it. |
+| `activeConsole(console)`, `activateConsole(console, n)`, `consoleNumber(path)` | `VT_GETSTATE` / `VT_ACTIVATE` + `VT_WAITACTIVE`, and the number in a `/dev/ttyN` path. |
+| `watchConsoleSwitches(console, onAcquire)` | `VT_SETMODE` with `VT_PROCESS`: answers the kernel's switch-away and switch-back signals and calls `onAcquire` when the display returns. Returns a function restoring automatic switching. |
+| `runGraphics(draw, { device, console, switchConsole }?)` | Open the framebuffer, put the console in graphics mode, run `await draw(display, { console, onRestore, onAcquire })`, and restore text mode however the call ends (return, throw, `process.exit()`, `SIGHUP`/`SIGINT`/`SIGQUIT`/`SIGTERM`). `console` lists console devices to try, such as `["/dev/tty1"]`; when the one opened is a `/dev/ttyN` other than the console on screen, the display is switched to it first and back afterwards (`switchConsole: false` disables this). Console switches with Ctrl-Alt-Fn keep working; `onAcquire(callback)` runs when the display comes back so the caller can repaint, and `onRestore(callback)` registers cleanup to run before text mode returns. |
+| `runDemo({ polygons, device }?)` | Run the CLI demo through `runGraphics()`. Each item in `polygons` is drawn separately. |
+
+The module supports 16-, 24-, and 32-bit packed-pixel framebuffers and uses
+the kernel-reported stride, offsets, and RGB bitfields. Paletted and unusual
+non-packed framebuffer formats are rejected rather than drawn incorrectly.
+
+## Operational limits
+
+- Run the demo from a real Linux virtual console. A PTY, serial console, SSH
+  session, or terminal pane cannot accept `KDSETMODE`.
+- The framebuffer device and active virtual console must be accessible to the
+  process; Buninu normally runs as root.
+- Imported drawing calls modify an in-memory frame until `flush()` is called.
+- Importing the module does not switch console mode. Only `runDemo()` or an
+  explicit `setConsoleGraphics()` call does so.
+- No userspace cleanup can run after `SIGKILL`, a kernel panic, power loss, or
+  a native runtime crash. If one leaves the virtual console in graphics mode,
+  switch to another VT or reboot to recover it.
+
+## See also
+
+- Source: `/lib/fbdev.js`
+- Shared native binding: `/lib/dlopen.js`
+- Skia on this framebuffer: `/lib/canvas.js` (`canvas.md`); the terminal
+  built on both: `bunterm`
+- Linux UAPI: `linux/fb.h` and `linux/kd.h`

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

@@ -27,7 +27,7 @@ Use `-` as ARCHIVE to read from standard input or write to standard output.
 | `-C DIR`, `--directory=DIR` | Read input files from DIR, or extract into DIR. |
 | `-z`, `--gzip` | Create gzip-compressed tar, or explicitly identify gzip input. |
 | `--zstd` | Create or read a zstd-compressed tar. A `.zst` or `.tzst` input is also detected by name. |
-| `-v` | Print names while creating/extracting; with `-t`, also show each regular file's size and modification time. |
+| `-v` | Print names while creating/extracting; with `-t`, also show each member's size, modification time, kind and link target. |
 
 Short options can be combined, for example `-xzvf` or `-czf`.
 For the traditional first option word, the leading hyphen is optional, so
@@ -42,8 +42,34 @@ tar -xzf source.tar.gz -C /tmp/source
 tar -tf source.tar.gz
 tar --zstd -cf backup.tar.zst home
 tar --zstd -xf backup.tar.zst -C /mnt/restore
+
+# An Alpine root filesystem, symbolic links and all; then enter it
+tar -xzf alpine-minirootfs-3.24.1-x86_64.tar.gz -C /mnt/alpine
+chroot /mnt/alpine
 ```
 
+## Links
+
+Extraction restores symbolic links exactly as the archive records them,
+including absolute targets such as `/bin/busybox` and targets that do not
+exist yet, and it restores hard links. This is what GNU tar does, and it is
+what an unpacked root filesystem needs: an Alpine minirootfs is 335 symbolic
+links, 306 of them absolute, and without them the result has no `/bin/sh`.
+
+`Bun.Archive` creates only the symbolic links whose target is relative and
+stays inside the extraction directory, and skips hard links entirely, so
+this command reads the archive's own headers (ustar, GNU `L`/`K` long names,
+pax `x` records) and creates the rest itself once every file is in place.
+Nothing is ever written through a link, because the links are made last.
+
+A member's own name still follows GNU tar's rule: a leading `/` is dropped
+and a name containing `..` is refused, so an archive cannot write outside
+the extraction directory.
+
+The same header scan backs listing, so `-t` reports every member —
+directories, links, devices — and not just regular files. A symbolic link
+shows its target, a hard link the file it points at.
+
 ## Current Bun.Archive limits
 
 Creation stores regular files only. Symbolic links are rejected rather than
@@ -51,11 +77,9 @@ silently archived as the wrong type; modes, ownership, hard links, and empty
 directories are not preserved. Bun 1.4.3 also requires file contents to be
 materialized in memory before archive creation.
 
-Extraction restores directories and symbolic links, but Bun 1.4.3 skips hard
-links. Listing and verbose extraction use `Archive.files()`, so they report
-regular files only. Verbose listing can show their size and modification time,
-but not the unavailable mode or owner. Bun provides gzip and zstd codecs but no xz or bzip2 codec,
-so this command does not accept `.tar.xz` or `.tar.bz2`.
+Extraction does not restore modes, ownership or timestamps. Bun provides gzip
+and zstd codecs but no xz or bzip2 codec, so this command does not accept
+`.tar.xz` or `.tar.bz2`.
 
 Appending with `-r`/`rvf` is not supported. `Bun.Archive` has no append API;
 rebuilding an existing archive through `Archive.files()` would silently lose