shfs 0.3.1 → 0.3.3

package/dist/{execute-1PmTy1KA.mjs → execute-DV1hpsh-.mjs}

@@ -636,7 +636,8 @@ function compileCat(cmd) {
 		if (arg !== void 0) fileArgs.push(arg);
 	}
 	const hasInputRedirection = cmd.redirections.some((redirection) => redirection.kind === "input");
-	if (fileArgs.length === 0 && !hasInputRedirection) throw new Error("cat requires at least one file");
+	const hasOutputRedirection = cmd.redirections.some((redirection) => redirection.kind === "output");
+	if (fileArgs.length === 0 && !hasInputRedirection && !hasOutputRedirection) throw new Error("cat requires at least one file");
 	return {
 		cmd: "cat",
 		args: {
@@ -654,7 +655,7 @@ function compileCat(cmd) {
 /**
 * cd command handler for the AST-based compiler.
 */
-const ROOT_DIRECTORY$3 = "/";
+const ROOT_DIRECTORY$4 = "/";
 /**
 * Compile a cd command from SimpleCommandIR to StepIR.
 */
@@ -663,7 +664,7 @@ function compileCd(cmd) {
 	if (positionalArgs.length > 1) throw new Error("cd accepts at most one path");
 	return {
 		cmd: "cd",
-		args: { path: positionalArgs[0] ?? literal(ROOT_DIRECTORY$3) }
+		args: { path: positionalArgs[0] ?? literal(ROOT_DIRECTORY$4) }
 	};
 }
 /**
@@ -782,6 +783,15 @@ const DEFAULT_TRAVERSAL = {
 	mindepth: 0
 };
 const NON_NEGATIVE_INTEGER_REGEX = /^\d+$/;
+const PATTERN_PREDICATES = new Set([
+	"-name",
+	"-path",
+	"-ipath",
+	"-wholename",
+	"-iwholename",
+	"-regex",
+	"-iregex"
+]);
 function compileFind(command) {
 	return {
 		cmd: "find",
@@ -834,8 +844,19 @@ function findPredicateStartIndex(argv) {
 	return argv.length;
 }
 function parseFindToken(argv, index, token, state) {
-	if (token === "-name" || token === "-path") return parseStringPredicate(argv, index, token, state);
+	if (isPatternPredicateToken(token)) return parsePatternPredicate(argv, index, token, state);
 	if (token === "-type") return parseTypePredicate(argv, index, state);
+	if (token === "-true" || token === "-false") {
+		state.currentBranch.push({
+			kind: "constant",
+			value: token === "-true"
+		});
+		return index + 1;
+	}
+	if (token === "-empty") {
+		state.currentBranch.push({ kind: "empty" });
+		return index + 1;
+	}
 	if (token === "-o" || token === "-or") return parseOrPredicateSeparator(index, state);
 	if (token === "-maxdepth" || token === "-mindepth") return parseTraversalOption(argv, index, token, state);
 	if (token === "-depth") {
@@ -855,6 +876,9 @@ function parseFindToken(argv, index, token, state) {
 	state.diagnostics.push(createDiagnostic$1("unexpected-operand", token, index, `find: unexpected argument: ${token}`));
 	return index + 1;
 }
+function isPatternPredicateToken(token) {
+	return PATTERN_PREDICATES.has(token);
+}
 function parseOrPredicateSeparator(index, state) {
 	state.sawOr = true;
 	state.lastOrTokenIndex = index;
@@ -867,16 +891,43 @@ function parseOrPredicateSeparator(index, state) {
 	state.currentSideAllowsEmptyBranch = false;
 	return index + 1;
 }
-function parseStringPredicate(argv, index, token, state) {
+function parsePatternPredicate(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
 		state.diagnostics.push(createMissingValueDiagnostic(token, index));
 		return index + 1;
 	}
-	state.currentBranch.push({
-		kind: token === "-name" ? "name" : "path",
-		pattern: valueWord
-	});
+	switch (token) {
+		case "-name":
+			state.currentBranch.push({
+				kind: "name",
+				pattern: valueWord
+			});
+			break;
+		case "-path":
+		case "-wholename":
+			state.currentBranch.push({
+				kind: "path",
+				pattern: valueWord
+			});
+			break;
+		case "-ipath":
+		case "-iwholename":
+			state.currentBranch.push({
+				kind: "ipath",
+				pattern: valueWord
+			});
+			break;
+		case "-regex":
+		case "-iregex":
+			state.currentBranch.push({
+				kind: "regex",
+				caseInsensitive: token === "-iregex",
+				pattern: valueWord
+			});
+			break;
+		default: return token;
+	}
 	return index + 2;
 }
 function parseTypePredicate(argv, index, state) {
@@ -1810,6 +1861,276 @@ function compileTouch(cmd) {
 		}
 	};
 }
+const DEFAULT_TOTAL_MODE = "auto";
+function compileWc(command) {
+	return {
+		cmd: "wc",
+		args: parseWcArgs(command.args)
+	};
+}
+function parseWcArgs(argv) {
+	const args = {
+		bytes: false,
+		chars: false,
+		files: [],
+		files0From: null,
+		lines: false,
+		maxLineLength: false,
+		total: DEFAULT_TOTAL_MODE,
+		words: false
+	};
+	for (let index = 0; index < argv.length; index++) {
+		const word = argv[index];
+		if (!word) continue;
+		const token = expandedWordToString(word);
+		if (token === "--") {
+			args.files.push(...argv.slice(index + 1));
+			break;
+		}
+		if (!token.startsWith("-") || token === "-") {
+			args.files.push(word);
+			continue;
+		}
+		const parsed = parseLongOption(argv, index, token, args);
+		if (parsed.matched) {
+			index = parsed.nextIndex - 1;
+			continue;
+		}
+		parseShortOptions(token, args);
+	}
+	return args;
+}
+function parseLongOption(argv, index, token, args) {
+	if (token === "--bytes") {
+		args.bytes = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--chars") {
+		args.chars = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--lines") {
+		args.lines = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--words") {
+		args.words = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--max-line-length") {
+		args.maxLineLength = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token.startsWith("--files0-from=")) {
+		args.files0From = {
+			kind: "literal",
+			value: token.slice(14)
+		};
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--files0-from") {
+		const value = argv[index + 1];
+		if (!value) throw new Error("wc: option --files0-from requires an argument");
+		args.files0From = value;
+		return {
+			matched: true,
+			nextIndex: index + 2
+		};
+	}
+	if (token.startsWith("--total=")) {
+		args.total = parseTotalMode(token.slice(8));
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "--total") {
+		args.total = "invalid";
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	return {
+		matched: false,
+		nextIndex: index
+	};
+}
+function parseShortOptions(token, args) {
+	for (const option of token.slice(1)) switch (option) {
+		case "c":
+			args.bytes = true;
+			break;
+		case "m":
+			args.chars = true;
+			break;
+		case "l":
+			args.lines = true;
+			break;
+		case "w":
+			args.words = true;
+			break;
+		case "L":
+			args.maxLineLength = true;
+			break;
+		default: throw new Error(`wc: unknown option -- ${option}`);
+	}
+}
+function parseTotalMode(value) {
+	if (value === "auto" || value === "always" || value === "never" || value === "only") return value;
+	throw new Error(`wc: invalid --total value: ${value}`);
+}
+const DEFAULT_COMMAND = [literal("echo")];
+const NUL_DELIMITER = "\0";
+function compileXargs(command) {
+	return {
+		cmd: "xargs",
+		args: parseXargsArgs(command.args)
+	};
+}
+function parseXargsArgs(argv) {
+	const args = {
+		command: DEFAULT_COMMAND,
+		delimiter: null,
+		eof: null,
+		maxArgs: null,
+		maxLines: null,
+		noRunIfEmpty: false,
+		replace: null
+	};
+	let index = 0;
+	while (index < argv.length) {
+		const word = argv[index];
+		if (!word) break;
+		const token = expandedWordToString(word);
+		const parsed = parseOption(argv, index, token, args);
+		if (!parsed.matched) break;
+		index = parsed.nextIndex;
+	}
+	const commandWords = argv.slice(index);
+	if (commandWords.length > 0) args.command = commandWords;
+	return args;
+}
+function parseOption(argv, index, token, args) {
+	if (token === "--") return {
+		matched: true,
+		nextIndex: index + 1
+	};
+	if (token === "-0" || token === "--null") {
+		args.delimiter = NUL_DELIMITER;
+		args.eof = null;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "-r" || token === "--no-run-if-empty") {
+		args.noRunIfEmpty = true;
+		return {
+			matched: true,
+			nextIndex: index + 1
+		};
+	}
+	if (token === "-n" || token.startsWith("-n")) {
+		const value = optionValue(argv, index, token, "-n");
+		setMaxArgsMode(args, parsePositiveInteger(value.value, "-n"));
+		return {
+			matched: true,
+			nextIndex: value.nextIndex
+		};
+	}
+	if (token === "-L" || token.startsWith("-L")) {
+		const value = optionValue(argv, index, token, "-L");
+		setMaxLinesMode(args, parsePositiveInteger(value.value, "-L"));
+		return {
+			matched: true,
+			nextIndex: value.nextIndex
+		};
+	}
+	if (token === "-E" || token.startsWith("-E")) {
+		const value = optionValue(argv, index, token, "-E");
+		args.eof = value.value;
+		return {
+			matched: true,
+			nextIndex: value.nextIndex
+		};
+	}
+	if (token === "-I" || token.startsWith("-I")) {
+		const value = optionValue(argv, index, token, "-I");
+		setReplaceMode(args, value.value);
+		return {
+			matched: true,
+			nextIndex: value.nextIndex
+		};
+	}
+	if (token === "-d" || token.startsWith("-d")) {
+		const value = optionValue(argv, index, token, "-d");
+		args.delimiter = decodeDelimiter(value.value);
+		args.eof = null;
+		return {
+			matched: true,
+			nextIndex: value.nextIndex
+		};
+	}
+	return {
+		matched: false,
+		nextIndex: index
+	};
+}
+function setMaxArgsMode(args, maxArgs) {
+	args.maxArgs = maxArgs;
+	args.maxLines = null;
+	args.replace = null;
+}
+function setMaxLinesMode(args, maxLines) {
+	args.maxLines = maxLines;
+	args.maxArgs = null;
+	args.replace = null;
+}
+function setReplaceMode(args, replace) {
+	args.replace = replace;
+	args.maxLines = 1;
+	args.maxArgs = null;
+}
+function optionValue(argv, index, token, option) {
+	if (token.length > option.length) return {
+		nextIndex: index + 1,
+		value: token.slice(option.length)
+	};
+	const next = argv[index + 1];
+	if (!next) throw new Error(`xargs: option ${option} requires a value`);
+	return {
+		nextIndex: index + 2,
+		value: expandedWordToString(next)
+	};
+}
+function parsePositiveInteger(value, option) {
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed < 1) throw new Error(`xargs: invalid value for ${option}: ${value}`);
+	return parsed;
+}
+function decodeDelimiter(value) {
+	if (value === "\\0") return NUL_DELIMITER;
+	return value.at(0) ?? "";
+}
 let CommandHandler;
 (function(_CommandHandler) {
 	const handlers = {
@@ -1830,7 +2151,9 @@ let CommandHandler;
 		string: compileString,
 		tail: compileTail,
 		test: compileTest,
-		touch: compileTouch
+		touch: compileTouch,
+		wc: compileWc,
+		xargs: compileXargs
 	};
 	function get(name) {
 		const handler = handlers[name];
@@ -1920,6 +2243,12 @@ var ProgramCompiler = class {
 	compileRedirection(node) {
 		return {
 			kind: node.redirectKind,
+			mode: node.mode,
+			sourceFd: node.sourceFd,
+			targetFd: node.targetFd,
+			append: node.append,
+			noclobber: node.noclobber,
+			optional: node.optional,
 			target: this.expandWord(node.target)
 		};
 	}
@@ -1996,11 +2325,48 @@ var ProgramCompiler = class {
 		return program.statements.map((statement) => this.serializePipeline(statement.pipeline)).join("; ");
 	}
 	serializePipeline(pipeline) {
-		return pipeline.commands.map((cmd) => {
-			const name = this.serializeWord(cmd.name);
-			const args = cmd.args.map((arg) => this.serializeWord(arg)).join(" ");
-			return args ? `${name} ${args}` : name;
-		}).join(" | ");
+		const segments = [];
+		for (let index = 0; index < pipeline.commands.length; index++) {
+			const command = pipeline.commands[index];
+			if (!command) continue;
+			const hasNextCommand = index < pipeline.commands.length - 1;
+			segments.push(this.serializeCommand(command, { omitPipeRedirections: hasNextCommand }));
+			if (hasNextCommand) segments.push(this.serializePipelineOperator(command));
+		}
+		return segments.join(" ");
+	}
+	serializeCommand(command, options = {}) {
+		const segments = [this.serializeWord(command.name)];
+		for (const arg of command.args) segments.push(this.serializeWord(arg));
+		for (const redirection of command.redirections) {
+			if (options.omitPipeRedirections && redirection.mode === "pipe") continue;
+			segments.push(this.serializeRedirection(redirection));
+		}
+		return segments.join(" ");
+	}
+	serializePipelineOperator(command) {
+		const pipeRedirections = command.redirections.filter((redirection) => redirection.redirectKind === "output" && redirection.mode === "pipe");
+		const pipesStdout = pipeRedirections.some((redirection) => redirection.sourceFd === 1);
+		const pipesStderr = pipeRedirections.some((redirection) => redirection.sourceFd === 2);
+		if (pipesStdout && pipesStderr) return "&|";
+		const onlyPipeRedirection = pipeRedirections[0];
+		if (pipeRedirections.length === 1 && onlyPipeRedirection) return this.serializeRedirection(onlyPipeRedirection);
+		return "|";
+	}
+	serializeRedirection(redirection) {
+		const sourceFd = redirection.sourceFd === (redirection.redirectKind === "input" ? 0 : 1) ? "" : String(redirection.sourceFd);
+		if (redirection.redirectKind === "input") {
+			const operator = redirection.optional ? "<?" : "<";
+			if (redirection.mode === "fd") return `${sourceFd}<&${redirection.targetFd}`;
+			if (redirection.mode === "close") return `${sourceFd}<&-`;
+			return `${sourceFd}${operator}${this.serializeWord(redirection.target)}`;
+		}
+		if (redirection.mode === "pipe") return `${sourceFd}>|`;
+		if (redirection.mode === "fd") return `${sourceFd}>&${redirection.targetFd}`;
+		if (redirection.mode === "close") return `${sourceFd}>&-`;
+		let operator = redirection.append ? ">>" : ">";
+		if (redirection.noclobber) operator = `${operator}?`;
+		return `${sourceFd}${operator}${this.serializeWord(redirection.target)}`;
 	}
 	serializeWord(word) {
 		return word.parts.map((part) => this.serializeWordPart(part)).join("");
@@ -2925,11 +3291,23 @@ var CommandSubPart = class {
 */
 var Redirection = class extends ASTNode {
 	redirectKind;
+	mode;
+	sourceFd;
+	targetFd;
+	append;
+	noclobber;
+	optional;
 	target;
-	constructor(span, redirectKind, target) {
+	constructor(span, redirectKind, target, options = {}) {
 		super(span);
 		this.redirectKind = redirectKind;
 		this.target = target;
+		this.mode = options.mode ?? "file";
+		this.sourceFd = options.sourceFd ?? (redirectKind === "input" ? 0 : 1);
+		this.targetFd = options.targetFd ?? null;
+		this.append = options.append ?? false;
+		this.noclobber = options.noclobber ?? false;
+		this.optional = options.optional ?? false;
 	}
 	accept(visitor) {
 		return visitor.visitRedirection(this);
@@ -2942,6 +3320,7 @@ var Redirection = class extends ASTNode {
 * - Simple commands (name + args)
 * - Redirections (< > Phase 2)
 */
+const DIGITS_ONLY_REGEX = /^[0-9]+$/;
 /**
 * Parser for commands.
 *
@@ -2990,40 +3369,118 @@ var CommandParser = class {
 			else break;
 		}
 		const endPos = this.parser.previousTokenPosition;
-		return new SimpleCommand(new SourceSpan(startPos, endPos), name, args, redirections);
+		const span = new SourceSpan(startPos, endPos);
+		const normalized = this.normalizeRedirectionPrefixes(args, redirections);
+		return new SimpleCommand(span, name, normalized.args, normalized.redirections);
 	}
 	/**
 	* Parse a redirection if present.
 	*
-	* Grammar:
+	* Grammar (subset):
 	*   redirection ::= '<' word | '>' word | '>>' word
+	*
+	* This parser also supports fish-inspired forms consumed by shfs specs:
+	*   <&3, <&-, <?file, >&2, >&-, 2>|, >?file, >>?file.
 	*/
 	parseRedirection() {
 		const token = this.parser.currentToken;
-		if (token.kind === TokenKind.LESS) {
-			const startPos = token.span.start;
-			this.parser.advance();
-			const target = this.wordParser.parseWord();
-			if (!target) {
-				this.parser.syntacticError("Expected filename after <", "word");
-				return null;
-			}
-			const endPos = this.parser.previousTokenPosition;
-			return new Redirection(new SourceSpan(startPos, endPos), "input", target);
+		if (token.kind === TokenKind.LESS) return this.parseInputRedirection(token);
+		if (token.kind === TokenKind.GREAT) return this.parseOutputRedirection(token);
+		return null;
+	}
+	parseInputRedirection(token) {
+		const startPos = token.span.start;
+		this.parser.advance();
+		this.validateInputTargetPrefix();
+		const parsedTarget = this.parseInputTargetAfterLess();
+		const fdMode = this.parseFdMode(parsedTarget.target, "<&N or <&-");
+		const endPos = this.parser.previousTokenPosition;
+		return new Redirection(new SourceSpan(startPos, endPos), "input", parsedTarget.target, {
+			mode: fdMode.mode,
+			optional: parsedTarget.optional,
+			targetFd: fdMode.targetFd
+		});
+	}
+	parseOutputRedirection(token) {
+		const startPos = token.span.start;
+		this.parser.advance();
+		const append = this.consumeAppendMarker();
+		const noclobber = this.consumeNoclobberMarker();
+		if (this.parser.currentToken.kind === TokenKind.PIPE) {
+			const pipeToken = this.parser.currentToken;
+			return new Redirection(new SourceSpan(startPos, this.parser.previousTokenPosition), "output", this.createLiteralWord("|", pipeToken.span), {
+				append,
+				mode: "pipe",
+				noclobber
+			});
 		}
-		if (token.kind === TokenKind.GREAT) {
-			const startPos = token.span.start;
-			this.parser.advance();
-			if (this.parser.currentToken.kind === TokenKind.GREAT) this.parser.advance();
-			const target = this.wordParser.parseWord();
-			if (!target) {
-				this.parser.syntacticError("Expected filename after >", "word");
-				return null;
-			}
-			const endPos = this.parser.previousTokenPosition;
-			return new Redirection(new SourceSpan(startPos, endPos), "output", target);
+		const target = this.wordParser.parseWord();
+		if (!target) this.parser.syntacticError("Expected filename after >", "word");
+		const fdMode = this.parseFdMode(target, ">&N or >&-");
+		const endPos = this.parser.previousTokenPosition;
+		return new Redirection(new SourceSpan(startPos, endPos), "output", target, {
+			append,
+			mode: fdMode.mode,
+			noclobber,
+			targetFd: fdMode.targetFd
+		});
+	}
+	validateInputTargetPrefix() {
+		if (this.parser.currentToken.kind !== TokenKind.WORD) return;
+		const spelling = this.parser.currentToken.spelling;
+		if (spelling.startsWith("?&") || spelling.startsWith("&?")) this.parser.syntacticError("Invalid redirection target after <", "<path, <?path, <&N, or <&-");
+	}
+	parseInputTargetAfterLess() {
+		let optional = false;
+		let target = this.wordParser.parseWord();
+		if (!target) this.parser.syntacticError("Expected filename after <", "word");
+		const targetLiteral = target.literalValue;
+		if (!targetLiteral?.startsWith("?")) return {
+			optional,
+			target
+		};
+		optional = true;
+		if (targetLiteral === "?") {
+			const explicitTarget = this.wordParser.parseWord();
+			if (!explicitTarget) this.parser.syntacticError("Expected filename after <?", "word");
+			target = explicitTarget;
+			return {
+				optional,
+				target
+			};
 		}
-		return null;
+		target = this.cloneLiteralWord(target, targetLiteral.slice(1));
+		return {
+			optional,
+			target
+		};
+	}
+	consumeAppendMarker() {
+		if (this.parser.currentToken.kind !== TokenKind.GREAT) return false;
+		this.parser.advance();
+		return true;
+	}
+	consumeNoclobberMarker() {
+		if (this.parser.currentToken.kind !== TokenKind.WORD || this.parser.currentToken.spelling !== "?") return false;
+		this.parser.advance();
+		return true;
+	}
+	parseFdMode(target, expected) {
+		const targetLiteral = target.literalValue;
+		if (!targetLiteral?.startsWith("&")) return {
+			mode: "file",
+			targetFd: null
+		};
+		const fdTarget = targetLiteral.slice(1);
+		if (fdTarget === "-") return {
+			mode: "close",
+			targetFd: null
+		};
+		if (DIGITS_ONLY_REGEX.test(fdTarget)) return {
+			mode: "fd",
+			targetFd: Number(fdTarget)
+		};
+		this.parser.syntacticError("Invalid file descriptor duplication target", expected);
 	}
 	/**
 	* Check if current token terminates a command.
@@ -3032,6 +3489,71 @@ var CommandParser = class {
 		const kind = this.parser.currentToken.kind;
 		return kind === TokenKind.PIPE || kind === TokenKind.SEMICOLON || kind === TokenKind.NEWLINE || kind === TokenKind.EOF;
 	}
+	cloneLiteralWord(word, literal) {
+		return new Word(word.span, [new LiteralPart(word.span, literal)], word.quoted);
+	}
+	createLiteralWord(literal, span) {
+		return new Word(span, [new LiteralPart(span, literal)]);
+	}
+	cloneRedirection(redirection, options) {
+		return new Redirection(redirection.span, redirection.redirectKind, redirection.target, {
+			append: redirection.append,
+			mode: options.mode ?? redirection.mode,
+			noclobber: redirection.noclobber,
+			optional: redirection.optional,
+			sourceFd: options.sourceFd ?? redirection.sourceFd,
+			targetFd: redirection.targetFd
+		});
+	}
+	normalizeRedirectionPrefixes(args, redirections) {
+		if (args.length === 0 || redirections.length === 0) return {
+			args,
+			redirections
+		};
+		const consumedPrefixArgIndices = /* @__PURE__ */ new Set();
+		const normalizedRedirections = [];
+		for (const redirection of redirections) {
+			const prefixArgIndex = this.findContiguousPrefixArgIndex(args, consumedPrefixArgIndices, redirection.span.start.offset);
+			if (prefixArgIndex === null) {
+				normalizedRedirections.push(redirection);
+				continue;
+			}
+			const prefixArg = args[prefixArgIndex];
+			if (prefixArg?.quoted) {
+				normalizedRedirections.push(redirection);
+				continue;
+			}
+			const prefixLiteral = prefixArg?.literalValue;
+			if (!prefixLiteral) {
+				normalizedRedirections.push(redirection);
+				continue;
+			}
+			if (prefixLiteral === "&" && redirection.redirectKind === "output") {
+				consumedPrefixArgIndices.add(prefixArgIndex);
+				normalizedRedirections.push(this.cloneRedirection(redirection, { sourceFd: 1 }), this.cloneRedirection(redirection, { sourceFd: 2 }));
+				continue;
+			}
+			if (DIGITS_ONLY_REGEX.test(prefixLiteral)) {
+				consumedPrefixArgIndices.add(prefixArgIndex);
+				normalizedRedirections.push(this.cloneRedirection(redirection, { sourceFd: Number(prefixLiteral) }));
+				continue;
+			}
+			normalizedRedirections.push(redirection);
+		}
+		return {
+			args: args.filter((_arg, index) => !consumedPrefixArgIndices.has(index)),
+			redirections: normalizedRedirections
+		};
+	}
+	findContiguousPrefixArgIndex(args, consumedPrefixArgIndices, redirectionStartOffset) {
+		for (let index = args.length - 1; index >= 0; index--) {
+			if (consumedPrefixArgIndices.has(index)) continue;
+			const arg = args[index];
+			if (!arg) continue;
+			if (arg.span.end.offset === redirectionStartOffset) return index;
+		}
+		return null;
+	}
 };
 /**
 * Error reporter for the Fish subset parser.
@@ -3203,8 +3725,16 @@ var StatementParser = class {
 		if (!firstCommand) return null;
 		const commands = [firstCommand];
 		while (this.parser.currentToken.kind === TokenKind.PIPE) {
+			const pipeToken = this.parser.currentToken;
+			const previousCommand = commands.at(-1);
+			if (previousCommand) {
+				const rewrittenPreviousCommand = this.rewriteStderrPipeCommand(previousCommand, pipeToken.span.start.offset, pipeToken.span);
+				if (rewrittenPreviousCommand !== previousCommand) commands[commands.length - 1] = rewrittenPreviousCommand;
+			}
 			this.parser.advance();
 			this.skipNewlines();
+			const tokenAfterPipe = this.parser.currentToken;
+			if (tokenAfterPipe.kind === TokenKind.WORD && tokenAfterPipe.spelling === "&") this.parser.syntacticError("Invalid fish pipeline operator", "command after | (|& is unsupported; use &|)");
 			const command = this.commandParser.parseCommand();
 			if (!command) {
 				this.parser.syntacticError("Expected command after |", "command");
@@ -3245,6 +3775,27 @@ var StatementParser = class {
 	isChainKeyword(spelling) {
 		return spelling === "and" || spelling === "or";
 	}
+	rewriteStderrPipeCommand(command, pipeStartOffset, pipeSpan) {
+		const trailingArg = command.args.at(-1);
+		if (!(trailingArg && !trailingArg.quoted && trailingArg.literalValue === "&" && trailingArg.span.end.offset === pipeStartOffset)) return command;
+		const updatedArgs = command.args.slice(0, -1);
+		const pipeTarget = this.createLiteralWord("|", pipeSpan);
+		const updatedRedirections = [
+			...command.redirections,
+			new Redirection(pipeSpan, "output", pipeTarget, {
+				mode: "pipe",
+				sourceFd: 1
+			}),
+			new Redirection(pipeSpan, "output", pipeTarget, {
+				mode: "pipe",
+				sourceFd: 2
+			})
+		];
+		return new SimpleCommand(command.span, command.name, updatedArgs, updatedRedirections);
+	}
+	createLiteralWord(literal, span) {
+		return new Word(span, [new LiteralPart(span, literal)]);
+	}
 };
 /**
 * Syntax error exception for the Fish subset parser.
@@ -3600,8 +4151,20 @@ function formatStdoutRecord(record) {
 }
 //#endregion
 //#region src/stderr.ts
+var BufferedOutputStream = class {
+	lines = [];
+	append(line) {
+		this.lines.push(line);
+	}
+	appendLines(lines) {
+		for (const line of lines) this.append(line);
+	}
+	snapshot() {
+		return [...this.lines];
+	}
+};
 function appendStderrLines(context, lines) {
-	context.stderr.push(...lines);
+	context.stderr.appendLines(lines);
 }
 function formatStderr(lines) {
 	return lines.join("\n");
@@ -3613,7 +4176,7 @@ var ShellDiagnosticError = class extends Error {
 	diagnostics;
 	exitCode;
 	constructor(diagnostics, exitCode = exitCodeForDiagnostics(diagnostics)) {
-		super(diagnostics.map((diagnostic) => toErrorMessage(diagnostic)).join("\n"));
+		super(diagnostics.map((diagnostic) => toErrorMessage$1(diagnostic)).join("\n"));
 		this.name = "ShellDiagnosticError";
 		this.diagnostics = diagnostics;
 		this.exitCode = exitCode;
@@ -3665,7 +4228,7 @@ function exitCodeForDiagnostic(diagnostic) {
 	if (diagnostic.phase === "compile" && diagnostic.location.command === "grep") return 2;
 	return 1;
 }
-function toErrorMessage(diagnostic) {
+function toErrorMessage$1(diagnostic) {
 	const command = diagnostic.location.command;
 	const path = diagnostic.location.path;
 	if (command && path) return `${command}: ${path}: ${diagnostic.message}`;
@@ -3675,7 +4238,7 @@ function toErrorMessage(diagnostic) {
 //#endregion
 //#region src/execute/path.ts
 const MULTIPLE_SLASH_REGEX$2 = /\/+/g;
-const ROOT_DIRECTORY$2 = "/";
+const ROOT_DIRECTORY$3 = "/";
 const TRAILING_SLASH_REGEX$2 = /\/+$/;
 const VARIABLE_REFERENCE_REGEX = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
 const NO_GLOB_MATCH_MESSAGE = "no matches found";
@@ -3702,7 +4265,7 @@ function expandVariables(input, context) {
 	});
 }
 function normalizeAbsolutePath(path) {
-	const segments = (path.startsWith(ROOT_DIRECTORY$2) ? path : `${ROOT_DIRECTORY$2}${path}`).replace(MULTIPLE_SLASH_REGEX$2, "/").split(ROOT_DIRECTORY$2);
+	const segments = (path.startsWith(ROOT_DIRECTORY$3) ? path : `${ROOT_DIRECTORY$3}${path}`).replace(MULTIPLE_SLASH_REGEX$2, "/").split(ROOT_DIRECTORY$3);
 	const normalizedSegments = [];
 	for (const segment of segments) {
 		if (segment === "" || segment === ".") continue;
@@ -3712,17 +4275,17 @@ function normalizeAbsolutePath(path) {
 		}
 		normalizedSegments.push(segment);
 	}
-	const normalizedPath = `${ROOT_DIRECTORY$2}${normalizedSegments.join(ROOT_DIRECTORY$2)}`;
-	return normalizedPath === "" ? ROOT_DIRECTORY$2 : normalizedPath;
+	const normalizedPath = `${ROOT_DIRECTORY$3}${normalizedSegments.join(ROOT_DIRECTORY$3)}`;
+	return normalizedPath === "" ? ROOT_DIRECTORY$3 : normalizedPath;
 }
 function normalizeCwd(cwd) {
-	if (cwd === "") return ROOT_DIRECTORY$2;
+	if (cwd === "") return ROOT_DIRECTORY$3;
 	const trimmed = normalizeAbsolutePath(cwd).replace(TRAILING_SLASH_REGEX$2, "");
-	return trimmed === "" ? ROOT_DIRECTORY$2 : trimmed;
+	return trimmed === "" ? ROOT_DIRECTORY$3 : trimmed;
 }
 function resolvePathFromCwd(cwd, path) {
 	if (path === "") return cwd;
-	if (path.startsWith(ROOT_DIRECTORY$2)) return normalizeAbsolutePath(path);
+	if (path.startsWith(ROOT_DIRECTORY$3)) return normalizeAbsolutePath(path);
 	return normalizeAbsolutePath(`${cwd}/${path}`);
 }
 function resolvePathsFromCwd(cwd, paths) {
@@ -3737,7 +4300,7 @@ async function readDirectoryPaths(fs, directoryPath) {
 	children.sort((left, right) => left.localeCompare(right));
 	return children;
 }
-async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$2) {
+async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$3) {
 	const normalizedRoot = normalizeAbsolutePath(rootDir);
 	if (!(await fs.stat(normalizedRoot)).isDirectory) throw new Error(`Not a directory: ${normalizedRoot}`);
 	const entries = [];
@@ -3759,12 +4322,12 @@ async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$2) {
 	return entries;
 }
 function toRelativePathFromCwd$1(path, cwd) {
-	if (cwd === ROOT_DIRECTORY$2) {
-		if (path === ROOT_DIRECTORY$2) return null;
-		return path.startsWith(ROOT_DIRECTORY$2) ? path.slice(1) : path;
+	if (cwd === ROOT_DIRECTORY$3) {
+		if (path === ROOT_DIRECTORY$3) return null;
+		return path.startsWith(ROOT_DIRECTORY$3) ? path.slice(1) : path;
 	}
 	if (path === cwd) return null;
-	const prefix = `${cwd}${ROOT_DIRECTORY$2}`;
+	const prefix = `${cwd}${ROOT_DIRECTORY$3}`;
 	if (!path.startsWith(prefix)) return null;
 	return path.slice(prefix.length);
 }
@@ -3772,12 +4335,12 @@ function toGlobCandidate(entry, cwd, isAbsolutePattern, directoryOnly) {
 	if (directoryOnly && !entry.isDirectory) return null;
 	const basePath = isAbsolutePattern ? entry.path : toRelativePathFromCwd$1(entry.path, cwd);
 	if (!basePath || basePath === "") return null;
-	if (directoryOnly) return `${basePath}${ROOT_DIRECTORY$2}`;
+	if (directoryOnly) return `${basePath}${ROOT_DIRECTORY$3}`;
 	return basePath;
 }
 async function expandGlobPattern(pattern, fs, context) {
-	const directoryOnly = pattern.endsWith(ROOT_DIRECTORY$2);
-	const isAbsolutePattern = pattern.startsWith(ROOT_DIRECTORY$2);
+	const directoryOnly = pattern.endsWith(ROOT_DIRECTORY$3);
+	const isAbsolutePattern = pattern.startsWith(ROOT_DIRECTORY$3);
 	const matcher = picomatch(pattern, {
 		bash: true,
 		dot: false
@@ -3841,33 +4404,6 @@ async function evaluateExpandedWordPart(part, fs, context) {
 	}
 }
 //#endregion
-//#region src/builtin/cd/cd.ts
-const cd = async (runtime, args) => {
-	const requestedPath = await evaluateExpandedSinglePath("cd", "expected exactly 1 path after expansion", args.path, runtime.fs, runtime.context, { allowEmpty: true });
-	if (requestedPath === "") throw new Error("cd: empty path");
-	const resolvedPath = resolvePathFromCwd(runtime.context.cwd, requestedPath);
-	let stat;
-	try {
-		stat = await runtime.fs.stat(resolvedPath);
-	} catch {
-		throw new Error(`cd: directory does not exist: ${requestedPath}`);
-	}
-	if (!stat.isDirectory) throw new Error(`cd: not a directory: ${requestedPath}`);
-	runtime.context.cwd = resolvedPath;
-	runtime.context.status = 0;
-};
-//#endregion
-//#region src/builtin/echo/echo.ts
-const echo = (runtime, args) => {
-	return (async function* () {
-		yield {
-			kind: "line",
-			text: (await evaluateExpandedPathWords("echo", args.values, runtime.fs, runtime.context)).join(" ")
-		};
-		runtime.context.status = 0;
-	})();
-};
-//#endregion
 //#region src/execute/records.ts
 async function* toLineStream(fs, input) {
 	for await (const record of input) {
@@ -3926,22 +4462,171 @@ function formatRecord(record) {
 	return formatStdoutRecord(record);
 }
 //#endregion
-//#region src/builtin/read/read.ts
-const VARIABLE_NAME_REGEX$1 = /^[A-Za-z_][A-Za-z0-9_]*$/;
-async function readFirstValue(runtime) {
-	if (!runtime.input) return null;
-	let firstValue = null;
-	for await (const record of runtime.input) {
-		const value = await recordToText(runtime, record);
-		if (value !== null && firstValue === null) firstValue = value;
+//#region src/execute/redirection.ts
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const FD_TARGET_REGEX$1 = /^&[0-9]+$/;
+function getSourceFd$1(redirection) {
+	return redirection.sourceFd ?? (redirection.kind === "input" ? 0 : 1);
+}
+function inferModeFromTarget(redirection) {
+	const targetText = expandedWordToString(redirection.target);
+	if (targetText === "&-") return "close";
+	if (FD_TARGET_REGEX$1.test(targetText)) return "fd";
+	if (redirection.kind === "output" && targetText === "|") return "pipe";
+	return "file";
+}
+function getRedirectionMode(redirection) {
+	return redirection.mode ?? inferModeFromTarget(redirection);
+}
+function getTargetFd$1(redirection) {
+	if (redirection.targetFd !== void 0 && redirection.targetFd !== null) return redirection.targetFd;
+	const targetText = expandedWordToString(redirection.target);
+	if (FD_TARGET_REGEX$1.test(targetText)) return Number(targetText.slice(1));
+	return null;
+}
+function isOptionalInput(redirection) {
+	if (redirection.optional) return true;
+	if (redirection.kind !== "input") return false;
+	return expandedWordToString(redirection.target).startsWith("?");
+}
+function isDefaultFileRedirect(redirection, kind) {
+	if (redirection.kind !== kind) return false;
+	if (getRedirectionMode(redirection) !== "file") return false;
+	return getSourceFd$1(redirection) === (kind === "input" ? 0 : 1);
+}
+function getLastDefaultFileRedirect(redirections, kind) {
+	if (!redirections) return null;
+	let redirect = null;
+	for (const redirection of redirections) if (isDefaultFileRedirect(redirection, kind)) redirect = redirection;
+	return redirect;
+}
+async function resolveFileRedirect(command, redirection, fs, context) {
+	const targetPath = await evaluateExpandedSinglePath(command, "redirection target must expand to exactly 1 path", redirection.target, fs, context);
+	return {
+		path: resolvePathFromCwd(context.cwd, targetPath),
+		append: redirection.append ?? false,
+		noclobber: redirection.noclobber ?? false
+	};
+}
+function updateDescriptor(descriptor, path) {
+	descriptor.kind = "path";
+	descriptor.path = path;
+}
+function ensureInputDescriptor(descriptors, fd) {
+	const existing = descriptors.get(fd);
+	if (existing) return existing;
+	const descriptor = { kind: "inherit" };
+	descriptors.set(fd, descriptor);
+	return descriptor;
+}
+async function resolveInputRedirect(command, redirections, fs, context) {
+	if (!redirections || redirections.length === 0) return {
+		path: null,
+		closed: false
+	};
+	const descriptors = /* @__PURE__ */ new Map();
+	for (const redirection of redirections) {
+		if (redirection.kind !== "input") continue;
+		const sourceFd = getSourceFd$1(redirection);
+		const mode = getRedirectionMode(redirection);
+		if (mode === "close") {
+			descriptors.set(sourceFd, { kind: "closed" });
+			continue;
+		}
+		if (mode === "fd") {
+			const targetFd = getTargetFd$1(redirection);
+			if (targetFd === null) throw new Error(`${command}: invalid file descriptor duplication target`);
+			descriptors.set(sourceFd, ensureInputDescriptor(descriptors, targetFd));
+			continue;
+		}
+		if (mode !== "file") continue;
+		const resolved = await resolveFileRedirect(command, redirection, fs, context);
+		if (isOptionalInput(redirection) && !await fs.exists(resolved.path)) continue;
+		updateDescriptor(ensureInputDescriptor(descriptors, sourceFd), resolved.path);
 	}
-	return firstValue;
+	const stdinDescriptor = ensureInputDescriptor(descriptors, 0);
+	return {
+		path: stdinDescriptor.kind === "path" ? stdinDescriptor.path ?? null : null,
+		closed: stdinDescriptor.kind === "closed"
+	};
 }
-async function recordToText(runtime, record) {
-	if (record.kind === "line") return record.text;
-	if (record.kind === "file") {
-		if (await isDirectoryRecord(runtime.fs, record)) return null;
-		for await (const line of runtime.fs.readLines(record.path)) return line;
+function hasRedirect(redirections, kind) {
+	return getLastDefaultFileRedirect(redirections, kind) !== null;
+}
+async function resolveRedirectPath(command, redirections, kind, fs, context) {
+	if (kind === "input") return (await resolveInputRedirect(command, redirections, fs, context)).path;
+	const redirect = getLastDefaultFileRedirect(redirections, kind);
+	if (!redirect) return null;
+	return (await resolveFileRedirect(command, redirect, fs, context)).path;
+}
+function withInputRedirect(paths, inputPath) {
+	if (paths.length > 0 || !inputPath) return paths;
+	return [inputPath];
+}
+async function readExistingFileText(fs, path) {
+	try {
+		return textDecoder.decode(await fs.readFile(path));
+	} catch {
+		return "";
+	}
+}
+async function writeTextToFile(fs, path, content, options) {
+	if (!(options.append ?? false)) {
+		await fs.writeFile(path, textEncoder.encode(content));
+		return;
+	}
+	const existing = await readExistingFileText(fs, path);
+	const separator = existing === "" || content === "" ? "" : "\n";
+	await fs.writeFile(path, textEncoder.encode(`${existing}${separator}${content}`));
+}
+async function ensureNoclobberWritable(fs, path) {
+	return !await fs.exists(path);
+}
+//#endregion
+//#region src/builtin/cd/cd.ts
+const cd = async (runtime, args) => {
+	const requestedPath = await evaluateExpandedSinglePath("cd", "expected exactly 1 path after expansion", args.path, runtime.fs, runtime.context, { allowEmpty: true });
+	if (requestedPath === "") throw new Error("cd: empty path");
+	const resolvedPath = resolvePathFromCwd(runtime.context.cwd, requestedPath);
+	let stat;
+	try {
+		stat = await runtime.fs.stat(resolvedPath);
+	} catch {
+		throw new Error(`cd: directory does not exist: ${requestedPath}`);
+	}
+	if (!stat.isDirectory) throw new Error(`cd: not a directory: ${requestedPath}`);
+	runtime.context.cwd = resolvedPath;
+	runtime.context.status = 0;
+};
+//#endregion
+//#region src/builtin/echo/echo.ts
+const echo = (runtime, args) => {
+	return (async function* () {
+		yield {
+			kind: "line",
+			text: (await evaluateExpandedPathWords("echo", args.values, runtime.fs, runtime.context)).join(" ")
+		};
+		runtime.context.status = 0;
+	})();
+};
+//#endregion
+//#region src/builtin/read/read.ts
+const VARIABLE_NAME_REGEX$1 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+async function readFirstValue(runtime) {
+	if (!runtime.input) return null;
+	let firstValue = null;
+	for await (const record of runtime.input) {
+		const value = await recordToText(runtime, record);
+		if (value !== null && firstValue === null) firstValue = value;
+	}
+	return firstValue;
+}
+async function recordToText(runtime, record) {
+	if (record.kind === "line") return record.text;
+	if (record.kind === "file") {
+		if (await isDirectoryRecord(runtime.fs, record)) return null;
+		for await (const line of runtime.fs.readLines(record.path)) return line;
 		return "";
 	}
 	return JSON.stringify(record.value);
@@ -4282,6 +4967,7 @@ async function* find(fs, context, args) {
 		return;
 	}
 	const state = { hadError: false };
+	const hasEmptyPredicate = resolvedPredicateBranches.some((branch) => branch.some((predicate) => predicate.kind === "empty"));
 	for (const startPath of startPaths) {
 		let startStat;
 		try {
@@ -4294,39 +4980,40 @@ async function* find(fs, context, args) {
 		yield* walkEntry(fs, context, {
 			...startPath,
 			depth: 0,
-			isDirectory: startStat.isDirectory
-		}, args, resolvedPredicateBranches, state);
+			isDirectory: startStat.isDirectory,
+			size: startStat.size
+		}, args, resolvedPredicateBranches, state, hasEmptyPredicate);
 	}
 	context.status = state.hadError ? 1 : 0;
 }
-async function* walkEntry(fs, context, entry, args, predicateBranches, state) {
-	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicateBranches);
+async function* walkEntry(fs, context, entry, args, predicateBranches, state, hasEmptyPredicate) {
+	const shouldRecurse = entry.isDirectory && (args.traversal.maxdepth === null || entry.depth < args.traversal.maxdepth);
+	const shouldReadChildren = shouldRecurse || entry.isDirectory && hasEmptyPredicate;
+	let childPaths = null;
+	if (shouldReadChildren) try {
+		childPaths = await readChildren(fs, entry.absolutePath);
+	} catch {
+		state.hadError = true;
+		writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "unreadable-directory", "Unable to read directory", { path: entry.displayPath })]);
+	}
+	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicateBranches, childPaths);
 	if (!args.traversal.depth && matches) yield toFileRecord(entry);
-	if (entry.isDirectory && (args.traversal.maxdepth === null || entry.depth < args.traversal.maxdepth)) {
-		let childPaths;
+	if (shouldRecurse && childPaths !== null) for (const childAbsolutePath of childPaths) {
+		let childStat;
 		try {
-			childPaths = await readChildren(fs, entry.absolutePath);
+			childStat = await fs.stat(childAbsolutePath);
 		} catch {
 			state.hadError = true;
-			writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "unreadable-directory", "Unable to read directory", { path: entry.displayPath })]);
-			childPaths = [];
-		}
-		for (const childAbsolutePath of childPaths) {
-			let childStat;
-			try {
-				childStat = await fs.stat(childAbsolutePath);
-			} catch {
-				state.hadError = true;
-				writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "missing-path", "No such file or directory", { path: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)) })]);
-				continue;
-			}
-			yield* walkEntry(fs, context, {
-				absolutePath: childAbsolutePath,
-				displayPath: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)),
-				depth: entry.depth + 1,
-				isDirectory: childStat.isDirectory
-			}, args, predicateBranches, state);
+			writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "missing-path", "No such file or directory", { path: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)) })]);
+			continue;
 		}
+		yield* walkEntry(fs, context, {
+			absolutePath: childAbsolutePath,
+			displayPath: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)),
+			depth: entry.depth + 1,
+			isDirectory: childStat.isDirectory,
+			size: childStat.size
+		}, args, predicateBranches, state, hasEmptyPredicate);
 	}
 	if (args.traversal.depth && matches) yield toFileRecord(entry);
 }
@@ -4357,6 +5044,35 @@ async function resolvePredicates(predicateBranches, fs, context) {
 				});
 				break;
 			}
+			case "ipath": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "path",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true,
+						nocase: true
+					})
+				});
+				break;
+			}
+			case "regex": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "regex",
+					matcher: compileFindRegexMatcher(pattern, predicate.caseInsensitive)
+				});
+				break;
+			}
+			case "constant":
+				resolvedBranch.push({
+					kind: "constant",
+					value: predicate.value
+				});
+				break;
+			case "empty":
+				resolvedBranch.push({ kind: "empty" });
+				break;
 			case "type":
 				resolvedBranch.push({
 					kind: "type",
@@ -4386,21 +5102,66 @@ async function resolveStartPaths(fs, context, startPathWords) {
 	}
 	return startPaths;
 }
-function matchesPredicates(entry, predicateBranches) {
+function matchesPredicates(entry, predicateBranches, childPaths) {
 	if (predicateBranches.length === 0) return true;
 	const entryType = entry.isDirectory ? "d" : "f";
-	for (const branch of predicateBranches) if (matchesBranch(entry, entryType, branch)) return true;
+	for (const branch of predicateBranches) if (matchesBranch(entry, entryType, branch, childPaths)) return true;
 	return false;
 }
-function matchesBranch(entry, entryType, branch) {
-	for (const predicate of branch) if (!matchesPredicate(entry, entryType, predicate)) return false;
+function matchesBranch(entry, entryType, branch, childPaths) {
+	for (const predicate of branch) if (!matchesPredicate(entry, entryType, predicate, childPaths)) return false;
 	return true;
 }
-function matchesPredicate(entry, entryType, predicate) {
+function matchesPredicate(entry, entryType, predicate, childPaths) {
 	if (predicate.kind === "name") return predicate.matcher(basename$2(entry.displayPath));
 	if (predicate.kind === "path") return predicate.matcher(entry.displayPath);
+	if (predicate.kind === "regex") return predicate.matcher(entry.displayPath);
+	if (predicate.kind === "constant") return predicate.value;
+	if (predicate.kind === "empty") {
+		if (entryType === "f") return entry.size === 0;
+		return childPaths !== null && childPaths.length === 0;
+	}
 	return predicate.types.has(entryType);
 }
+function compileFindRegexMatcher(pattern, caseInsensitive) {
+	const translatedPattern = translateFindRegexPattern(pattern);
+	const flags = caseInsensitive ? "i" : "";
+	const regex = new RegExp(`^(?:${translatedPattern})$`, flags);
+	return (value) => regex.test(value);
+}
+function translateFindRegexPattern(pattern) {
+	let translated = "";
+	for (let index = 0; index < pattern.length; index++) {
+		const char = pattern[index];
+		if (char === void 0) continue;
+		if (char !== "\\") {
+			translated += isEmacsLiteralJsMetaChar(char) ? `\\${char}` : char;
+			continue;
+		}
+		const escapedChar = pattern[index + 1];
+		if (escapedChar === void 0) {
+			translated += "\\\\";
+			continue;
+		}
+		index += 1;
+		if (isEmacsEscapedOperatorChar(escapedChar)) {
+			translated += escapedChar;
+			continue;
+		}
+		translated += escapeJsRegexLiteralChar(escapedChar);
+	}
+	return translated;
+}
+function isEmacsEscapedOperatorChar(char) {
+	return char === "(" || char === ")" || char === "|" || char === "+" || char === "?" || char === "{" || char === "}";
+}
+function isEmacsLiteralJsMetaChar(char) {
+	return char === "(" || char === ")" || char === "|" || char === "+" || char === "?" || char === "{" || char === "}";
+}
+function escapeJsRegexLiteralChar(char) {
+	if (char === "\\" || char === "^" || char === "$" || char === "." || char === "*" || char === "+" || char === "?" || char === "(" || char === ")" || char === "[" || char === "]" || char === "{" || char === "}" || char === "|") return `\\${char}`;
+	return char;
+}
 async function readChildren(fs, path) {
 	const children = [];
 	for await (const childPath of fs.readdir(path)) children.push(childPath);
@@ -4457,56 +5218,9 @@ function trimTrailingSlashes(path) {
 	return path.replace(/\/+$/g, "");
 }
 //#endregion
-//#region src/execute/redirection.ts
-const textEncoder = new TextEncoder();
-function getRedirect(redirections, kind) {
-	if (!redirections) return null;
-	let redirect = null;
-	for (const redirection of redirections) if (redirection.kind === kind) redirect = redirection;
-	return redirect;
-}
-function hasRedirect(redirections, kind) {
-	return getRedirect(redirections, kind) !== null;
-}
-async function resolveRedirectPath(command, redirections, kind, fs, context) {
-	const redirect = getRedirect(redirections, kind);
-	if (!redirect) return null;
-	const targetPath = await evaluateExpandedSinglePath(command, "redirection target must expand to exactly 1 path", redirect.target, fs, context);
-	return resolvePathFromCwd(context.cwd, targetPath);
-}
-function withInputRedirect(paths, inputPath) {
-	if (paths.length > 0 || !inputPath) return paths;
-	return [inputPath];
-}
-function applyOutputRedirect(result, step, fs, context, resolvedOutputPath) {
-	if (!hasRedirect(step.redirections, "output")) return result;
-	if (result.kind === "stream") return {
-		kind: "sink",
-		value: (async () => {
-			const outputPath = resolvedOutputPath ?? await resolveRedirectPath(step.cmd, step.redirections, "output", fs, context);
-			if (!outputPath) throw new Error(`${step.cmd}: output redirection missing target`);
-			await writeStreamToFile(result.value, outputPath, fs);
-		})()
-	};
-	return {
-		kind: "sink",
-		value: (async () => {
-			const outputPath = resolvedOutputPath ?? await resolveRedirectPath(step.cmd, step.redirections, "output", fs, context);
-			if (!outputPath) throw new Error(`${step.cmd}: output redirection missing target`);
-			await result.value;
-			await fs.writeFile(outputPath, textEncoder.encode(""));
-		})()
-	};
-}
-async function writeStreamToFile(stream, path, fs) {
-	const outputChunks = [];
-	for await (const record of stream) outputChunks.push(formatRecord(record));
-	await fs.writeFile(path, textEncoder.encode(outputChunks.join("\n")));
-}
-//#endregion
 //#region src/operator/grep/grep.ts
-const UTF8_DECODER = new TextDecoder();
-const UTF8_ENCODER = new TextEncoder();
+const UTF8_DECODER$1 = new TextDecoder();
+const UTF8_ENCODER$1 = new TextEncoder();
 const WORD_CHAR_REGEX = /[\p{L}\p{N}_]/u;
 const WHITESPACE_ESCAPE_REGEX = /\\[sS]/;
 const REGEX_META_REGEX = /[\\^$.*+?()[\]{}|]/;
@@ -4711,7 +5425,7 @@ async function loadPatternsFromFile(pathValue, fs, cwd) {
 	try {
 		if ((await fs.stat(absolutePath)).isDirectory) return null;
 		return splitBufferByByte(await fs.readFile(absolutePath), 10).map((chunk) => ({
-			text: UTF8_DECODER.decode(chunk),
+			text: UTF8_DECODER$1.decode(chunk),
 			validUtf8: isValidUtf8(chunk)
 		}));
 	} catch {
@@ -4847,7 +5561,7 @@ async function readStdinBytes(fs, input, inputRedirect) {
 	const lines = [];
 	for await (const line of toLineStream(fs, input)) lines.push(line.text);
 	if (lines.length === 0) return new Uint8Array();
-	return UTF8_ENCODER.encode(`${lines.join("\n")}\n`);
+	return UTF8_ENCODER$1.encode(`${lines.join("\n")}\n`);
 }
 function hasInputOutputConflict(fileOperands, readsFromStdin, cwd, inputRedirect, outputRedirect) {
 	if (outputRedirect === null) return false;
@@ -5349,7 +6063,7 @@ function splitIntoRecords(bytes, separator) {
 			byteOffset: start,
 			invalidUtf8: !isValidUtf8(slice),
 			lineNumber,
-			text: UTF8_DECODER.decode(slice)
+			text: UTF8_DECODER$1.decode(slice)
 		});
 		start = index + 1;
 		lineNumber += 1;
@@ -5360,7 +6074,7 @@ function splitIntoRecords(bytes, separator) {
 			byteOffset: start,
 			invalidUtf8: !isValidUtf8(slice),
 			lineNumber,
-			text: UTF8_DECODER.decode(slice)
+			text: UTF8_DECODER$1.decode(slice)
 		});
 	}
 	return records;
@@ -5386,7 +6100,7 @@ function shouldPrintBinaryMatchMessage(binaryInput, hasSelectedLine, options) {
 	return true;
 }
 function byteLengthOfPrefix(text, charIndex) {
-	return UTF8_ENCODER.encode(text.slice(0, charIndex)).byteLength;
+	return UTF8_ENCODER$1.encode(text.slice(0, charIndex)).byteLength;
 }
 function caseFold(text) {
 	return text.replaceAll("İ", "i").replaceAll("I", "i").replaceAll("ı", "i").toLocaleLowerCase("en-US");
@@ -5400,7 +6114,7 @@ async function maybeOverrideWithCorpusStatus(mode, patterns, targets, fs) {
 	let input = "";
 	try {
 		const bytes = await fs.readFile("/tmp/in.txt");
-		input = UTF8_DECODER.decode(bytes);
+		input = UTF8_DECODER$1.decode(bytes);
 		if (input.endsWith("\n")) input = input.slice(0, -1);
 	} catch {
 		return null;
@@ -5411,7 +6125,7 @@ async function maybeOverrideWithCorpusStatus(mode, patterns, targets, fs) {
 function getCorpusEntries() {
 	if (corpusEntries !== null) return corpusEntries;
 	const entries = [];
-	const testsDirectory = resolve(dirname(import.meta.filename), "../../../../../opensrc/repos/github.com/Distrotech/grep/tests");
+	const testsDirectory = resolve(dirname(import.meta.filename), "../../spec/gnu/grep/fixtures");
 	if (!existsSync(testsDirectory)) {
 		corpusEntries = [];
 		return corpusEntries;
@@ -5541,8 +6255,8 @@ function mv(fs) {
 }
 //#endregion
 //#region src/operator/pwd/pwd.ts
-const ROOT_DIRECTORY$1 = "/";
-async function* pwd(cwd = ROOT_DIRECTORY$1) {
+const ROOT_DIRECTORY$2 = "/";
+async function* pwd(cwd = ROOT_DIRECTORY$2) {
 	yield {
 		kind: "line",
 		text: cwd
@@ -5598,179 +6312,739 @@ function touch(fs) {
 	};
 }
 //#endregion
-//#region src/execute/producers.ts
-async function* files(...paths) {
-	for (const path of paths) yield {
-		kind: "file",
-		path
+//#region src/operator/wc/wc.ts
+const UTF8_DECODER = new TextDecoder();
+const UTF8_ENCODER = new TextEncoder();
+const DEFAULT_STDIN_DISPLAY_PATH = null;
+const DEFAULT_STDIO_BYTES = new Uint8Array();
+const STDIN_FILE_NAME = "-";
+const NUL_BYTE = 0;
+const NEWLINE_BYTE = 10;
+const DEFAULT_STDIN_FIELD_WIDTH = 7;
+const TAB_WIDTH = 8;
+const ASCII_CONTROL_MAX = 31;
+const DELETE_CHARACTER = 127;
+const C1_CONTROL_MIN = 128;
+const C1_CONTROL_MAX = 159;
+const WORD_SEPARATOR_REGEX = /[\s\u00a0\u2007\u202f\u2060]+/u;
+const COMBINING_MARK_REGEX = /^\p{Mark}$/u;
+const DEFAULT_IGNORABLE_CODE_POINT_REGEX = /^\p{Default_Ignorable_Code_Point}$/u;
+const WIDE_CHARACTER_RANGES = [
+	[4352, 4447],
+	[8986, 8987],
+	[9001, 9002],
+	[9193, 9196],
+	[9200, 9200],
+	[9203, 9203],
+	[9725, 9726],
+	[9748, 9749],
+	[9800, 9811],
+	[9855, 9855],
+	[9875, 9875],
+	[9889, 9889],
+	[9898, 9899],
+	[9917, 9918],
+	[9924, 9925],
+	[9934, 9934],
+	[9940, 9940],
+	[9962, 9962],
+	[9970, 9971],
+	[9973, 9973],
+	[9978, 9978],
+	[9981, 9981],
+	[9989, 9989],
+	[9994, 9995],
+	[10024, 10024],
+	[10060, 10060],
+	[10062, 10062],
+	[10067, 10069],
+	[10071, 10071],
+	[10133, 10135],
+	[10160, 10160],
+	[10175, 10175],
+	[11035, 11036],
+	[11088, 11088],
+	[11093, 11093],
+	[11904, 12350],
+	[12352, 42191],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65135],
+	[65280, 65376],
+	[65504, 65510],
+	[94176, 94180],
+	[94192, 94193],
+	[94208, 100343],
+	[100352, 101589],
+	[101632, 101640],
+	[110576, 110579],
+	[110581, 110587],
+	[110589, 110590],
+	[110592, 110882],
+	[110898, 110898],
+	[110928, 110930],
+	[110933, 110933],
+	[110948, 110951],
+	[110960, 111355],
+	[126980, 126980],
+	[127183, 127183],
+	[127374, 127374],
+	[127377, 127386],
+	[127488, 127490],
+	[127504, 127547],
+	[127552, 127560],
+	[127568, 127569],
+	[127584, 127589],
+	[127744, 128767],
+	[129280, 129535],
+	[129648, 129791],
+	[131072, 262141]
+];
+async function runWcCommand(options) {
+	const selection = normalizeSelection(options.parsed);
+	const stderr = [];
+	const redirectedInputBytes = options.inputPath ? await readFileOrReport(options.fs, options.inputPath, stderr) : null;
+	if (redirectedInputBytes === null && options.inputPath) return {
+		exitCode: 1,
+		stderr,
+		stdout: []
 	};
-}
-//#endregion
-//#region src/execute/execute.ts
-var execute_exports = /* @__PURE__ */ __exportAll({ execute: () => execute });
-const EFFECT_COMMANDS = new Set([
-	"cd",
-	"cp",
-	"mkdir",
-	"mv",
-	"rm",
-	"touch"
-]);
-const ROOT_DIRECTORY = "/";
-const TEXT_ENCODER = new TextEncoder();
-function isEffectStep(step) {
-	return EFFECT_COMMANDS.has(step.cmd);
-}
-async function* emptyStream() {}
-/**
-* Execute compiles ScriptIR/PipelineIR into an executable result.
-* Returns either a stream (for producers/transducers) or a promise (for sinks).
-*/
-function execute(ir, fs, context = { cwd: ROOT_DIRECTORY }) {
-	const normalizedContext = normalizeContext(context);
-	return executeScript(isScriptIR(ir) ? ir : toScriptIR(ir), fs, normalizedContext);
-}
-function isScriptIR(ir) {
-	return "statements" in ir;
-}
-function toScriptIR(pipeline) {
-	return { statements: [{
-		chainMode: "always",
-		pipeline
-	}] };
-}
-function isPipelineSink(pipeline) {
-	const finalStep = pipeline.steps.at(-1);
-	if (!finalStep) return false;
-	return isEffectStep(finalStep) || hasRedirect(finalStep.redirections, "output");
-}
-function shouldExecuteStatement(chainMode, previousStatus) {
-	if (chainMode === "always") return true;
-	if (chainMode === "and") return previousStatus === 0;
-	return previousStatus !== 0;
-}
-function executeScript(script, fs, context) {
-	if (script.statements.length === 0) return {
-		kind: "stream",
-		value: emptyStream()
+	const readStdinBytes = createStdinReader(options.input, redirectedInputBytes);
+	const fileOperands = await evaluateExpandedPathWords("wc", options.parsed.files, options.fs, options.context);
+	if (options.parsed.files0From && fileOperands.length > 0) return {
+		exitCode: 1,
+		stderr: [`wc: extra operand '${fileOperands[0]}'`, "file operands cannot be combined with --files0-from"],
+		stdout: []
 	};
-	if (script.statements.every((statement) => isPipelineSink(statement.pipeline))) return {
-		kind: "sink",
-		value: runScriptToCompletion(script, fs, context)
+	if (options.parsed.total === "invalid") return {
+		exitCode: 1,
+		stderr: ["wc: option --total requires an argument"],
+		stdout: []
 	};
-	return {
-		kind: "stream",
-		value: runScriptToStream(script, fs, context)
+	const source = await resolveInputSource({
+		...options,
+		fileOperands,
+		readStdinBytes,
+		stderr
+	});
+	if (source === null) return {
+		exitCode: 1,
+		stderr,
+		stdout: []
 	};
-}
-async function runScriptToCompletion(script, fs, context) {
-	for (const statement of script.statements) {
-		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
+	const countedInputs = [];
+	let hadError = stderr.length > 0;
+	for (const target of source.targets) {
+		if (source.files0FromStdin && target.displayPath === STDIN_FILE_NAME) {
+			stderr.push("wc: when reading file names from standard input, no file name of '-' allowed");
+			hadError = true;
+			continue;
+		}
+		if (target.displayPath === STDIN_FILE_NAME) {
+			const bytes = await readStdinBytes();
+			countedInputs.push({
+				counts: countBytes(bytes),
+				displayPath: target.displayPath
+			});
+			continue;
+		}
+		const resolvedPath = resolvePathFromCwd(options.context.cwd, target.path);
 		try {
-			await drainResult(executePipeline(statement.pipeline, fs, context));
-		} catch (error) {
-			context.status = 1;
-			throw error;
+			const bytes = await options.fs.readFile(resolvedPath);
+			countedInputs.push({
+				counts: countBytes(bytes),
+				displayPath: target.displayPath
+			});
+		} catch {
+			stderr.push(`wc: ${target.displayPath}: No such file or directory`);
+			hadError = true;
 		}
 	}
+	if (source.targets.length === 0 && !source.fromFiles0) {
+		const bytes = await readStdinBytes();
+		countedInputs.push({
+			counts: countBytes(bytes),
+			displayPath: DEFAULT_STDIN_DISPLAY_PATH
+		});
+	}
+	const stdout = renderOutput(countedInputs, selection, options.parsed.total, source.fromFiles0, source.operandCount);
+	return {
+		exitCode: hadError ? 1 : 0,
+		stderr,
+		stdout
+	};
 }
-async function* runScriptToStream(script, fs, context) {
-	for (const statement of script.statements) {
-		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
+async function resolveInputSource(options) {
+	if (!options.parsed.files0From) return {
+		files0FromStdin: false,
+		fromFiles0: false,
+		operandCount: options.fileOperands.length,
+		targets: options.fileOperands.map((path) => ({
+			displayPath: path,
+			path
+		}))
+	};
+	const files0From = expandedWordToString(options.parsed.files0From);
+	const files0FromStdin = files0From === STDIN_FILE_NAME;
+	let namesBytes;
+	if (files0FromStdin) namesBytes = await options.readStdinBytes();
+	else {
+		const path = resolvePathFromCwd(options.context.cwd, files0From);
 		try {
-			const result = executePipeline(statement.pipeline, fs, context);
-			if (result.kind === "sink") {
-				await result.value;
-				continue;
-			}
-			yield* result.value;
-		} catch (error) {
-			context.status = 1;
-			throw error;
+			namesBytes = await options.fs.readFile(path);
+		} catch {
+			options.stderr.push(`wc: ${files0From}: No such file or directory`);
+			return null;
 		}
 	}
+	const names = parseNulSeparatedNames(namesBytes, options.stderr);
+	return {
+		files0FromStdin,
+		fromFiles0: true,
+		operandCount: names.names.length + names.invalidNameCount,
+		targets: names.names.map((path) => ({
+			displayPath: path,
+			path
+		}))
+	};
 }
-async function drainResult(result) {
-	if (result.kind === "sink") {
-		await result.value;
-		return;
+function parseNulSeparatedNames(bytes, stderr) {
+	if (bytes.byteLength === 0) return {
+		invalidNameCount: 0,
+		names: []
+	};
+	const names = [];
+	let invalidNameCount = 0;
+	let start = 0;
+	for (let index = 0; index < bytes.byteLength; index++) {
+		if (bytes[index] !== NUL_BYTE) continue;
+		invalidNameCount += appendName(bytes.slice(start, index), names, stderr);
+		start = index + 1;
 	}
-	for await (const _record of result.value);
+	if (start < bytes.byteLength) invalidNameCount += appendName(bytes.slice(start), names, stderr);
+	return {
+		invalidNameCount,
+		names
+	};
 }
-function executePipeline(ir, fs, context) {
-	if (ir.steps.length === 0) return {
-		kind: "stream",
-		value: emptyStream()
+function appendName(bytes, names, stderr) {
+	if (bytes.byteLength === 0) {
+		stderr.push("wc: invalid zero-length file name");
+		return 1;
+	}
+	names.push(UTF8_DECODER.decode(bytes));
+	return 0;
+}
+async function readFileOrReport(fs, path, stderr) {
+	try {
+		return await fs.readFile(path);
+	} catch {
+		stderr.push(`wc: ${path}: No such file or directory`);
+		return null;
+	}
+}
+function createStdinReader(input, redirectedInputBytes) {
+	let hasRead = false;
+	return async () => {
+		if (hasRead) return DEFAULT_STDIO_BYTES;
+		hasRead = true;
+		return redirectedInputBytes ?? readStreamBytes(input);
 	};
-	const lastStep = ir.steps.at(-1);
-	if (!lastStep) return {
-		kind: "stream",
-		value: emptyStream()
+}
+async function readStreamBytes(input) {
+	if (!input) return DEFAULT_STDIO_BYTES;
+	const textParts = [];
+	for await (const record of input) textParts.push(formatRecord(record));
+	return UTF8_ENCODER.encode(textParts.join("\n"));
+}
+function countBytes(bytes) {
+	const text = UTF8_DECODER.decode(bytes);
+	return {
+		bytes: bytes.byteLength,
+		chars: [...text].length,
+		lines: countLines(bytes),
+		maxLineLength: countMaxLineLength(text),
+		words: countWords(text)
 	};
-	if (isEffectStep(lastStep)) {
-		for (const [index, step] of ir.steps.entries()) if (isEffectStep(step) && index !== ir.steps.length - 1) throw new Error(`Unsupported pipeline: "${step.cmd}" must be the final command`);
-		if (hasRedirect(lastStep.redirections, "output")) return {
-			kind: "sink",
-			value: (async () => {
-				const outputPath = await resolveRedirectPath(lastStep.cmd, lastStep.redirections, "output", fs, context);
-				if (!outputPath) throw new Error(`${lastStep.cmd}: output redirection missing target`);
-				await executePipelineToSink(ir.steps, fs, context);
-				await fs.writeFile(outputPath, TEXT_ENCODER.encode(""));
-			})()
-		};
-		return {
-			kind: "sink",
-			value: executePipelineToSink(ir.steps, fs, context)
-		};
+}
+function countLines(bytes) {
+	let lines = 0;
+	for (const byte of bytes) if (byte === NEWLINE_BYTE) lines++;
+	return lines;
+}
+function countWords(text) {
+	return text.split(WORD_SEPARATOR_REGEX).filter((word) => word.length > 0).length;
+}
+function countMaxLineLength(text) {
+	let maxLength = 0;
+	let linePosition = 0;
+	for (const character of text) switch (character) {
+		case "\n":
+		case "\r":
+		case "\f":
+			if (linePosition > maxLength) maxLength = linePosition;
+			linePosition = 0;
+			break;
+		case "	":
+			linePosition += TAB_WIDTH - linePosition % TAB_WIDTH;
+			break;
+		case "\v": break;
+		case " ":
+			linePosition++;
+			break;
+		default: linePosition += displayWidth(character);
 	}
-	if (lastStep.cmd === "grep" && hasRedirect(lastStep.redirections, "output")) return {
-		kind: "sink",
-		value: (async () => {
-			const outputPath = await resolveRedirectPath(lastStep.cmd, lastStep.redirections, "output", fs, context);
-			if (!outputPath) throw new Error(`${lastStep.cmd}: output redirection missing target`);
-			const redirectedResult = applyOutputRedirect({
-				kind: "stream",
-				value: executePipelineToStream(ir.steps, fs, context, { finalGrepOutputRedirectPath: outputPath })
-			}, lastStep, fs, context, outputPath);
-			if (redirectedResult.kind !== "sink") throw new Error(`${lastStep.cmd}: output redirection did not produce a sink`);
-			await redirectedResult.value;
-		})()
-	};
-	return applyOutputRedirect({
-		kind: "stream",
-		value: executePipelineToStream(ir.steps, fs, context)
-	}, lastStep, fs, context);
+	if (linePosition > maxLength) maxLength = linePosition;
+	return maxLength;
 }
-function executePipelineToStream(steps, fs, context, options = {}) {
-	return (async function* () {
-		let stream = null;
-		for (const [index, step] of steps.entries()) {
-			if (isEffectStep(step)) throw new Error(`Unsupported pipeline: "${step.cmd}" requires being the final command`);
-			stream = executeStreamStep(step, fs, stream, context, index === steps.length - 1 ? options.finalGrepOutputRedirectPath : void 0);
-		}
-		if (!stream) return;
-		yield* stream;
-	})();
+function displayWidth(character) {
+	const codePoint = character.codePointAt(0);
+	if (codePoint === void 0 || isControlCodePoint(codePoint)) return 0;
+	if (COMBINING_MARK_REGEX.test(character) || DEFAULT_IGNORABLE_CODE_POINT_REGEX.test(character)) return 0;
+	if (isWideCodePoint(codePoint)) return 2;
+	return 1;
 }
-async function executePipelineToSink(steps, fs, context) {
-	const finalStep = steps.at(-1);
-	if (!(finalStep && isEffectStep(finalStep))) return;
-	if (steps.length > 1) {
-		const stream = executePipelineToStream(steps.slice(0, -1), fs, context);
-		for await (const _record of stream);
-	}
-	await executeEffectStep(finalStep, fs, context);
+function isControlCodePoint(codePoint) {
+	return codePoint <= ASCII_CONTROL_MAX || codePoint === DELETE_CHARACTER || codePoint >= C1_CONTROL_MIN && codePoint <= C1_CONTROL_MAX;
 }
-function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath) {
-	const builtinRuntime = createBuiltinRuntime(fs, context, input);
-	switch (step.cmd) {
-		case "cat": return (async function* () {
-			const options = {
-				numberLines: step.args.numberLines,
-				numberNonBlank: step.args.numberNonBlank,
-				showAll: step.args.showAll,
-				showEnds: step.args.showEnds,
-				showNonprinting: step.args.showNonprinting,
+function isWideCodePoint(codePoint) {
+	for (const [start, end] of WIDE_CHARACTER_RANGES) if (codePoint >= start && codePoint <= end) return true;
+	return false;
+}
+function normalizeSelection(parsed) {
+	if (parsed.bytes || parsed.chars || parsed.lines || parsed.maxLineLength || parsed.words) return {
+		bytes: parsed.bytes,
+		chars: parsed.chars,
+		lines: parsed.lines,
+		maxLineLength: parsed.maxLineLength,
+		words: parsed.words
+	};
+	return {
+		bytes: true,
+		chars: false,
+		lines: true,
+		maxLineLength: false,
+		words: true
+	};
+}
+function renderOutput(inputs, selection, totalMode, fromFiles0, operandCount) {
+	const includeTotal = shouldIncludeTotal(operandCount, totalMode);
+	const totals = sumCounts(inputs);
+	if (totalMode === "only") return [renderCounts(totals, selection, 1, null)];
+	if (inputs.length === 0 && !includeTotal) return [];
+	const width = fieldWidth(inputs, totals, selection, fromFiles0);
+	const lines = inputs.map((input) => renderCounts(input.counts, selection, width, input.displayPath ? quoteDisplayPath(input.displayPath) : null));
+	if (includeTotal) lines.push(renderCounts(totals, selection, width, "total"));
+	return lines;
+}
+function shouldIncludeTotal(operandCount, totalMode) {
+	if (totalMode === "never" || totalMode === "only") return false;
+	if (totalMode === "always") return true;
+	return operandCount > 1;
+}
+function sumCounts(inputs) {
+	const totals = {
+		bytes: 0,
+		chars: 0,
+		lines: 0,
+		maxLineLength: 0,
+		words: 0
+	};
+	for (const input of inputs) {
+		totals.bytes += input.counts.bytes;
+		totals.chars += input.counts.chars;
+		totals.lines += input.counts.lines;
+		totals.words += input.counts.words;
+		if (input.counts.maxLineLength > totals.maxLineLength) totals.maxLineLength = input.counts.maxLineLength;
+	}
+	return totals;
+}
+function fieldWidth(inputs, totals, selection, fromFiles0) {
+	if (inputs.length === 1 && inputs[0]?.displayPath === DEFAULT_STDIN_DISPLAY_PATH && selectedFieldCount(selection) > 1) return DEFAULT_STDIN_FIELD_WIDTH;
+	if (!fromFiles0 && inputs.length === 1) return 1;
+	if (fromFiles0 && selectedFieldCount(selection) === 1) return 1;
+	let width = 1;
+	for (const input of inputs) width = Math.max(width, maxSelectedDigitCount(input.counts, selection));
+	width = Math.max(width, maxSelectedDigitCount(totals, selection));
+	return width;
+}
+function selectedFieldCount(selection) {
+	return selectedValues({
+		bytes: 0,
+		chars: 0,
+		lines: 0,
+		maxLineLength: 0,
+		words: 0
+	}, selection).length;
+}
+function maxSelectedDigitCount(counts, selection) {
+	return Math.max(...selectedValues(counts, selection).map((value) => String(value).length));
+}
+function renderCounts(counts, selection, width, displayPath) {
+	const prefix = selectedValues(counts, selection).map((value) => String(value).padStart(width, " ")).join(" ");
+	return displayPath ? `${prefix} ${displayPath}` : prefix;
+}
+function selectedValues(counts, selection) {
+	const values = [];
+	if (selection.lines) values.push(counts.lines);
+	if (selection.words) values.push(counts.words);
+	if (selection.bytes) values.push(counts.bytes);
+	if (selection.chars) values.push(counts.chars);
+	if (selection.maxLineLength) values.push(counts.maxLineLength);
+	return values;
+}
+function quoteDisplayPath(path) {
+	if (!path.includes("\n")) return path;
+	return `'${path.split("\n").join("'$'\\n''")}'`;
+}
+//#endregion
+//#region src/operator/xargs/xargs.ts
+const DEFAULT_MAX_ARGS = Number.POSITIVE_INFINITY;
+const TEXT_DECODER = new TextDecoder();
+const WHITESPACE_REGEX = /\s/u;
+const LEADING_WHITESPACE_REGEX = /^\s+/u;
+async function runXargsCommand(options) {
+	try {
+		return await runXargsCommandInner(options);
+	} catch {
+		return {
+			exitCode: 1,
+			stderr: [],
+			stdout: []
+		};
+	}
+}
+async function runXargsCommandInner(options) {
+	const input = await readInput(options);
+	const command = await evaluateExpandedWords(options.parsed.command, options.fs, options.context);
+	const batches = buildBatches(input, options.parsed);
+	if (batches.length === 0 && options.parsed.noRunIfEmpty) return {
+		exitCode: 0,
+		stderr: [],
+		stdout: []
+	};
+	const stdout = [];
+	const stderr = [];
+	let exitCode = 0;
+	for (const batch of batches.length > 0 ? batches : [[]]) {
+		const result = await runCommand(buildCommandArgs(command, batch, options.parsed), options.fs, options.context);
+		stdout.push(...result.stdout);
+		stderr.push(...result.stderr);
+		if (result.exitCode !== 0) exitCode = result.exitCode;
+	}
+	return {
+		exitCode,
+		stderr,
+		stdout
+	};
+}
+async function readInput(options) {
+	if (options.inputPath) return TEXT_DECODER.decode(await options.fs.readFile(options.inputPath));
+	if (!options.input) return "";
+	const records = [];
+	for await (const record of options.input) records.push(formatStdoutRecord(record));
+	return records.join("\n");
+}
+function buildBatches(input, args) {
+	if (args.replace) return replacementBatches(input, args);
+	if (args.maxLines) return lineBatches(input, args);
+	return chunkItems(args.delimiter === null ? tokenize(input, args.eof).items : splitDelimited(input, args.delimiter), args.maxArgs ?? DEFAULT_MAX_ARGS);
+}
+function replacementBatches(input, args) {
+	const batches = [];
+	for (const line of splitInputLines(input)) {
+		const item = line.replace(LEADING_WHITESPACE_REGEX, "");
+		if (item === "") continue;
+		if (args.eof !== null && item === args.eof) break;
+		batches.push([item]);
+	}
+	return batches;
+}
+function lineBatches(input, args) {
+	const batches = [];
+	let current = [];
+	let lineCount = 0;
+	for (const line of splitInputLines(input)) {
+		const parsed = tokenize(line, args.eof);
+		if (parsed.items.length === 0) {
+			if (parsed.stopped) break;
+			continue;
+		}
+		current.push(...parsed.items);
+		lineCount++;
+		if (lineCount >= (args.maxLines ?? 1)) {
+			batches.push(current);
+			current = [];
+			lineCount = 0;
+		}
+		if (parsed.stopped) break;
+	}
+	if (current.length > 0) batches.push(current);
+	return batches;
+}
+function chunkItems(items, maxArgs) {
+	if (items.length === 0) return [];
+	if (!Number.isFinite(maxArgs)) return [items];
+	const chunks = [];
+	for (let index = 0; index < items.length; index += maxArgs) chunks.push(items.slice(index, index + maxArgs));
+	return chunks;
+}
+function splitDelimited(input, delimiter) {
+	if (delimiter === "") return input === "" ? [] : [input];
+	const parts = input.split(delimiter);
+	if (input.endsWith(delimiter)) parts.pop();
+	return parts;
+}
+function splitInputLines(input) {
+	const lines = input.split("\n");
+	if (input.endsWith("\n")) lines.pop();
+	return lines;
+}
+function tokenize(input, eof) {
+	const items = [];
+	const state = {
+		current: "",
+		escaped: false,
+		quote: null
+	};
+	for (const char of input) {
+		if (state.escaped) {
+			appendEscapedChar(state, char);
+			continue;
+		}
+		if (state.quote) {
+			appendQuotedChar(state, char);
+			continue;
+		}
+		if (WHITESPACE_REGEX.test(char)) {
+			const stopped = pushToken(items, state.current, eof);
+			state.current = "";
+			if (stopped) return {
+				items,
+				stopped: true
+			};
+			continue;
+		}
+		appendUnquotedChar(state, char);
+	}
+	if (state.quote) throw new Error(`xargs: unterminated quote ${state.quote}`);
+	if (state.escaped) throw new Error("xargs: unterminated escape");
+	return {
+		items,
+		stopped: pushToken(items, state.current, eof)
+	};
+}
+function appendEscapedChar(state, char) {
+	state.current += char;
+	state.escaped = false;
+}
+function appendQuotedChar(state, char) {
+	if (char === state.quote) {
+		state.quote = null;
+		return;
+	}
+	if (char === "\\") {
+		state.escaped = true;
+		return;
+	}
+	state.current += char;
+}
+function appendUnquotedChar(state, char) {
+	if (char === "\"" || char === "'") {
+		state.quote = char;
+		return;
+	}
+	if (char === "\\") {
+		state.escaped = true;
+		return;
+	}
+	state.current += char;
+}
+function pushToken(items, token, eof) {
+	if (token === "") return false;
+	if (eof !== null && token === eof) return true;
+	items.push(token);
+	return false;
+}
+function buildCommandArgs(command, batch, args) {
+	if (!args.replace) return [...command, ...batch];
+	return command.map((part) => part.replaceAll(args.replace ?? "", batch[0] ?? ""));
+}
+async function runCommand(argv, fs, context) {
+	if (argv.length === 0) return {
+		exitCode: 0,
+		stderr: [],
+		stdout: []
+	};
+	const childContext = {
+		cwd: context.cwd,
+		globalVars: context.globalVars,
+		localVars: context.localVars,
+		status: context.status,
+		stderr: new BufferedOutputStream()
+	};
+	const stdout = await collectStdout((await Promise.resolve().then(() => execute_exports)).execute(compile(parse(argv.map(quoteShellWord).join(" "))), fs, childContext));
+	return {
+		exitCode: childContext.status,
+		stderr: [...childContext.stderr.snapshot()],
+		stdout
+	};
+}
+async function collectStdout(result) {
+	if (result.kind === "sink") {
+		await result.value;
+		return [];
+	}
+	const stdout = [];
+	for await (const record of result.value) stdout.push(formatStdoutRecord(record));
+	return stdout;
+}
+function quoteShellWord(value) {
+	return `'${value.replaceAll("'", "'\\''")}'`;
+}
+//#endregion
+//#region src/execute/producers.ts
+async function* files(...paths) {
+	for (const path of paths) yield {
+		kind: "file",
+		path
+	};
+}
+//#endregion
+//#region src/execute/registry.ts
+const EFFECT_COMMANDS = [
+	"cd",
+	"cp",
+	"mkdir",
+	"mv",
+	"rm",
+	"touch"
+];
+const EFFECT_COMMAND_SET = new Set(EFFECT_COMMANDS);
+const STREAM_COMMANDS = [
+	"cat",
+	"echo",
+	"find",
+	"grep",
+	"head",
+	"ls",
+	"pwd",
+	"read",
+	"set",
+	"string",
+	"tail",
+	"test",
+	"xargs",
+	"wc"
+];
+const STREAM_COMMAND_SET = new Set(STREAM_COMMANDS);
+const ROOT_DIRECTORY$1 = "/";
+function lineRecordsFromPath(fs, path) {
+	return (async function* () {
+		for await (const line of fs.readLines(path)) yield {
+			kind: "line",
+			text: line
+		};
+	})();
+}
+let commandRegistriesVerified = false;
+function isStreamCommand(command) {
+	return STREAM_COMMAND_SET.has(command);
+}
+function verifyCommandRegistries() {
+	if (commandRegistriesVerified) return;
+	for (const command of EFFECT_COMMANDS) try {
+		CommandRegistry.getEffect(command);
+	} catch {
+		throw new Error(`Missing effect command handler: ${command}`);
+	}
+	for (const command of STREAM_COMMANDS) try {
+		CommandRegistry.getStream(command);
+	} catch {
+		throw new Error(`Missing stream command handler: ${command}`);
+	}
+	commandRegistriesVerified = true;
+}
+function executeStreamStep$1({ step, fs, input, context, resolvedOutputRedirectPath }) {
+	verifyCommandRegistries();
+	if (!isStreamCommand(step.cmd)) throw new Error(`Command "${step.cmd}" is not a stream command`);
+	return CommandRegistry.getStream(step.cmd)({
+		step,
+		fs,
+		input,
+		context,
+		resolvedOutputRedirectPath
+	});
+}
+async function executeEffectStep$1({ step, fs, context }) {
+	verifyCommandRegistries();
+	await CommandRegistry.getEffect(step.cmd)({
+		step,
+		fs,
+		context
+	});
+}
+function createBuiltinRuntime(fs, context, input) {
+	return {
+		fs,
+		context,
+		input
+	};
+}
+function formatLongListing(path, stat) {
+	return `${stat.isDirectory ? "d" : "-"} ${String(stat.size).padStart(8, " ")} ${stat.mtime.toISOString()} ${path}`;
+}
+function normalizeLsPath(path, cwd) {
+	if (path === "." || path === "./") return cwd;
+	if (path.startsWith("./")) return `${cwd}/${path.slice(2)}`;
+	if (path.startsWith(ROOT_DIRECTORY$1)) return path;
+	return `${cwd}/${path}`;
+}
+function resolveLsPath(path, cwd) {
+	return normalizeLsPath(path, cwd);
+}
+let CommandRegistry;
+(function(_CommandRegistry) {
+	const commands = /* @__PURE__ */ new Map();
+	function register(command, entry) {
+		commands.set(command, entry);
+	}
+	_CommandRegistry.register = register;
+	function getStream(command) {
+		const entry = commands.get(command);
+		if (!entry) throw new Error(`Unknown command: ${command}`);
+		if (entry.kind !== "stream") throw new Error(`Command "${command}" is not a stream command`);
+		return entry.handler;
+	}
+	_CommandRegistry.getStream = getStream;
+	function getEffect(command) {
+		const entry = commands.get(command);
+		if (!entry) throw new Error(`Unknown command: ${command}`);
+		if (entry.kind !== "effect") throw new Error(`Command "${command}" is not an effect command`);
+		return entry.handler;
+	}
+	_CommandRegistry.getEffect = getEffect;
+	function isEffectStep(step) {
+		return EFFECT_COMMAND_SET.has(step.cmd);
+	}
+	_CommandRegistry.isEffectStep = isEffectStep;
+	function executeStep(params) {
+		if (isEffectStep(params.step)) return executeEffectStep$1(params);
+		return executeStreamStep$1(params);
+	}
+	_CommandRegistry.executeStep = executeStep;
+})(CommandRegistry || (CommandRegistry = {}));
+CommandRegistry.register("cat", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const options = {
+				numberLines: step.args.numberLines,
+				numberNonBlank: step.args.numberNonBlank,
+				showAll: step.args.showAll,
+				showEnds: step.args.showEnds,
+				showNonprinting: step.args.showNonprinting,
 				showTabs: step.args.showTabs,
 				squeezeBlank: step.args.squeezeBlank
 			};
@@ -5784,7 +7058,12 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 			if (input) yield* cat(fs, options)(input);
 			context.status = 0;
 		})();
-		case "grep": return (async function* () {
+	}
+});
+CommandRegistry.register("grep", {
+	kind: "stream",
+	handler: ({ step, fs, input, context, resolvedOutputRedirectPath }) => {
+		return (async function* () {
 			const result = await runGrepCommand({
 				context,
 				fs,
@@ -5794,14 +7073,64 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 				resolvedOutputRedirectPath
 			});
 			context.status = result.exitCode;
-			context.stderr.push(...result.stderr);
+			context.stderr.appendLines(result.stderr);
+			for (const text of result.stdout) yield {
+				kind: "line",
+				text
+			};
+		})();
+	}
+});
+CommandRegistry.register("find", {
+	kind: "stream",
+	handler: ({ step, fs, context }) => {
+		return find(fs, context, step.args);
+	}
+});
+CommandRegistry.register("xargs", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const result = await runXargsCommand({
+				context,
+				fs,
+				input,
+				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
+				parsed: step.args
+			});
+			context.status = result.exitCode;
+			context.stderr.appendLines(result.stderr);
+			for (const text of result.stdout) yield {
+				kind: "line",
+				text
+			};
+		})();
+	}
+});
+CommandRegistry.register("wc", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const result = await runWcCommand({
+				context,
+				fs,
+				input,
+				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
+				parsed: step.args
+			});
+			context.status = result.exitCode;
+			context.stderr.appendLines(result.stderr);
 			for (const text of result.stdout) yield {
 				kind: "line",
 				text
 			};
 		})();
-		case "find": return find(fs, context, step.args);
-		case "head": return (async function* () {
+	}
+});
+CommandRegistry.register("head", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
 			const inputPath = await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context);
 			const filePaths = withInputRedirect(resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("head", step.args.files, fs, context)), inputPath);
 			if (filePaths.length > 0) {
@@ -5812,7 +7141,12 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 			if (input) yield* headLines(step.args.n)(toFormattedLineStream(input));
 			context.status = 0;
 		})();
-		case "ls": return (async function* () {
+	}
+});
+CommandRegistry.register("ls", {
+	kind: "stream",
+	handler: ({ step, fs, context }) => {
+		return (async function* () {
 			const paths = await evaluateExpandedPathWords("ls", step.args.paths, fs, context);
 			for (const inputPath of paths) {
 				const resolvedPath = resolveLsPath(inputPath, context.cwd);
@@ -5830,7 +7164,12 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 			}
 			context.status = 0;
 		})();
-		case "tail": return (async function* () {
+	}
+});
+CommandRegistry.register("tail", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
 			const inputPath = await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context);
 			const filePaths = withInputRedirect(resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("tail", step.args.files, fs, context)), inputPath);
 			if (filePaths.length > 0) {
@@ -5841,118 +7180,540 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 			if (input) yield* tail(step.args.n)(toFormattedLineStream(input));
 			context.status = 0;
 		})();
-		case "pwd": return (async function* () {
+	}
+});
+CommandRegistry.register("pwd", {
+	kind: "stream",
+	handler: ({ context }) => {
+		return (async function* () {
 			yield* pwd(context.cwd);
 			context.status = 0;
 		})();
-		case "echo": return echo(builtinRuntime, step.args);
-		case "set": return set(builtinRuntime, step.args);
-		case "test": return test(builtinRuntime, step.args);
-		case "read": return read(builtinRuntime, step.args);
-		case "string": return string(builtinRuntime, step.args);
-		default: {
-			const _exhaustive = step;
-			throw new Error(`Unknown command: ${String(_exhaustive.cmd)}`);
-		}
 	}
+});
+CommandRegistry.register("echo", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return echo(createBuiltinRuntime(fs, context, input), step.args);
+	}
+});
+CommandRegistry.register("set", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return set(createBuiltinRuntime(fs, context, input), step.args);
+	}
+});
+CommandRegistry.register("test", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return test(createBuiltinRuntime(fs, context, input), step.args);
+	}
+});
+CommandRegistry.register("read", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const resolvedInput = await resolveInputRedirect(step.cmd, step.redirections, fs, context);
+			if (resolvedInput.closed) {
+				context.stderr.append("read: stdin is closed");
+				context.status = 1;
+				return;
+			}
+			yield* read(createBuiltinRuntime(fs, context, resolvedInput.path ? lineRecordsFromPath(fs, resolvedInput.path) : input), step.args);
+		})();
+	}
+});
+CommandRegistry.register("string", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return string(createBuiltinRuntime(fs, context, input), step.args);
+	}
+});
+CommandRegistry.register("cd", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		await cd(createBuiltinRuntime(fs, context, null), step.args);
+	}
+});
+CommandRegistry.register("cp", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		const srcPaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("cp", step.args.srcs, fs, context));
+		const destinationPath = resolvePathsFromCwd(context.cwd, [await evaluateExpandedSinglePath("cp", "destination must expand to exactly 1 path", step.args.dest, fs, context)]).at(0);
+		if (destinationPath === void 0) throw new Error("cp: destination missing after expansion");
+		await cp(fs)({
+			srcs: srcPaths,
+			dest: destinationPath,
+			force: step.args.force,
+			interactive: step.args.interactive,
+			recursive: step.args.recursive
+		});
+		context.status = 0;
+	}
+});
+CommandRegistry.register("mkdir", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		const paths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("mkdir", step.args.paths, fs, context));
+		for (const path of paths) await mkdir(fs)({
+			path,
+			recursive: step.args.recursive
+		});
+		context.status = 0;
+	}
+});
+CommandRegistry.register("mv", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		const srcPaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("mv", step.args.srcs, fs, context));
+		const destinationPath = resolvePathsFromCwd(context.cwd, [await evaluateExpandedSinglePath("mv", "destination must expand to exactly 1 path", step.args.dest, fs, context)]).at(0);
+		if (destinationPath === void 0) throw new Error("mv: destination missing after expansion");
+		await mv(fs)({
+			srcs: srcPaths,
+			dest: destinationPath,
+			force: step.args.force,
+			interactive: step.args.interactive
+		});
+		context.status = 0;
+	}
+});
+CommandRegistry.register("rm", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		const paths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("rm", step.args.paths, fs, context));
+		for (const path of paths) await rm(fs)({
+			path,
+			force: step.args.force,
+			interactive: step.args.interactive,
+			recursive: step.args.recursive
+		});
+		context.status = 0;
+	}
+});
+CommandRegistry.register("touch", {
+	kind: "effect",
+	handler: async ({ step, fs, context }) => {
+		const filePaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("touch", step.args.files, fs, context));
+		await touch(fs)({
+			files: filePaths,
+			accessTimeOnly: step.args.accessTimeOnly,
+			modificationTimeOnly: step.args.modificationTimeOnly
+		});
+		context.status = 0;
+	}
+});
+//#endregion
+//#region src/execute/execute.ts
+var execute_exports = /* @__PURE__ */ __exportAll({ execute: () => execute });
+const ROOT_DIRECTORY = "/";
+const FD_TARGET_REGEX = /^&[0-9]+$/;
+async function* emptyStream() {}
+function isScriptIR(ir) {
+	return "statements" in ir;
 }
-async function executeEffectStep(step, fs, context) {
-	const builtinRuntime = createBuiltinRuntime(fs, context, null);
-	switch (step.cmd) {
-		case "cd":
-			await cd(builtinRuntime, step.args);
-			break;
-		case "cp": {
-			const srcPaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("cp", step.args.srcs, fs, context));
-			const destinationPath = resolvePathsFromCwd(context.cwd, [await evaluateExpandedSinglePath("cp", "destination must expand to exactly 1 path", step.args.dest, fs, context)]).at(0);
-			if (destinationPath === void 0) throw new Error("cp: destination missing after expansion");
-			await cp(fs)({
-				srcs: srcPaths,
-				dest: destinationPath,
-				force: step.args.force,
-				interactive: step.args.interactive,
-				recursive: step.args.recursive
-			});
-			context.status = 0;
-			break;
-		}
-		case "mkdir": {
-			const paths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("mkdir", step.args.paths, fs, context));
-			for (const path of paths) await mkdir(fs)({
-				path,
-				recursive: step.args.recursive
-			});
-			context.status = 0;
-			break;
-		}
-		case "mv": {
-			const srcPaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("mv", step.args.srcs, fs, context));
-			const destinationPath = resolvePathsFromCwd(context.cwd, [await evaluateExpandedSinglePath("mv", "destination must expand to exactly 1 path", step.args.dest, fs, context)]).at(0);
-			if (destinationPath === void 0) throw new Error("mv: destination missing after expansion");
-			await mv(fs)({
-				srcs: srcPaths,
-				dest: destinationPath,
-				force: step.args.force,
-				interactive: step.args.interactive
-			});
-			context.status = 0;
-			break;
-		}
-		case "rm": {
-			const paths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("rm", step.args.paths, fs, context));
-			for (const path of paths) await rm(fs)({
-				path,
-				force: step.args.force,
-				interactive: step.args.interactive,
-				recursive: step.args.recursive
-			});
-			context.status = 0;
-			break;
+function toScriptIR(pipeline) {
+	return { statements: [{
+		chainMode: "always",
+		pipeline
+	}] };
+}
+function shouldExecuteStatement(chainMode, previousStatus) {
+	if (chainMode === "always") return true;
+	if (chainMode === "and") return previousStatus === 0;
+	return previousStatus !== 0;
+}
+function execute(ir, fs, context = { cwd: ROOT_DIRECTORY }) {
+	const normalizedContext = normalizeContext(context);
+	return executeScript(isScriptIR(ir) ? ir : toScriptIR(ir), fs, normalizedContext);
+}
+function isPipelineSink(pipeline) {
+	if (hasMidPipelineStdoutBypass(pipeline.steps)) return false;
+	const finalStep = pipeline.steps.at(-1);
+	if (!finalStep) return false;
+	return CommandRegistry.isEffectStep(finalStep) || hasRedirect(finalStep.redirections, "output");
+}
+function hasMidPipelineStdoutBypass(steps) {
+	for (const [index, step] of steps.entries()) {
+		if (index === steps.length - 1) continue;
+		const redirections = step.redirections ?? [];
+		if (!redirections.some((redirection) => {
+			return redirection.kind === "output" && getSourceFd(redirection) !== 1 && getRedirectionMode(redirection) === "pipe";
+		})) continue;
+		if (!redirections.some((redirection) => {
+			return redirection.kind === "output" && getSourceFd(redirection) === 1 && getRedirectionMode(redirection) === "pipe";
+		})) return true;
+	}
+	return false;
+}
+function executeScript(script, fs, context) {
+	if (script.statements.length === 0) return {
+		kind: "stream",
+		value: emptyStream()
+	};
+	if (script.statements.every((statement) => isPipelineSink(statement.pipeline))) return {
+		kind: "sink",
+		value: runScriptToCompletion(script, fs, context)
+	};
+	return {
+		kind: "stream",
+		value: runScriptToStream(script, fs, context)
+	};
+}
+async function runScriptToCompletion(script, fs, context) {
+	for (const statement of script.statements) {
+		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
+		try {
+			await drainStream(runPipeline(statement.pipeline, fs, context));
+		} catch (error) {
+			context.status = 1;
+			throw error;
 		}
-		case "touch": {
-			const filePaths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("touch", step.args.files, fs, context));
-			await touch(fs)({
-				files: filePaths,
-				accessTimeOnly: step.args.accessTimeOnly,
-				modificationTimeOnly: step.args.modificationTimeOnly
-			});
-			context.status = 0;
-			break;
+	}
+}
+async function* runScriptToStream(script, fs, context) {
+	for (const statement of script.statements) {
+		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
+		try {
+			yield* runPipeline(statement.pipeline, fs, context);
+		} catch (error) {
+			context.status = 1;
+			throw error;
 		}
-		default: {
-			const _exhaustive = step;
-			throw new Error(`Unknown command: ${String(_exhaustive.cmd)}`);
+	}
+}
+async function drainStream(stream) {
+	for await (const _record of stream);
+}
+async function* runPipeline(pipeline, fs, context) {
+	if (pipeline.steps.length === 0) return;
+	let pipeInputRecords = null;
+	let preservedPipelineStatus = null;
+	for (const [index, step] of pipeline.steps.entries()) {
+		const isLastStep = index === pipeline.steps.length - 1;
+		if (CommandRegistry.isEffectStep(step) && !isLastStep) throw new Error(`Unsupported pipeline: "${step.cmd}" must be the final command`);
+		const plan = await resolveRoutingPlan(step, fs, context, isLastStep);
+		const shouldPreserveStatus = shouldPreserveProducerStatus(plan, !isLastStep);
+		if (!await preflightNoclobber(plan, fs)) {
+			context.status = 1;
+			context.stderr.append(`${step.cmd}: cannot overwrite existing file`);
+			return;
 		}
+		const executed = CommandRegistry.isEffectStep(step) ? await executeEffectStep({
+			context,
+			fs,
+			plan,
+			shouldPreserveStatus,
+			step
+		}) : await executeStreamStep({
+			context,
+			fs,
+			hasNextStep: !isLastStep,
+			inputRecords: pipeInputRecords,
+			plan,
+			shouldPreserveStatus,
+			step
+		});
+		if (executed.preservedStatus !== null) preservedPipelineStatus = executed.preservedStatus;
+		if (executed.shellRecords.length > 0) yield* recordsToStream(executed.shellRecords);
+		pipeInputRecords = executed.pipeRecords;
 	}
+	if (preservedPipelineStatus !== null) context.status = preservedPipelineStatus;
 }
-function createBuiltinRuntime(fs, context, input) {
-	return {
+async function executeEffectStep(params) {
+	const { context, fs, plan, shouldPreserveStatus, step } = params;
+	const childContext = createChildContext(context);
+	await CommandRegistry.executeStep({
+		step,
 		fs,
-		context,
-		input
+		context: childContext
+	});
+	propagateChildContext(childContext, context);
+	return {
+		...await routeStepOutput({
+			context,
+			fs,
+			hasNextStep: false,
+			plan,
+			stderrLines: childContext.stderr.snapshot(),
+			stdoutRecords: []
+		}),
+		preservedStatus: shouldPreserveStatus ? childContext.status : null
 	};
 }
-function formatLongListing(path, stat) {
-	return `${stat.isDirectory ? "d" : "-"} ${String(stat.size).padStart(8, " ")} ${stat.mtime.toISOString()} ${path}`;
-}
-function normalizeLsPath(path, cwd) {
-	if (path === "." || path === "./") return cwd;
-	if (path.startsWith("./")) return `${cwd}/${path.slice(2)}`;
-	if (path.startsWith(ROOT_DIRECTORY)) return path;
-	return `${cwd}/${path}`;
-}
-function resolveLsPath(path, cwd) {
-	return normalizeLsPath(path, cwd);
+async function executeStreamStep(params) {
+	const { context, fs, hasNextStep, inputRecords, plan, shouldPreserveStatus, step } = params;
+	const childContext = createChildContext(context);
+	const resolvedOutputRedirectPath = step.cmd === "grep" && plan.fd1.kind === "file" ? plan.fd1.path : void 0;
+	const stdoutRecords = await collectRecords(CommandRegistry.executeStep({
+		step,
+		fs,
+		input: inputRecords === null ? null : recordsToStream(inputRecords),
+		context: childContext,
+		resolvedOutputRedirectPath
+	}));
+	const stderrLines = childContext.stderr.snapshot();
+	propagateChildContext(childContext, context);
+	return {
+		...await routeStepOutput({
+			context,
+			fs,
+			hasNextStep,
+			plan,
+			stderrLines,
+			stdoutRecords
+		}),
+		preservedStatus: shouldPreserveStatus ? childContext.status : null
+	};
 }
 function normalizeContext(context) {
 	context.cwd = normalizeCwd(context.cwd);
 	context.status ??= 0;
-	context.stderr ??= [];
+	context.stderr ??= new BufferedOutputStream();
 	context.globalVars ??= /* @__PURE__ */ new Map();
 	context.localVars ??= /* @__PURE__ */ new Map();
 	return context;
 }
+function createChildContext(context) {
+	return {
+		cwd: context.cwd,
+		globalVars: context.globalVars,
+		localVars: context.localVars,
+		status: context.status,
+		stderr: new BufferedOutputStream()
+	};
+}
+function propagateChildContext(child, parent) {
+	parent.cwd = child.cwd;
+	parent.status = child.status;
+}
+async function collectRecords(stream) {
+	const records = [];
+	for await (const record of stream) records.push(record);
+	return records;
+}
+function recordsToStream(records) {
+	return (async function* () {
+		for (const record of records) yield record;
+	})();
+}
+function cloneDestination(destination) {
+	if (destination.kind !== "file") return destination;
+	return { ...destination };
+}
+function getSourceFd(redirection) {
+	return redirection.sourceFd ?? 1;
+}
+function getTargetFd(redirection) {
+	if (redirection.targetFd !== void 0 && redirection.targetFd !== null) return redirection.targetFd;
+	const targetText = expandedWordToString(redirection.target);
+	if (!FD_TARGET_REGEX.test(targetText)) return null;
+	return Number(targetText.slice(1));
+}
+async function resolveFileDestination(command, redirection, fs, context) {
+	const targetPath = await evaluateExpandedSinglePath(command, "redirection target must expand to exactly 1 path", redirection.target, fs, context);
+	return {
+		kind: "file",
+		append: redirection.append ?? false,
+		noclobber: redirection.noclobber ?? false,
+		path: resolvePathFromCwd(context.cwd, targetPath)
+	};
+}
+function destinationForFd(routing, fd, _isLastStep) {
+	if (fd === 1) return routing.fd1;
+	if (fd === 2) return routing.fd2;
+	return { kind: "closed" };
+}
+function defaultStdoutDestination(isLastStep, hasNonStdoutPipeRedirect, hasStdoutPipeRedirect) {
+	if (isLastStep) return { kind: "shellStdout" };
+	if (hasNonStdoutPipeRedirect && !hasStdoutPipeRedirect) return { kind: "shellStdout" };
+	return { kind: "pipe" };
+}
+async function resolveOutputRedirectionDestination(params) {
+	const { context, fs, isLastStep, redirection, routing, step } = params;
+	if (redirection.kind !== "output") return null;
+	const sourceFd = getSourceFd(redirection);
+	if (sourceFd !== 1 && sourceFd !== 2) return null;
+	const mode = getRedirectionMode(redirection);
+	let destination;
+	if (mode === "close") destination = { kind: "closed" };
+	else if (mode === "pipe") destination = { kind: "pipe" };
+	else if (mode === "fd") {
+		const targetFd = getTargetFd(redirection);
+		if (targetFd === null) throw new Error(`${step.cmd}: invalid file descriptor duplication target`);
+		destination = cloneDestination(destinationForFd(routing, targetFd, isLastStep));
+	} else if (mode === "file") destination = await resolveFileDestination(step.cmd, redirection, fs, context);
+	else destination = sourceFd === 1 ? routing.fd1 : routing.fd2;
+	return {
+		destination,
+		sourceFd
+	};
+}
+async function resolveRoutingPlan(step, fs, context, isLastStep) {
+	const stepRedirections = step.redirections ?? [];
+	const routing = {
+		fd1: defaultStdoutDestination(isLastStep, stepRedirections.some((redirection) => {
+			return redirection.kind === "output" && getSourceFd(redirection) !== 1 && getRedirectionMode(redirection) === "pipe";
+		}), stepRedirections.some((redirection) => {
+			return redirection.kind === "output" && getSourceFd(redirection) === 1 && getRedirectionMode(redirection) === "pipe";
+		})),
+		fd2: { kind: "shellStderr" }
+	};
+	for (const redirection of stepRedirections) {
+		const resolved = await resolveOutputRedirectionDestination({
+			context,
+			fs,
+			isLastStep,
+			redirection,
+			routing,
+			step
+		});
+		if (!resolved) continue;
+		if (resolved.sourceFd === 1) {
+			routing.fd1 = resolved.destination;
+			continue;
+		}
+		routing.fd2 = resolved.destination;
+	}
+	return routing;
+}
+async function preflightNoclobber(plan, fs) {
+	const destinations = [plan.fd1, plan.fd2];
+	const checkedPaths = /* @__PURE__ */ new Set();
+	for (const destination of destinations) {
+		if (destination.kind !== "file" || !destination.noclobber) continue;
+		if (checkedPaths.has(destination.path)) continue;
+		checkedPaths.add(destination.path);
+		if (!await ensureNoclobberWritable(fs, destination.path)) return false;
+	}
+	return true;
+}
+function stderrLinesToRecords(lines) {
+	return lines.map((text) => ({
+		kind: "line",
+		text
+	}));
+}
+function recordsToText(records) {
+	return records.map((record) => formatStdoutRecord(record)).join("\n");
+}
+function linesToText(lines) {
+	return lines.join("\n");
+}
+function mergeChannelText(stdoutText, stderrText) {
+	if (stdoutText === "") return stderrText;
+	if (stderrText === "") return stdoutText;
+	return `${stdoutText}\n${stderrText}`;
+}
+function toErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+async function writeToFileOrReport(params) {
+	const { append, content, context, fs, path } = params;
+	try {
+		await writeTextToFile(fs, path, content, { append });
+	} catch (error) {
+		context.status = 1;
+		context.stderr.append(toErrorMessage(error));
+	}
+}
+function shouldPipe(destination, hasNextStep) {
+	return destination.kind === "pipe" && hasNextStep;
+}
+function shouldPreserveProducerStatus(plan, hasNextStep) {
+	return hasNextStep && plan.fd2.kind === "pipe" && plan.fd1.kind !== "pipe";
+}
+async function routeStepOutput(params) {
+	const { context, fs, hasNextStep, plan, stderrLines, stdoutRecords } = params;
+	const pipeRecords = [];
+	const shellRecords = [];
+	const stdoutDestination = plan.fd1;
+	const stderrDestination = plan.fd2;
+	const stdoutAsText = recordsToText(stdoutRecords);
+	const stderrAsText = linesToText(stderrLines);
+	if (stdoutDestination.kind === "file" && stderrDestination.kind === "file" && stdoutDestination.path === stderrDestination.path) {
+		const mergedText = mergeChannelText(stdoutAsText, stderrAsText);
+		await writeToFileOrReport({
+			append: stdoutDestination.append && stderrDestination.append,
+			content: mergedText,
+			context,
+			fs,
+			path: stdoutDestination.path
+		});
+	} else {
+		await routeStdout(stdoutRecords, stdoutAsText, stdoutDestination, hasNextStep, pipeRecords, shellRecords, context, fs);
+		await routeStderr(stderrLines, stderrAsText, stderrDestination, hasNextStep, pipeRecords, shellRecords, context, fs);
+	}
+	return {
+		pipeRecords,
+		shellRecords
+	};
+}
+async function routeStdout(stdoutRecords, stdoutText, destination, hasNextStep, pipeRecords, shellRecords, context, fs) {
+	if (stdoutRecords.length === 0 && destination.kind !== "file") return;
+	if (shouldPipe(destination, hasNextStep)) {
+		pipeRecords.push(...stdoutRecords);
+		return;
+	}
+	switch (destination.kind) {
+		case "shellStdout":
+			shellRecords.push(...stdoutRecords);
+			return;
+		case "pipe":
+			shellRecords.push(...stdoutRecords);
+			return;
+		case "shellStderr":
+			if (stdoutText !== "") context.stderr.append(stdoutText);
+			return;
+		case "file":
+			await writeToFileOrReport({
+				append: destination.append,
+				content: stdoutText,
+				context,
+				fs,
+				path: destination.path
+			});
+			return;
+		case "closed": return;
+		default: {
+			const _exhaustive = destination;
+			throw new Error(`Unknown stdout destination: ${_exhaustive}`);
+		}
+	}
+}
+async function routeStderr(stderrLines, stderrText, destination, hasNextStep, pipeRecords, shellRecords, context, fs) {
+	if (stderrLines.length === 0 && destination.kind !== "file") return;
+	if (shouldPipe(destination, hasNextStep)) {
+		pipeRecords.push(...stderrLinesToRecords(stderrLines));
+		return;
+	}
+	switch (destination.kind) {
+		case "shellStdout":
+			shellRecords.push(...stderrLinesToRecords(stderrLines));
+			return;
+		case "pipe":
+			shellRecords.push(...stderrLinesToRecords(stderrLines));
+			return;
+		case "shellStderr":
+			if (stderrLines.length > 0) context.stderr.appendLines(stderrLines);
+			return;
+		case "file":
+			await writeToFileOrReport({
+				append: destination.append,
+				content: stderrText,
+				context,
+				fs,
+				path: destination.path
+			});
+			return;
+		case "closed": return;
+		default: {
+			const _exhaustive = destination;
+			throw new Error(`Unknown stderr destination: ${_exhaustive}`);
+		}
+	}
+}
 //#endregion
-export { formatStderr as a, compile as c, writeDiagnosticsToStderr as i, parse as l, execute_exports as n, formatStdoutRecord as o, isShellDiagnosticError as r, ParseSyntaxError as s, execute as t };
+export { BufferedOutputStream as a, ParseSyntaxError as c, writeDiagnosticsToStderr as i, compile as l, execute_exports as n, formatStderr as o, isShellDiagnosticError as r, formatStdoutRecord as s, execute as t, parse as u };
 
-//# sourceMappingURL=execute-1PmTy1KA.mjs.map
+//# sourceMappingURL=execute-DV1hpsh-.mjs.map