buninu 0.4.17 → 0.4.19

package/apps/bunmsh/src/shell.js

@@ -283,25 +283,23 @@ 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 fdDup = /^(\d+>&\d+)/.exec(source.slice(i))?.[1] ?? "";
     const operatorAhead =
       ["|", ";", "<", ">"].includes(ch) ||
       two === "&&" ||
       two === "||" ||
       two === "2>" ||
-      fdDup === "1>&2" ||
-      fdDup === "2>&1";
+      Boolean(fdDup);
     if (current && operatorAhead) {
       finishWord();
       continue;
     }
     // A descriptor duplication begins with the shorter `2>` redirect token,
     // so it must win before ordinary file redirects are considered.
-    if (!current && (fdDup === "1>&2" || fdDup === "2>&1")) {
+    if (!current && fdDup) {
       tokens.push({ type: "op", value: fdDup, offset: i });
-      i += 4;
+      i += fdDup.length;
       atWordBoundary = true;
       continue;
     }
@@ -364,7 +362,7 @@ export function tokenize(source, options = {}) {
         }
         if (source[i] === "\\" && i + 1 < source.length) {
           const next = source[i + 1];
-          if (next === "$" || next === '"' || next === "\\") {
+          if (next === "$" || next === "`" || next === '"' || next === "\\") {
             text += `\u0000${next}`;
             i += 2;
             continue;
@@ -419,8 +417,7 @@ export function tokenize(source, options = {}) {
         source.slice(i, i + 2) === "&&" ||
         source.slice(i, i + 2) === "||" ||
         source.slice(i, i + 2) === "2>" ||
-        source.slice(i, i + 4) === "1>&2" ||
-        source.slice(i, i + 4) === "2>&1";
+        /^\d+>&\d+/.test(source.slice(i));
       if (isSpace(c) || c === "\n" || c === "'" || c === '"' || c === "\\" || maybeOp)
         break;
       text += c;
@@ -448,6 +445,7 @@ function emptyCommand() {
 }
 
 export function parse(source) {
+  source = normalizeSource(source);
   const tokens = tokenize(source);
   const jobs = [];
   let i = 0;
@@ -466,7 +464,7 @@ export function parse(source) {
         const token = tokens[i];
         if (token.type === "op" && ["|", ";", "&&", "||"].includes(token.value))
           break;
-        if (token.type === "op" && ["1>&2", "2>&1"].includes(token.value)) {
+        if (token.type === "op" && /^\d+>&\d+$/.test(token.value)) {
           command.redirects.push({ op: token.value, target: null });
           i++;
           continue;
@@ -513,8 +511,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 +521,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;
 }
 
@@ -604,6 +616,66 @@ function globPatternRegex(pattern, anchoredStart, anchoredEnd, greedy) {
   return new RegExp(`${anchoredStart ? "^" : ""}${source}${anchoredEnd ? "$" : ""}`);
 }
 
+async function casePatternRegex(pattern, state) {
+  let marked = "";
+  const literal = (value) => {
+    for (const ch of value) marked += `\u0000${ch}`;
+  };
+  for (let i = 0; i < pattern.length;) {
+    if (pattern[i] === "\\") {
+      if (i + 1 < pattern.length) literal(pattern[i + 1]);
+      i += 2;
+      continue;
+    }
+    if (pattern[i] === "'") {
+      const end = pattern.indexOf("'", i + 1);
+      if (end < 0) throw new ShellSyntaxError("unterminated single quote in case pattern");
+      literal(pattern.slice(i + 1, end));
+      i = end + 1;
+      continue;
+    }
+    if (pattern[i] === '"') {
+      let end = i + 1;
+      while (end < pattern.length && pattern[end] !== '"') {
+        if (pattern[end] === "\\") end++;
+        end++;
+      }
+      if (end >= pattern.length) throw new ShellSyntaxError("unterminated double quote in case pattern");
+      literal(stripExpansionMarkers(await expandText(pattern.slice(i + 1, end), state)));
+      i = end + 1;
+      continue;
+    }
+    let end = i;
+    while (end < pattern.length && !["\\", "'", '"'].includes(pattern[end])) end++;
+    marked += stripExpansionMarkers(await expandText(pattern.slice(i, end), state));
+    i = end;
+  }
+  let source = "";
+  for (let i = 0; i < marked.length; i++) {
+    if (marked[i] === "\u0000") {
+      source += (marked[++i] ?? "").replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    } else if (marked[i] === "*") source += ".*";
+    else if (marked[i] === "?") source += ".";
+    else if (marked[i] === "[") {
+      let end = i + 1;
+      if (marked[end] === "!" || marked[end] === "^") end++;
+      if (marked[end] === "]") end++;
+      while (end < marked.length && marked[end] !== "]") end++;
+      if (end >= marked.length) source += "\\[";
+      else {
+        let body = marked.slice(i + 1, end);
+        const negate = body[0] === "!" || body[0] === "^";
+        if (negate) body = body.slice(1);
+        body = body.replaceAll("\\", "\\\\");
+        source += `[${negate ? "^" : ""}${body}]`;
+        i = end;
+      }
+    }
+    else source += marked[i].replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }
+  return new RegExp(`^${source}$`);
+}
+
 async function parameterExpansion(body, state) {
   if (/^[!%][A-Za-z_][A-Za-z0-9_]*$/.test(body)) {
     const value = parameterValue(body.slice(1), state);
@@ -1223,33 +1295,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 +1897,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 +1957,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 +1991,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 +2116,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 +2285,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 +2295,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 +2456,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 +2487,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) {
@@ -2859,6 +2983,9 @@ function compoundLogicalSource(source) {
       breaks.add(token.offset);
     if (["elif", "else", "fi", "done", "esac"].includes(word))
       breaks.add(token.offset);
+    if (["fi", "done", "esac"].includes(word) && tokens[index + 1]?.value === ";" &&
+        tokens[index + 2] && tokens[index + 2].value !== ";")
+      breaks.add(tokens[index + 2].offset);
     if (["then", "do", "else"].includes(word) && tokens[index + 1])
       breaks.add(tokens[index + 1].offset);
     commandStart = ["if", "while", "until", "elif", "then", "do", "else"].includes(word);
@@ -2870,14 +2997,12 @@ function compoundLogicalSource(source) {
   return logical;
 }
 
-// A leaf command line inside a compound body (if/while/for/case) is scanned
-// one physical line at a time, but a here-document's body lives on the lines
-// that follow it. Grow the line by re-tokenizing with more lines appended
-// until the heredoc(s) it opens are fully resolved, so the folded lines never
-// get misread as separate commands or as clauses of the surrounding compound.
-function growHeredocLine(lines, index) {
+// A leaf command inside a compound body may continue across physical lines
+// inside quotes, substitutions, or a here-document. Keep those lines together
+// until mksh-style lexical tokenization says the command is complete, so
+// keywords inside a multiline word are never mistaken for compound syntax.
+function growLogicalCommand(lines, index) {
   const line = lines[index];
-  if (!line.includes("<<")) return { source: line, next: index + 1 };
   let end = index;
   let candidate = line;
   while (true) {
@@ -2886,7 +3011,7 @@ function growHeredocLine(lines, index) {
       return { source: candidate, next: end + 1 };
     } catch (error) {
       if (!(error instanceof ShellSyntaxError) ||
-          !error.message.startsWith("unterminated here-document"))
+          !/^(?:unterminated (?:here-document|single quote|double quote|command substitution|substitution))/.test(error.message))
         throw error;
       end++;
       if (end >= lines.length) throw error;
@@ -2895,7 +3020,199 @@ function growHeredocLine(lines, index) {
   }
 }
 
-function parseCompoundScript(source) {
+function makeCompoundPostfix(compound, suffix, source, nextLine) {
+  const match = /^\s*(\|\||&&|\||;)\s*(.*)$/.exec(suffix ?? "");
+  if (!match) return { node: compound, nextLine };
+  let command = match[2].trim();
+  while (!command && nextLine < source.length) {
+    command = source[nextLine++].trim();
+    if (!command || command.startsWith("#")) command = "";
+  }
+  if (!command)
+    throw new ShellSyntaxError(`compound command requires a command after ${match[1]}`);
+  return {
+    node: {
+      type: "compoundPostfix",
+      compound,
+      operator: match[1],
+      command,
+    },
+    nextLine,
+  };
+}
+
+function findShellKeyword(source, keyword) {
+  if (source.trimStart().startsWith("#")) return -1;
+  let quote = null;
+  for (let i = 0; i < source.length;) {
+    const ch = source[i];
+    if (quote === "'") {
+      if (ch === "'") quote = null;
+      i++;
+      continue;
+    }
+    if (quote === '"') {
+      if (ch === "\\" && /[\\"$`\n]/.test(source[i + 1] ?? "")) { i += 2; continue; }
+      if (ch === '"') quote = null;
+      i++;
+      continue;
+    }
+    if (ch === "\\") { i += 2; continue; }
+    if (ch === "'" || ch === '"') { quote = ch; i++; continue; }
+    if (ch === "`" || (ch === "$" && source[i + 1] === "(")) {
+      try { i = substitutionEnd(source, i); }
+      catch { return -1; } // This physical line may continue the substitution.
+      continue;
+    }
+    if (ch === "$" && source[i + 1] === "{") {
+      try { i = parameterEnd(source, i); }
+      catch { return -1; }
+      continue;
+    }
+    if (/[A-Za-z_]/.test(ch)) {
+      const start = i++;
+      while (/[A-Za-z0-9_]/.test(source[i] ?? "")) i++;
+      if (source.slice(start, i) === keyword) {
+        let previous = start - 1;
+        while (previous >= 0 && /\s/.test(source[previous])) previous--;
+        if (keyword !== "esac" || previous < 0 || source[previous] === ";" || source[previous] === "\n")
+          return start;
+      }
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+
+function splitCasePatterns(source) {
+  const patterns = [];
+  let start = 0;
+  let quote = null;
+  for (let i = 0; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "\\") { i++; continue; }
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') { quote = ch; continue; }
+    if (ch === "$" && (source[i + 1] === "(" || source[i + 1] === "{")) {
+      i = (source[i + 1] === "(" ? substitutionEnd(source, i) : parameterEnd(source, i)) - 1;
+      continue;
+    }
+    if (ch === "`") { i = substitutionEnd(source, i) - 1; continue; }
+    if (ch === "|") { patterns.push(source.slice(start, i).trim()); start = i + 1; }
+  }
+  patterns.push(source.slice(start).trim());
+  return patterns;
+}
+
+// Scan case clauses in the same lexical spirit as mksh's CASEPAT/KEYWORD
+// modes. In particular, clause boundaries are shell tokens, not line
+// boundaries: Autoconf commonly writes an entire clause on one line.
+function parseCaseArms(source) {
+  const arms = [];
+  let i = 0;
+  const skipSpace = () => {
+    while (/\s/.test(source[i] ?? "")) i++;
+  };
+  while (i < source.length) {
+    skipSpace();
+    if (i >= source.length) break;
+    if (source[i] === "#") {
+      while (i < source.length && source[i] !== "\n") i++;
+      continue;
+    }
+    if (source[i] === "(") { i++; skipSpace(); }
+    const patternStart = i;
+    let quote = null;
+    let extensionDepth = 0;
+    for (; i < source.length; i++) {
+      const ch = source[i];
+      if (ch === "\\") { i++; continue; }
+      if (quote) {
+        if (ch === quote) quote = null;
+        continue;
+      }
+      if (ch === "'" || ch === '"') { quote = ch; continue; }
+      if (ch === "$" && (source[i + 1] === "(" || source[i + 1] === "{")) {
+        i = (source[i + 1] === "(" ? substitutionEnd(source, i) : parameterEnd(source, i)) - 1;
+        continue;
+      }
+      if (ch === "`") { i = substitutionEnd(source, i) - 1; continue; }
+      if (ch === "(" && /[?*+@!]/.test(source[i - 1] ?? "")) { extensionDepth++; continue; }
+      if (ch === ")" && extensionDepth) { extensionDepth--; continue; }
+      if (ch === ")") break;
+    }
+    if (i >= source.length)
+      throw new ShellSyntaxError(`case pattern requires ): ${source.slice(patternStart, Math.min(source.length, patternStart + 120))}`);
+    const patterns = splitCasePatterns(source.slice(patternStart, i));
+    if (!patterns.length || patterns.some((pattern) => !pattern))
+      throw new ShellSyntaxError("case requires a pattern");
+    i++;
+
+    const bodyStart = i;
+    quote = null;
+    let nestedCases = 0;
+    let word = "";
+    let terminator = null;
+    const finishWord = () => {
+      if (word === "case") nestedCases++;
+      else if (word === "esac" && nestedCases) nestedCases--;
+      word = "";
+    };
+    for (; i < source.length; i++) {
+      const ch = source[i];
+      if (ch === "#" && !word && (i === bodyStart || /[\s;|&]/.test(source[i - 1] ?? ""))) {
+        while (i < source.length && source[i] !== "\n") i++;
+        continue;
+      }
+      if (ch === "\\") { word = ""; i++; continue; }
+      if (quote) {
+        if (ch === quote) quote = null;
+        continue;
+      }
+      if (ch === "'" || ch === '"') { finishWord(); quote = ch; continue; }
+      if (ch === "$" && (source[i + 1] === "(" || source[i + 1] === "{")) {
+        finishWord();
+        i = (source[i + 1] === "(" ? substitutionEnd(source, i) : parameterEnd(source, i)) - 1;
+        continue;
+      }
+      if (ch === "`") {
+        finishWord();
+        try { i = substitutionEnd(source, i) - 1; }
+        catch (error) { error.message += ` near ${JSON.stringify(source.slice(Math.max(0, i - 100), i + 180))}`; throw error; }
+        continue;
+      }
+      if (/[A-Za-z_]/.test(ch)) { word += ch; continue; }
+      finishWord();
+      if (!nestedCases && ch === ";" && [";", "&", "|"].includes(source[i + 1])) {
+        terminator = source.slice(i, i + 2);
+        break;
+      }
+    }
+    // POSIX allows the final clause to omit `;;` immediately before esac.
+    if (!terminator) {
+      if (source.slice(bodyStart, i).trim() || arms.length) terminator = ";;";
+      else throw new ShellSyntaxError("unterminated case clause");
+    }
+    const bodySource = source.slice(bodyStart, i).trim();
+    let body;
+    try {
+      body = parseCompoundScript(bodySource);
+    } catch (error) {
+      if (error instanceof ShellSyntaxError)
+        error.message += ` in case arm ${patterns.join("|")}`;
+      throw error;
+    }
+    arms.push({ patterns, body, terminator });
+    if (i < source.length) i += 2;
+  }
+  return arms;
+}
+
+export function parseCompoundScript(source) {
   const lines = compoundLogicalSource(source.replace(/\\\r?\n/g, "")).split(/\r?\n/);
   const parseSequence = (start, stops = []) => {
     const nodes = [];
@@ -2923,102 +3240,163 @@ function parseCompoundScript(source) {
       }
 
       if (/^if(?:\s|$)/.test(trimmed)) {
+        const compoundStart = i;
         const branches = [];
         let header = trimmed;
-        while (!/;\s*then\s*$/.test(header) && ++i < lines.length)
+        while (!/(?:;\s*|\s+)then(?:\s+.*)?$/.test(header) && ++i < lines.length)
           header += ` ${lines[i].trim()}`;
-        if (!/;\s*then\s*$/.test(header)) throw new ShellSyntaxError("if requires then");
-        let condition = header.replace(/^if\s*/, "").replace(/;\s*then\s*$/, "");
+        let then = /(?:;\s*|\s+)then(?:\s+(.*))?$/.exec(header);
+        if (!then) throw new ShellSyntaxError("if requires then");
+        let condition = header.slice(0, then.index).replace(/^if\s*/, "").trim();
+        let thenCommand = then[1]?.trim() ?? "";
         i++;
         while (true) {
-          const body = parseSequence(i, [/^elif(?:\s|$)/, /^else\s*;?$/, /^fi\s*;?$/]);
-          branches.push({ condition, body: body.nodes });
+          const body = parseSequence(i, [/^elif(?:\s|$)/, /^else\s*;?$/, /^fi\b/]);
+          branches.push({ condition, body: body.nodes, thenCommand });
           i = body.index;
           const stop = lines[i]?.trim() ?? "";
           if (/^elif(?:\s|$)/.test(stop)) {
             header = stop;
-            while (!/;\s*then\s*$/.test(header) && ++i < lines.length)
+            while (!/(?:;\s*|\s+)then(?:\s+.*)?$/.test(header) && ++i < lines.length)
               header += ` ${lines[i].trim()}`;
-            if (!/;\s*then\s*$/.test(header)) throw new ShellSyntaxError("elif requires then");
-            condition = header.replace(/^elif\s*/, "").replace(/;\s*then\s*$/, "");
+            then = /(?:;\s*|\s+)then(?:\s+(.*))?$/.exec(header);
+            if (!then) throw new ShellSyntaxError("elif requires then");
+            condition = header.slice(0, then.index).replace(/^elif\s*/, "").trim();
+            thenCommand = then[1]?.trim() ?? "";
             i++;
             continue;
           }
           let otherwise = [];
           if (/^else\s*;?$/.test(stop)) {
-            const body = parseSequence(i + 1, [/^fi\s*;?$/]);
+            const body = parseSequence(i + 1, [/^fi\b/]);
             otherwise = body.nodes;
             i = body.index;
           }
-          if (!/^fi\s*;?$/.test(lines[i]?.trim() ?? ""))
+          if (!/^fi\b/.test(lines[i]?.trim() ?? ""))
             throw new ShellSyntaxError("unterminated if");
-          nodes.push({ type: "if", branches, otherwise });
-          i++;
+          const compound = { type: "if", branches, otherwise };
+          const close = /^fi\b(.*)$/.exec(lines[i].trim());
+          const result = makeCompoundPostfix(
+            { ...compound, source: [...lines.slice(compoundStart, i), "fi"].join("\n") },
+            close?.[1] ?? "",
+            lines,
+            i + 1,
+          );
+          nodes.push(result.node);
+          i = result.nextLine;
           break;
         }
         continue;
       }
       if (/^(?:while|until)(?:\s|$)/.test(trimmed)) {
+        const compoundStart = i;
         const kind = trimmed.startsWith("until") ? "until" : "while";
         let header = trimmed;
-        while (!/;\s*do\s*$/.test(header) && ++i < lines.length)
+        while (!/(?:;\s*|\s+)do\s*$/.test(header) && ++i < lines.length)
           header += ` ${lines[i].trim()}`;
-        if (!/;\s*do\s*$/.test(header)) throw new ShellSyntaxError(`${kind} requires do`);
-        const condition = header.replace(new RegExp(`^${kind}\\s*`), "").replace(/;\s*do\s*$/, "");
-        const body = parseSequence(i + 1, [/^done(?:\s*<\s*.+)?\s*;?$/]);
-        const done = /^done(?:\s*<\s*(.+?))?\s*;?$/.exec(lines[body.index]?.trim() ?? "");
+        if (!/(?:;\s*|\s+)do\s*$/.test(header)) throw new ShellSyntaxError(`${kind} requires do`);
+        const condition = header.replace(new RegExp(`^${kind}\\s*`), "").replace(/(?:;\s*|\s+)do\s*$/, "");
+        const body = parseSequence(i + 1, [/^done\b/]);
+        const done = /^done(?:\s*<\s*(.+?))?\s*;?\s*((?:\|\||&&|\||;).*)?$/.exec(lines[body.index]?.trim() ?? "");
         if (!done)
           throw new ShellSyntaxError(`unterminated ${kind}`);
-        nodes.push({ type: "loop", kind, condition, body: body.nodes, input: done[1] ?? null });
-        i = body.index + 1;
+        const compound = {
+          type: "loop", kind, condition, body: body.nodes, input: done[1] ?? null,
+          source: [...lines.slice(compoundStart, body.index), `done${done[1] ? ` < ${done[1]}` : ""}`].join("\n"),
+        };
+        const result = makeCompoundPostfix(compound, done[2] ?? "", lines, body.index + 1);
+        nodes.push(result.node);
+        i = result.nextLine;
         continue;
       }
       if (/^for(?:\s|$)/.test(trimmed)) {
+        const compoundStart = i;
         let header = trimmed;
-        while (!/;\s*do\s*$/.test(header) && ++i < lines.length)
+        let bodyStart = -1;
+        while (i < lines.length) {
+          if (/;\s*do\s*$/.test(header)) {
+            header = header.replace(/;\s*do\s*$/, "");
+            bodyStart = i + 1;
+            break;
+          }
+          if (lines[i + 1]?.trim() === "do") {
+            bodyStart = i + 2;
+            i++;
+            break;
+          }
+          if (++i >= lines.length) break;
           header += ` ${lines[i].trim()}`;
-        const match = /^for\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s+in\s+(.*?))?\s*;\s*do\s*$/.exec(header);
+        }
+        const match = /^for\s+([A-Za-z_][A-Za-z0-9_]*)(?:\s+in(?:\s+(.*?))?)?\s*;?$/.exec(header);
         if (!match) throw new ShellSyntaxError("invalid for command");
-        const body = parseSequence(i + 1, [/^done\s*;?$/]);
-        if (!/^done\s*;?$/.test(lines[body.index]?.trim() ?? ""))
-          throw new ShellSyntaxError("unterminated for");
-        nodes.push({ type: "for", name: match[1], words: match[2] ?? null, body: body.nodes });
-        i = body.index + 1;
+        if (bodyStart < 0) throw new ShellSyntaxError("for requires do");
+        const body = parseSequence(bodyStart, [/^done\b/]);
+        if (!/^done\b/.test(lines[body.index]?.trim() ?? ""))
+          throw new ShellSyntaxError(`unterminated for: ${lines[compoundStart]?.trim()} (stopped at ${lines[body.index]?.trim()})`);
+        const compound = {
+          type: "for", name: match[1], words: match[2] ?? null, body: body.nodes,
+          source: [...lines.slice(compoundStart, body.index), "done"].join("\n"),
+        };
+        const close = /^done\b(.*)$/.exec(lines[body.index].trim());
+        const result = makeCompoundPostfix(compound, close?.[1] ?? "", lines, body.index + 1);
+        nodes.push(result.node);
+        i = result.nextLine;
         continue;
       }
       if (/^case(?:\s|$)/.test(trimmed)) {
+        const compoundStart = i;
         let header = trimmed;
-        while (!/\s+in\s*$/.test(header) && ++i < lines.length)
+        while (!/\s+in(?:\s|$)/.test(header) && ++i < lines.length)
           header += ` ${lines[i].trim()}`;
-        const match = /^case\s+(.+?)\s+in\s*$/.exec(header);
+        const match = /^case\s+(.+?)\s+in(?:\s+(.*))?$/.exec(header);
         if (!match) throw new ShellSyntaxError("case requires in");
-        const arms = [];
+        const inlineEsac = findShellKeyword(match[2] ?? "", "esac");
+        if (inlineEsac >= 0) {
+          const inlineArms = match[2].slice(0, inlineEsac);
+          const suffix = match[2].slice(inlineEsac + "esac".length);
+          const compound = {
+            type: "case",
+            word: match[1],
+            arms: parseCaseArms(inlineArms),
+            source: `case ${match[1]} in\n${inlineArms}\nesac`,
+          };
+          const result = makeCompoundPostfix(compound, suffix, lines, i + 1);
+          nodes.push(result.node);
+          i = result.nextLine;
+          continue;
+        }
+        const bodyLines = match[2] ? [match[2]] : [];
         i++;
-        while (i < lines.length && !/^esac\s*;?$/.test(lines[i].trim())) {
-          if (!lines[i].trim() || lines[i].trim().startsWith("#")) { i++; continue; }
-          const arm = /^(.+?)\)\s*$/.exec(lines[i].trim());
-          if (!arm) throw new ShellSyntaxError("case pattern requires )");
-          const bodyLines = [];
-          i++;
-          while (i < lines.length && !/^esac\s*;?$/.test(lines[i].trim())) {
-            const current = lines[i];
-            const terminator = current.indexOf(";;");
-            if (terminator >= 0) {
-              if (current.slice(0, terminator).trim()) bodyLines.push(current.slice(0, terminator));
-              i++;
-              break;
-            }
-            bodyLines.push(current);
-            i++;
+        let nestedCases = 0;
+        while (i < lines.length) {
+          const current = lines[i].trim();
+          const nestedCase = findShellKeyword(current, "case");
+          if (nestedCase >= 0 && /\s/.test(current[nestedCase + "case".length] ?? ""))
+            nestedCases++;
+          // In an enclosing case arm, mksh tokenises `esac;;` as two
+          // independent tokens: ESAC followed by the enclosing arm's BREAK.
+          // Count that as the end of the nested case while retaining the
+          // whole line for parseCaseArms to assign the `;;` to its parent.
+          const closingCase = findShellKeyword(current, "esac");
+          if (closingCase >= 0) {
+            if (!nestedCases) break;
+            nestedCases--;
           }
-          arms.push({ patterns: arm[1].split("|").map((pattern) => pattern.trim()), body: parseCompoundScript(bodyLines.join("\n")) });
+          bodyLines.push(lines[i++]);
         }
-        if (!/^esac\s*;?$/.test(lines[i]?.trim() ?? "")) throw new ShellSyntaxError("unterminated case");
-        nodes.push({ type: "case", word: match[1], arms });
-        i++;
+        if (!/^esac\b/.test(lines[i]?.trim() ?? ""))
+          throw new ShellSyntaxError(`unterminated case: ${trimmed} (at ${lines[i]?.trim() ?? "EOF"})`);
+        const compound = {
+          type: "case", word: match[1], arms: parseCaseArms(bodyLines.join("\n")),
+          source: [...lines.slice(compoundStart, i), "esac"].join("\n"),
+        };
+        const close = /^esac\b(.*)$/.exec(lines[i].trim());
+        const result = makeCompoundPostfix(compound, close?.[1] ?? "", lines, i + 1);
+        nodes.push(result.node);
+        i = result.nextLine;
         continue;
       }
-      const grown = growHeredocLine(lines, i);
+      const grown = growLogicalCommand(lines, i);
       nodes.push({ type: "command", source: grown.source });
       i = grown.next;
     }
@@ -3069,6 +3447,61 @@ async function executeNodeList(nodes, state, options = {}) {
   };
   for (const node of nodes) {
     if (state.exitRequested) break;
+    if (node.type === "compoundPostfix") {
+      if (node.operator === "|") {
+        const link = new TransformStream();
+        const leftPromise = runExternal(
+          pipelineCompoundArgv(node.compound.source),
+          pipelineBuiltinState(state),
+          options.input ?? null,
+          false,
+          true,
+          link.writable,
+          { pipelineKillSignal: "SIGTERM" },
+        );
+        const rightState = {
+          ...state,
+          env: { ...state.env },
+          aliases: { ...state.aliases },
+          functions: { ...state.functions },
+          readonly: new Set(state.readonly),
+          directoryHistory: [...state.directoryHistory],
+          tabs: [...state.tabs],
+          exitRequested: false,
+          exitStatus: 0,
+        };
+        const right = await runExternal(
+          pipelineCompoundArgv(node.command),
+          pipelineBuiltinState(rightState),
+          link.readable,
+          true,
+          true,
+        );
+        const left = await leftPromise;
+        execution = result(right.status, right.stdout, concatBytes([left.stderr, right.stderr]));
+      } else {
+        execution = await executeNodeList([node.compound], state, { capture });
+        append(execution);
+        const shouldRun = node.operator === "&&"
+          ? execution.status === 0
+          : node.operator === "||"
+            ? execution.status !== 0
+            : true;
+        if (shouldRun) {
+          execution = await execute(node.command, state, { capture });
+          append(execution);
+        }
+        state.lastStatus = execution.status;
+        continue;
+      }
+      state.lastStatus = execution.status;
+      if (capture) append(execution);
+      else {
+        if (execution.stdout.byteLength) stdout.push(execution.stdout);
+        if (execution.stderr.byteLength) stderr.push(execution.stderr);
+      }
+      continue;
+    }
     if (node.type === "function") {
       state.functions[node.name] = node.body;
       continue;
@@ -3152,29 +3585,39 @@ async function executeNodeList(nodes, state, options = {}) {
       const parsed = parse(`__case ${node.word}`)[0]?.pipeline[0];
       const value = (await expandWord(parsed.words[1], state, { single: true }))[0] ?? "";
       execution = result();
+      let fallThrough = false;
       for (const arm of node.arms) {
-        let matches = false;
-        for (let pattern of arm.patterns) {
-          pattern = pattern.replace(/^(['"])(.*)\1$/, "$2");
-          pattern = stripExpansionMarkers(await expandText(pattern, state));
-          if (globPatternRegex(pattern, true, true, true).test(value)) { matches = true; break; }
+        let matches = fallThrough;
+        if (!matches) for (const pattern of arm.patterns) {
+          if ((await casePatternRegex(pattern, state)).test(value)) { matches = true; break; }
         }
         if (!matches) continue;
         execution = await executeNodeList(arm.body, state, { capture });
         append(execution);
+        if (arm.terminator === ";&") { fallThrough = true; continue; }
+        if (arm.terminator === ";|") { fallThrough = false; continue; }
         break;
       }
       state.lastStatus = execution.status;
       continue;
     }
     let selected = null;
+    let selectedThen = "";
     for (const branch of node.branches) {
       let condition = branch.condition.trim();
       let negate = false;
       while (/^!\s+/.test(condition)) { negate = !negate; condition = condition.replace(/^!\s+/, ""); }
       const checked = await execute(condition, state, { capture, simple: true });
       append(checked);
-      if ((checked.status === 0) !== negate) { selected = branch.body; break; }
+      if ((checked.status === 0) !== negate) {
+        selected = branch.body;
+        selectedThen = branch.thenCommand ?? "";
+        break;
+      }
+    }
+    if (selectedThen) {
+      const initial = await execute(selectedThen, state, { capture });
+      append(initial);
     }
     execution = selected
       ? await executeNodeList(selected, state, { capture })
@@ -3210,15 +3653,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
@@ -3286,6 +3736,85 @@ function pipelineBuiltinArgv(argv) {
     : [...BUN_RUNTIME_COMMAND, BUNMSH_ENTRY, "-cc", ...argv];
 }
 
+function pipelineCompoundArgv(source) {
+  return IS_COMPILED
+    ? [...EXECUTABLE_COMMAND, "-c", source]
+    : [...BUN_RUNTIME_COMMAND, BUNMSH_ENTRY, "-c", source];
+}
+
+function leadingSubshell(source) {
+  const leading = source.length - source.trimStart().length;
+  if (source[leading] !== "(") return null;
+  let depth = 0, quote = null;
+  for (let i = leading; i < source.length; i++) {
+    const ch = source[i];
+    if (quote === "'") { if (ch === "'") quote = null; continue; }
+    if (quote === '"') {
+      if (ch === "\\" && /[\\"$`\n]/.test(source[i + 1] ?? "")) { i++; continue; }
+      if (ch === '"') quote = null;
+      continue;
+    }
+    if (ch === "\\") { i++; continue; }
+    if (ch === "'" || ch === '"') { quote = ch; continue; }
+    if (ch === "`") {
+      try { i = substitutionEnd(source, i) - 1; } catch { return null; }
+      continue;
+    }
+    if (ch === "$" && source[i + 1] === "(") {
+      try { i = substitutionEnd(source, i) - 1; } catch { return null; }
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")" && --depth === 0)
+      return { body: source.slice(leading + 1, i), suffix: source.slice(i + 1) };
+  }
+  return null;
+}
+
+function rewriteSubshells(source, state) {
+  let output = "", quote = null;
+  for (let i = 0; i < source.length;) {
+    const ch = source[i];
+    if (quote === "'") {
+      output += ch;
+      if (ch === "'") quote = null;
+      i++;
+      continue;
+    }
+    if (quote === '"') {
+      output += ch;
+      if (ch === "\\" && /[\\"$`\n]/.test(source[i + 1] ?? "")) output += source[++i];
+      else if (ch === '"') quote = null;
+      i++;
+      continue;
+    }
+    if (ch === "\\") { output += source.slice(i, i + 2); i += 2; continue; }
+    if (ch === "'" || ch === '"') { quote = ch; output += ch; i++; continue; }
+    if (ch === "`") {
+      try { const end = substitutionEnd(source, i); output += source.slice(i, end); i = end; continue; }
+      catch { output += ch; i++; continue; }
+    }
+    if (ch === "$" && source[i + 1] === "(") {
+      try { const end = substitutionEnd(source, i); output += source.slice(i, end); i = end; continue; }
+      catch { output += ch; i++; continue; }
+    }
+    const boundary = i === 0 || /[\s;|&]/.test(source[i - 1]);
+    if (ch === "(" && boundary) {
+      const group = leadingSubshell(source.slice(i));
+      if (group) {
+        const argv = pipelineCompoundArgv(group.body);
+        const serialized = pipelineBuiltinState(state).env[PIPELINE_STATE_ENV];
+        output += `BUNMSH_INTERNAL_PIPELINE_STATE=${quoteShellWord(serialized)} ${argv.map(quoteShellWord).join(" ")}`;
+        i += group.body.length + 2;
+        continue;
+      }
+    }
+    output += ch;
+    i++;
+  }
+  return output;
+}
+
 function pipelineBuiltinState(state) {
   return {
     ...state,
@@ -3379,6 +3908,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))
@@ -3585,6 +4123,7 @@ async function runCommand(command, state, options = {}) {
   for (const redirect of command.redirects) {
     if (redirect.op === "1>&2") { stdoutToStderr = true; continue; }
     if (redirect.op === "2>&1") { stderrToStdout = true; continue; }
+    if (/^\d+>&\d+$/.test(redirect.op)) continue;
     if (redirect.op === "<<" || redirect.op === "<<-") {
       const heredoc = redirect.heredoc ?? { body: "", expand: false };
       const content = heredoc.expand
@@ -3674,6 +4213,7 @@ async function runCommand(command, state, options = {}) {
       stderrSink: stderrRedirect,
       onSpawn: options.onSpawn,
       onExit: options.onExit,
+      background: Boolean(options.background),
     },
   );
 
@@ -3690,10 +4230,15 @@ 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, {
+      input: options.input ?? null,
+      stdoutSink: options.stdoutSink ?? null,
       captureStdout: Boolean(options.capture),
       captureStderr: Boolean(options.capture),
+      background: Boolean(options.background),
     });
 
   const links = Array.from(
@@ -3726,7 +4271,7 @@ async function runPipeline(pipeline, state, options = {}) {
   const stages = pipeline.map((command, i) => {
     const last = i === pipeline.length - 1;
     return runCommand(command, state, {
-      input: i === 0 ? null : links[i - 1].readable,
+      input: i === 0 ? options.input ?? null : links[i - 1].readable,
       captureStdout: last && Boolean(options.capture),
       captureStderr: Boolean(options.capture),
       stdoutSink: last ? null : links[i].writable,
@@ -3774,6 +4319,47 @@ export async function execute(source, state = createState(), io = {}) {
     return execution;
   }
   const rawSource = source.trimStart();
+  const group = leadingSubshell(source);
+  if (group) {
+    let suffix = group.suffix;
+    let discardStdout = false, discardStderr = false;
+    while (true) {
+      const redirect = /^\s*(?:(\d+)?(>>?|<)\s*([^\s;&|]+)|(\d+>&\d+))/.exec(suffix);
+      if (!redirect) break;
+      if (redirect[2] === ">" || redirect[2] === ">>") {
+        if (redirect[1] === "2") discardStderr ||= redirect[3] === "/dev/null";
+        else discardStdout ||= redirect[3] === "/dev/null";
+      }
+      suffix = suffix.slice(redirect[0].length);
+    }
+    const child = await runExternal(
+      pipelineCompoundArgv(group.body),
+      pipelineBuiltinState(state),
+      io.input ?? null,
+      true,
+      true,
+    );
+    let execution = result(child.status,
+      discardStdout ? "" : child.stdout,
+      discardStderr ? "" : child.stderr);
+    const connector = /^\s*(\|\||&&|;)\s*([\s\S]*)$/.exec(suffix);
+    if (connector) {
+      const shouldRun = connector[1] === ";" ||
+        (connector[1] === "&&" ? execution.status === 0 : execution.status !== 0);
+      if (shouldRun) {
+        const tail = await execute(connector[2], state, io);
+        execution = result(tail.status,
+          concatBytes([execution.stdout, tail.stdout]),
+          concatBytes([execution.stderr, tail.stderr]));
+      }
+    }
+    state.lastStatus = execution.status;
+    if (!io.capture) {
+      if (execution.stdout.byteLength) await writeStream(process.stdout, execution.stdout);
+      if (execution.stderr.byteLength) await writeStream(process.stderr, execution.stderr);
+    }
+    return execution;
+  }
   if (isJavaScriptMode(rawSource)) {
     let execution;
     const previousCwd = process.cwd();
@@ -3844,6 +4430,7 @@ export async function execute(source, state = createState(), io = {}) {
     try {
       execution = await executeNodeList(parseCompoundScript(source), state, {
         capture: Boolean(io.capture),
+        input: io.input ?? null,
       });
     }
     catch (error) {
@@ -3858,6 +4445,12 @@ export async function execute(source, state = createState(), io = {}) {
     return execution;
   }
 
+  const withSubshells = rewriteSubshells(source, state);
+  if (withSubshells !== source) {
+    source = withSubshells;
+    return execute(source, state, io);
+  }
+
   let jobs;
   try {
     jobs = parse(source);
@@ -3876,7 +4469,12 @@ 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,
+      input: io.input ?? null,
+      stdoutSink: io.stdoutSink ?? null,
+    });
     if (job.negate) execution.status = execution.status === 0 ? 1 : 0;
     state.lastStatus = execution.status;
     if (execution.stdout.byteLength) {