buninu-linux 0.7.2 → 0.7.3

package/initramfs/buninu/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.4.18 - 2026-09-29
+
+- Sync jsgotty to 1.1.14: Kitty for Windows
+- Sync bunmsh to 0.3.10: Fix several posix/gnu/external builtin commands
+
 ## 0.4.17 - 2026-09-26
 
 - readme: Add homepage URL

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

@@ -2,6 +2,21 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.3.10] - 2026-09-29
+
+### Fixed
+
+- Match system utilities when handling multiple operands: `printf` repeats its
+  format for remaining arguments; `ln` links multiple sources into a directory;
+  `head`, `tail`, `wc`, and `cut` process each file separately; and `md5sum` and
+  `sha256sum` print one labelled digest per file. `wc` also prints a total for
+  multiple files. Reference tests compare these results with system commands.
+
+- Make `grep -r PATTERN` without an explicit path search the current directory,
+  as system `grep` does, instead of reading a locked standard-input stream.
+  Reference tests cover recursive matches, line numbers, no matches, and quiet
+  mode.
+
 ## [0.3.9] - 2026-09-22
 
 ### Fixed

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

@@ -32,8 +32,12 @@ pseudo-terminal tests.
 
 ### Grammar and execution
 
-- Background jobs (`&`), job control, coprocesses, and asynchronous command
-  lists are not implemented.
+- A final, standalone, unquoted `&` starts a single external command in the
+  background (trailing comments and newlines are allowed). Stdin is ignored;
+  stdout/stderr are inherited, and the process is exposed in `Bun.sha.procs`.
+  Background pipelines, builtins, functions, and all redirections are rejected
+  before files are opened. General asynchronous command lists, job control,
+  and coprocesses are not implemented.
 - Brace command groups, `select`, arithmetic commands, and `[[ ... ]]` are
   not implemented.
 - Functions and subshells cover practical cases but do not yet reproduce every

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

@@ -959,7 +959,8 @@ Create hard or symbolic links.
 ### Usage
 
 ```sh
-ln [-sfT] TARGET LINK
+ln [-sf] TARGET LINK
+ln [-sf] TARGET ... DIRECTORY
 ```
 
 ### Options and forms
@@ -967,6 +968,7 @@ ln [-sfT] TARGET LINK
 - `-s`: Create a symbolic link.
 - `-f`: Replace an existing destination.
 - `-T`: Treat the destination as a normal path, not a directory.
+- Multiple targets may be linked into an existing directory.
 
 ### Example
 

package/initramfs/buninu/apps/bunmsh/help/ln.md

@@ -5,7 +5,8 @@ Create hard or symbolic links.
 ### Usage
 
 ```sh
-ln [-sfT] TARGET LINK
+ln [-sf] TARGET LINK
+ln [-sf] TARGET ... DIRECTORY
 ```
 
 ### Options and forms
@@ -13,6 +14,7 @@ ln [-sfT] TARGET LINK
 - `-s`: Create a symbolic link.
 - `-f`: Replace an existing destination.
 - `-T`: Treat the destination as a normal path, not a directory.
+- Multiple targets may be linked into an existing directory.
 
 ### Example
 

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

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

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

@@ -283,7 +283,6 @@ export function tokenize(source, options = {}) {
       while (i < source.length && source[i] !== "\n") i++;
       continue;
     }
-
     const two = source.slice(i, i + 2);
     const fdDup = source.slice(i, i + 4);
     const operatorAhead =
@@ -448,6 +447,7 @@ function emptyCommand() {
 }
 
 export function parse(source) {
+  source = normalizeSource(source);
   const tokens = tokenize(source);
   const jobs = [];
   let i = 0;
@@ -513,8 +513,8 @@ export function parse(source) {
         throw new ShellSyntaxError("! requires a command", firstWord.offset);
       negate = true;
     }
-    jobs.push({ connector, pipeline, negate });
     const separator = tokens[i]?.value;
+    jobs.push({ connector, pipeline, negate, background: false });
     if (!separator) break;
     if (![";", "&&", "||"].includes(separator))
       throw new ShellSyntaxError(`unexpected operator ${separator}`, tokens[i].offset);
@@ -523,6 +523,20 @@ export function parse(source) {
     skipSemicolons();
     if (i >= tokens.length) break;
   }
+  const lastJob = jobs.at(-1);
+  const lastCommand = lastJob?.pipeline.at(-1);
+  const lastWord = lastCommand?.words.at(-1);
+  const lastToken = tokens.findLast((token) =>
+    token.type !== "op" || token.value !== ";" || source[token.offset] !== "\n");
+  if (lastWord === lastToken &&
+      lastWord?.fragments.length === 1 &&
+      lastWord.fragments[0].quote === "none" &&
+      lastWord.fragments[0].text === "&") {
+    lastCommand.words.pop();
+    if (lastCommand.words.length === 0 && lastCommand.redirects.length === 0)
+      throw new ShellSyntaxError("expected a command", lastWord.offset);
+    lastJob.background = true;
+  }
   return jobs;
 }
 
@@ -1223,33 +1237,37 @@ const builtins = {
     const format = argv[1];
     let ai = 2;
     let output = "";
-    for (let i = 0; i < format.length; i++) {
-      if (format[i] === "\\" && i + 1 < format.length) {
-        const parsed = parsePrintEscapes(format.slice(i, i + 2));
-        output += parsed.text;
-        i++;
-        continue;
-      }
-      if (format[i] !== "%") {
-        output += format[i];
-        continue;
-      }
-      if (format[i + 1] === "%") {
-        output += "%";
-        i++;
-        continue;
+    let previous;
+    do {
+      previous = ai;
+      for (let i = 0; i < format.length; i++) {
+        if (format[i] === "\\" && i + 1 < format.length) {
+          const parsed = parsePrintEscapes(format.slice(i, i + 2));
+          output += parsed.text;
+          i++;
+          continue;
+        }
+        if (format[i] !== "%") {
+          output += format[i];
+          continue;
+        }
+        if (format[i + 1] === "%") {
+          output += "%";
+          i++;
+          continue;
+        }
+        const match = /^%([0-9]*)([sdi])/.exec(format.slice(i));
+        if (!match) return result(2, "", `bunmsh: printf: unsupported format near ${format.slice(i)}\n`);
+        const width = Number(match[1] || 0);
+        const kind = match[2];
+        const value = argv[ai++] ?? (kind === "s" ? "" : "0");
+        let rendered = kind === "s" ? value : String(Number.parseInt(value, 10) || 0);
+        if (width > rendered.length)
+          rendered = (match[1]?.startsWith("0") ? "0" : " ").repeat(width - rendered.length) + rendered;
+        output += rendered;
+        i += match[0].length - 1;
       }
-      const match = /^%([0-9]*)([sdi])/.exec(format.slice(i));
-      if (!match) return result(2, "", `bunmsh: printf: unsupported format near ${format.slice(i)}\n`);
-      const width = Number(match[1] || 0);
-      const kind = match[2];
-      const value = argv[ai++] ?? (kind === "s" ? "" : "0");
-      let rendered = kind === "s" ? value : String(Number.parseInt(value, 10) || 0);
-      if (width > rendered.length)
-        rendered = (match[1]?.startsWith("0") ? "0" : " ").repeat(width - rendered.length) + rendered;
-      output += rendered;
-      i += match[0].length - 1;
-    }
+    } while (ai > previous && ai < argv.length);
     return result(0, output);
   },
   read: async (argv, state, input) => {
@@ -1821,11 +1839,19 @@ async function runHeadFallback(argv, state, input) {
     return result(1, "", "bunmsh: head: invalid line count\n");
   const operands = argv.slice(i);
   if (operands.length) {
-    try {
-      const data = await readFallbackFiles(operands, state, input);
-      if (bytesMode) return result(0, data.slice(0, count));
-      return result(0, decoder.decode(data).split(/(?<=\n)/).slice(0, count).join(""));
-    } catch (error) { return result(1, "", `bunmsh: head: ${error.message}\n`); }
+    const output = [];
+    let status = 0, stderr = "";
+    for (const operand of operands) {
+      if (operands.length > 1)
+        output.push(`${output.length ? "\n" : ""}==> ${operand} <==\n`);
+      try {
+        const data = await readFallbackFiles([operand], state, input);
+        output.push(bytesMode
+          ? data.slice(0, count)
+          : decoder.decode(data).split(/(?<=\n)/).slice(0, count).join(""));
+      } catch (error) { status = 1; stderr += `bunmsh: head: ${operand}: ${error.message}\n`; }
+    }
+    return result(status, concatBytes(output), stderr);
   }
   const reader = fallbackInput(input).getReader();
   const output = [];
@@ -1873,19 +1899,32 @@ async function runTextFilter(argv, state, input, kind) {
         reverse ||= option.includes("r"); numeric ||= option.includes("n"); unique ||= option.includes("u");
       }
     }
-    const text = decoder.decode(await readFallbackFiles(args, state, input));
-    let lines = text.split("\n");
-    const trailing = lines.at(-1) === "";
-    if (trailing) lines.pop();
     if (kind === "tail") {
-      lines = tailFromStart
-        ? lines.slice(Math.max(0, tailCount - 1))
-        : lines.slice(-tailCount);
-    } else {
-      lines.sort((a, b) => numeric ? Number(a) - Number(b) : a.localeCompare(b));
-      if (unique) lines = lines.filter((line, index) => index === 0 || line !== lines[index - 1]);
-      if (reverse) lines.reverse();
+      const operands = args.length ? args : ["-"];
+      const output = [];
+      let status = 0, stderr = "";
+      for (const operand of operands) {
+        try {
+          const text = decoder.decode(await readFallbackFiles([operand], state, input));
+          const lines = text.split("\n");
+          const trailing = lines.at(-1) === "";
+          if (trailing) lines.pop();
+          const selected = tailFromStart
+            ? lines.slice(Math.max(0, tailCount - 1))
+            : tailCount === 0 ? [] : lines.slice(-tailCount);
+          if (operands.length > 1 && (tailFromStart || tailCount !== 0))
+            output.push(`${output.length ? "\n" : ""}==> ${operand === "-" ? "standard input" : operand} <==\n`);
+          if (selected.length) output.push(`${selected.join("\n")}${trailing ? "\n" : ""}`);
+        } catch (error) { status = 1; stderr += `bunmsh: tail: ${operand}: ${error.message}\n`; }
+      }
+      return result(status, output.join(""), stderr);
     }
+    const text = decoder.decode(await readFallbackFiles(args, state, input));
+    let lines = text.split("\n");
+    if (lines.at(-1) === "") lines.pop();
+    lines.sort((a, b) => numeric ? Number(a) - Number(b) : a.localeCompare(b));
+    if (unique) lines = lines.filter((line, index) => index === 0 || line !== lines[index - 1]);
+    if (reverse) lines.reverse();
     return result(0, lines.length ? `${lines.join("\n")}\n` : "");
   } catch (error) { return result(1, "", `bunmsh: ${kind}: ${error.message}\n`); }
 }
@@ -1894,15 +1933,27 @@ async function runWcFallback(argv, state, input) {
   let flags = "", i = 1;
   while (/^-[lwc]+$/.test(argv[i] ?? "")) flags += argv[i++].slice(1);
   if (!flags) flags = "lwc";
-  try {
-    const data = await readFallbackFiles(argv.slice(i), state, input);
+  const operands = argv.slice(i);
+  const files = operands.length ? operands : ["-"];
+  const rows = [];
+  let status = 0, stderr = "";
+  let totalBytes = 0;
+  for (const operand of files) try {
+    const data = await readFallbackFiles([operand], state, input);
     const text = decoder.decode(data);
     const values = [];
     if (flags.includes("l")) values.push((text.match(/\n/g) ?? []).length);
     if (flags.includes("w")) values.push(text.trim() ? text.trim().split(/\s+/).length : 0);
     if (flags.includes("c")) values.push(data.byteLength);
-    return result(0, `${values.join(" ")}\n`);
-  } catch (error) { return result(1, "", `bunmsh: wc: ${error.message}\n`); }
+    totalBytes += data.byteLength;
+    rows.push({ values, operand });
+  } catch (error) { status = 1; stderr += `bunmsh: wc: ${operand}: ${error.message}\n`; }
+  if (operands.length > 1 && rows.length)
+    rows.push({ values: rows.reduce((total, row) => total.map((n, index) => n + row.values[index]),
+      rows[0].values.map(() => 0)), operand: "total" });
+  const width = operands.length > 1 ? String(totalBytes).length : 0;
+  return result(status, rows.map(({ values, operand }) =>
+    `${values.map((value) => String(value).padStart(width)).join(" ")}${operands.length ? ` ${operand}` : ""}\n`).join(""), stderr);
 }
 
 function expandTrSet(value) {
@@ -2007,11 +2058,14 @@ async function runTeeFallback(argv, state, input) {
 
 async function runHashFallback(argv, state, input, algorithm) {
   const operands = argv.slice(1);
-  try {
-    const data = await readFallbackFiles(operands, state, input);
+  const output = [];
+  let status = 0, stderr = "";
+  for (const operand of operands.length ? operands : ["-"]) try {
+    const data = await readFallbackFiles([operand], state, input);
     const digest = createHash(algorithm).update(data).digest("hex");
-    return result(0, `${digest}${operands.length === 1 && operands[0] !== "-" ? `  ${operands[0]}` : ""}\n`);
-  } catch (error) { return result(1, "", `bunmsh: ${algorithm}sum: ${error.message}\n`); }
+    output.push(`${digest}  ${operand}\n`);
+  } catch (error) { status = 1; stderr += `bunmsh: ${algorithm}sum: ${operand}: ${error.message}\n`; }
+  return result(status, output.join(""), stderr);
 }
 
 function runMktempFallback(argv, state) {
@@ -2173,6 +2227,8 @@ async function runGrepFallback(argv, state, input, context = {}) {
   };
 
   const operands = argv.slice(i);
+  const implicitCwd = !operands.length && flags.includes("r");
+  if (implicitCwd) operands.push(".");
   if (operands.length) {
     try {
       const files = grepFiles(operands, state, flags.includes("r"));
@@ -2181,7 +2237,8 @@ async function runGrepFallback(argv, state, input, context = {}) {
         const lines = (await Bun.file(file.path).text()).split("\n");
         if (lines.at(-1) === "") lines.pop();
         for (let line = 0; line < lines.length; line++)
-          if (processLine(lines[line], line + 1, file.shown, showLabel)) return result(0);
+          if (processLine(lines[line], line + 1,
+            implicitCwd ? file.shown.replace(/^\.\//, "") : file.shown, showLabel)) return result(0);
       }
     } catch (error) { return result(2, "", `bunmsh: grep: ${error.message}\n`); }
   } else {
@@ -2341,20 +2398,26 @@ function cutCharacterRanges(spec) {
   return ranges;
 }
 
-async function runCutFallback(argv, _state, input) {
+async function runCutFallback(argv, state, input) {
   let spec, i = 1;
   if (argv[i] === "-c") spec = argv[++i], i++;
   else if (argv[i]?.startsWith("-c")) spec = argv[i++].slice(2);
-  if (!spec || i !== argv.length) return result(1, "", "bunmsh: cut: usage: cut -c LIST\n");
+  if (!spec) return result(1, "", "bunmsh: cut: usage: cut -c LIST [FILE ...]\n");
   try {
     const ranges = cutCharacterRanges(spec);
-    const text = decoder.decode(await readFallbackInput(input));
-    const trailing = text.endsWith("\n");
-    const lines = text.split("\n");
-    if (trailing) lines.pop();
-    const output = lines.map((line) => [...line].filter((_ch, index) =>
-      ranges.some(([start, end]) => index + 1 >= start && index + 1 <= end)).join("")).join("\n");
-    return result(0, output + (trailing ? "\n" : ""));
+    const output = [];
+    let status = 0, stderr = "";
+    const operands = argv.slice(i);
+    for (const operand of operands.length ? operands : ["-"]) try {
+      const text = decoder.decode(await readFallbackFiles([operand], state, input));
+      const trailing = text.endsWith("\n");
+      const lines = text.split("\n");
+      if (trailing) lines.pop();
+      output.push(lines.map((line) => [...line].filter((_ch, index) =>
+        ranges.some(([start, end]) => index + 1 >= start && index + 1 <= end)).join("")).join("\n") +
+        (trailing ? "\n" : ""));
+    } catch (error) { status = 1; stderr += `bunmsh: cut: ${operand}: ${error.message}\n`; }
+    return result(status, output.join(""), stderr);
   } catch (error) { return result(1, "", `bunmsh: cut: ${error.message}\n`); }
 }
 
@@ -2366,24 +2429,27 @@ function runLnFallback(argv, state) {
     noTargetDirectory ||= argv[i].includes("T");
     i++;
   }
-  if (argv.length - i !== 2) return result(1, "", "bunmsh: ln: usage: ln [-sf] target link_name\n");
-  const target = nativePath(argv[i]);
-  let link = isAbsolute(nativePath(argv[i + 1]))
-    ? nativePath(argv[i + 1])
-    : resolvePath(nativePath(state.cwd), nativePath(argv[i + 1]));
-  try {
-    if (!noTargetDirectory) {
-      try {
-        if (statSync(link).isDirectory()) link = resolvePath(link, pathBasename(target));
-      } catch {}
-    }
-    if (force) try { unlinkSync(link); } catch {}
-    if (symbolic) symlinkSync(target, link); else {
-      const source = isAbsolute(target) ? target : resolvePath(nativePath(state.cwd), target);
-      linkSync(source, link);
-    }
-    return result();
-  } catch (error) { return result(1, "", `bunmsh: ln: ${error.message}\n`); }
+  if (argv.length - i < 2) return result(1, "", "bunmsh: ln: usage: ln [-sf] target... link_name\n");
+  const sources = argv.slice(i, -1);
+  const destination = nativePath(argv.at(-1));
+  const targetPath = isAbsolute(destination) ? destination : resolvePath(nativePath(state.cwd), destination);
+  let directory = false;
+  if (!noTargetDirectory) try { directory = statSync(targetPath).isDirectory(); } catch {}
+  if (sources.length > 1 && !directory)
+    return result(1, "", "bunmsh: ln: target is not a directory\n");
+  let status = 0, stderr = "";
+  for (const operand of sources) {
+    const target = nativePath(operand);
+    const link = directory ? resolvePath(targetPath, pathBasename(target)) : targetPath;
+    try {
+      if (force) try { unlinkSync(link); } catch {}
+      if (symbolic) symlinkSync(target, link); else {
+        const source = isAbsolute(target) ? target : resolvePath(nativePath(state.cwd), target);
+        linkSync(source, link);
+      }
+    } catch (error) { status = 1; stderr += `bunmsh: ln: ${operand}: ${error.message}\n`; }
+  }
+  return result(status, "", stderr);
 }
 
 function runChmodFallback(argv, state) {
@@ -3210,15 +3276,22 @@ async function runExternal(
     cmd: spawnArgv,
     cwd: nativePath(state.cwd),
     env: state.env,
-    stdin: input === null ? "inherit" : input,
-    stdout: captureStdout || stdoutSink ? "pipe" : "inherit",
-    stderr: captureStderr || runtimeOptions.stderrSink ? "pipe" : "inherit",
+    stdin: runtimeOptions.background ? "ignore" : input === null ? "inherit" : input,
+    stdout: runtimeOptions.background ? "inherit" : captureStdout || stdoutSink ? "pipe" : "inherit",
+    stderr: runtimeOptions.background ? "inherit" : captureStderr || runtimeOptions.stderrSink ? "pipe" : "inherit",
     onExit(proc, exitCode, signalCode, error) {
       runtimeOptions.onExit?.(proc, exitCode, signalCode, error);
     },
   };
   try {
     const proc = Bun.spawn(options);
+    if (runtimeOptions.background) {
+      if (!Array.isArray(Bun.sha.procs)) Bun.sha.procs = [];
+      Bun.sha.procs.push(proc);
+      proc.unref();
+      const index = Bun.sha.procs.length - 1;
+      return result(0, "", `[${index + 1}] ${proc.pid} Bun.sha.procs[${index}]\n`);
+    }
     const pipelineKillSignal = runtimeOptions.pipelineKillSignal ?? "SIGPIPE";
     // A downstream pipeline stage that closes early (for example `head -n 3`)
     // leaves nothing reading the other end of `stdoutSink`/`stderrSink` (a
@@ -3379,6 +3452,15 @@ async function runCommandArgv(
     if(argv[0] === "&")
       commandArgv = argv.slice(1) ;
   }
+
+  if (options.background && (
+    options.pipelineStage ||
+    ["command", "builtin", "__builtin", "time", "yes"].includes(commandArgv[0]) ||
+    Object.hasOwn(state.functions, commandArgv[0]) ||
+    Object.hasOwn(builtins, commandArgv[0]) ||
+    (!commandArgv[0].includes("/") && Object.hasOwn(fallbackBuiltins, commandArgv[0]) &&
+      !findExecutable(commandArgv[0], state))
+  )) return result(2, "", "bunmsh: &: only a single external command is supported\n");
   
   let commandState = state;
   if (options.pipelineStage && runsInPipelineSubprocess(commandArgv, commandState))
@@ -3674,6 +3756,7 @@ async function runCommand(command, state, options = {}) {
       stderrSink: stderrRedirect,
       onSpawn: options.onSpawn,
       onExit: options.onExit,
+      background: Boolean(options.background),
     },
   );
 
@@ -3690,10 +3773,13 @@ async function runCommand(command, state, options = {}) {
 }
 
 async function runPipeline(pipeline, state, options = {}) {
+  if (options.background && (pipeline.length !== 1 || pipeline[0].redirects.length !== 0))
+    return result(2, "", "bunmsh: &: only a single external command without redirections is supported\n");
   if (pipeline.length === 1)
     return runCommand(pipeline[0], state, {
       captureStdout: Boolean(options.capture),
       captureStderr: Boolean(options.capture),
+      background: Boolean(options.background),
     });
 
   const links = Array.from(
@@ -3876,7 +3962,10 @@ export async function execute(source, state = createState(), io = {}) {
   for (const job of jobs) {
     if (job.connector === "&&" && execution.status !== 0) continue;
     if (job.connector === "||" && execution.status === 0) continue;
-    execution = await runPipeline(job.pipeline, state, { capture: io.capture });
+    execution = await runPipeline(job.pipeline, state, {
+      capture: io.capture,
+      background: job.background,
+    });
     if (job.negate) execution.status = execution.status === 0 ? 1 : 0;
     state.lastStatus = execution.status;
     if (execution.stdout.byteLength) {

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

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readlinkSync, readdirSync, rmSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { createState, decode, execute } from "../src/shell.js";
@@ -86,6 +86,15 @@ async function expectBuiltinSedLike(args, input, cwd = root) {
   expect(actual).toEqual(reference);
 }
 
+async function expectBuiltinLikeSystem(name, args, input = "", cwd = root) {
+  const [actual, reference] = await Promise.all([
+    invokeArgvWithInput(
+      [process.execPath, join(root, "src/main.js"), "-cc", "builtin", name, ...args], input, cwd),
+    invokeArgvWithInput([Bun.which(name), ...args], input, cwd),
+  ]);
+  expect(actual).toEqual(reference);
+}
+
 describe("/bin/sh reference", () => {
   describe("quote and word expansion", () => {
     test("removes LF and CRLF backslash continuations before tokenization", async () => {
@@ -402,6 +411,79 @@ printf ':%s' $?
   });
 });
 
+describe("system multi-operand reference", () => {
+  test("printf repeats its format until all arguments are consumed", async () => {
+    await expectBuiltinLikeSystem("printf", ["%s=%d\n", "one", "1", "two", "2"]);
+    await expectBuiltinLikeSystem("printf", ["[%s][%s]\n", "one", "two", "three"]);
+  });
+
+  test("ln links each source into a target directory", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-ln-reference-"));
+    const actualDir = join(directory, "actual");
+    const systemDir = join(directory, "system");
+    try {
+      for (const cwd of [actualDir, systemDir]) {
+        mkdirSync(cwd);
+        mkdirSync(join(cwd, "hard"));
+        mkdirSync(join(cwd, "soft"));
+        await Bun.write(join(cwd, "one"), "first\n");
+        await Bun.write(join(cwd, "two"), "second\n");
+      }
+      for (const args of [["one", "two", "hard"], ["-s", "one", "two", "soft"]]) {
+        const [actual, reference] = await Promise.all([
+          invokeArgvWithInput([process.execPath, join(root, "src/main.js"), "-cc", "builtin", "ln", ...args], "", actualDir),
+          invokeArgvWithInput([Bun.which("ln"), ...args], "", systemDir),
+        ]);
+        expect(actual).toEqual(reference);
+      }
+      for (const name of ["one", "two"]) {
+        expect(readdirSync(join(actualDir, "hard"))).toEqual(readdirSync(join(systemDir, "hard")));
+        expect(statSync(join(actualDir, "hard", name)).ino).toBe(statSync(join(actualDir, name)).ino);
+        expect(readlinkSync(join(actualDir, "soft", name)))
+          .toBe(readlinkSync(join(systemDir, "soft", name)));
+      }
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("head and tail select lines independently from each file", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-parts-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha\nbeta\n");
+      await Bun.write(join(directory, "two"), "gamma\ndelta\n");
+      for (const args of [["-n", "1", "one", "two"], ["-c", "2", "one", "two"],
+        ["-n", "0", "one", "two"]])
+        await expectBuiltinLikeSystem("head", args, "", directory);
+      for (const args of [["-n", "1", "one", "two"], ["-n", "+2", "one", "two"],
+        ["-n", "0", "one", "two"]])
+        await expectBuiltinLikeSystem("tail", args, "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("wc prints each file count and a total; cut reads each file", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-text-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha beta\ngamma\n");
+      await Bun.write(join(directory, "two"), "delta\nepsilon zeta\n");
+      for (const args of [["-l", "one", "two"], ["-lwc", "one", "two"]])
+        await expectBuiltinLikeSystem("wc", args, "", directory);
+      await expectBuiltinLikeSystem("cut", ["-c", "1-3", "one", "two"], "", directory);
+      await expectBuiltinLikeSystem("cut", ["-c", "1", "one"], "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+
+  test("md5sum and sha256sum hash each file separately", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-hash-reference-"));
+    try {
+      await Bun.write(join(directory, "one"), "alpha\n");
+      await Bun.write(join(directory, "two"), "beta\n");
+      for (const name of ["md5sum", "sha256sum"]) {
+        await expectBuiltinLikeSystem(name, ["one", "two"], "", directory);
+        await expectBuiltinLikeSystem(name, [], "stdin text\n", directory);
+      }
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
+});
+
 describe("system tail reference", () => {
   test("supports -n +N and compact -n+N from-start modes", async () => {
     const input = "one\ntwo\nthree\nfour\n";
@@ -450,6 +532,18 @@ describe("system grep reference", () => {
       await expectBuiltinGrepLike(["-n", "needle", "tree/a.txt", "tree/nested/b.txt"], "", directory);
     } finally { rmSync(directory, { recursive: true, force: true }); }
   });
+
+  test("searches the current directory for -r without a path", async () => {
+    const directory = mkdtempSync(join(tmpdir(), "bunmsh-grep-cwd-reference-"));
+    try {
+      mkdirSync(join(directory, "nested"));
+      await Bun.write(join(directory, "nested", "a.txt"), "needle one\nnone\n");
+      await expectBuiltinGrepLike(["-r", "needle"], "", directory);
+      await expectBuiltinGrepLike(["-rn", "needle"], "", directory);
+      await expectBuiltinGrepLike(["-r", "missing"], "", directory);
+      await expectBuiltinGrepLike(["-rq", "needle"], "", directory);
+    } finally { rmSync(directory, { recursive: true, force: true }); }
+  });
 });
 
 describe("system sed reference", () => {