shfs 0.3.0 → 0.3.2

package/dist/{execute-khztC2iY.mjs → execute-D1oWUkmO.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",
@@ -791,8 +801,12 @@ function compileFind(command) {
 function parseFindArgs(argv) {
 	const state = {
 		action: { ...DEFAULT_ACTION },
+		currentBranch: [],
+		currentSideAllowsEmptyBranch: false,
 		diagnostics: [],
-		predicates: [],
+		lastOrTokenIndex: null,
+		predicateBranches: [],
+		sawOr: false,
 		traversal: { ...DEFAULT_TRAVERSAL }
 	};
 	const predicateStartIndex = findPredicateStartIndex(argv);
@@ -807,7 +821,7 @@ function parseFindArgs(argv) {
 	return {
 		action: state.action,
 		diagnostics: state.diagnostics,
-		predicates: state.predicates,
+		predicateBranches: finalizePredicateBranches(state),
 		startPaths,
 		traversal: state.traversal,
 		usageError: state.diagnostics.length > 0
@@ -822,20 +836,37 @@ function createDiagnostic$1(code, token, tokenIndex, message) {
 function createMissingValueDiagnostic(token, tokenIndex) {
 	return createDiagnostic$1("missing-value", token, tokenIndex, `find: missing argument to ${token}`);
 }
+function createMissingExpressionDiagnostic(side, tokenIndex) {
+	return createDiagnostic$1("invalid-expression", "-o", tokenIndex, `find: -o is missing a ${side} predicate expression`);
+}
 function findPredicateStartIndex(argv) {
 	for (const [index, word] of argv.entries()) if (expandedWordToString(word).startsWith("-")) return index;
 	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") {
 		state.traversal.depth = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token === "-print") {
 		state.action.explicit = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token.startsWith("-")) {
@@ -845,16 +876,58 @@ function parseFindToken(argv, index, token, state) {
 	state.diagnostics.push(createDiagnostic$1("unexpected-operand", token, index, `find: unexpected argument: ${token}`));
 	return index + 1;
 }
-function parseStringPredicate(argv, index, token, state) {
+function isPatternPredicateToken(token) {
+	return PATTERN_PREDICATES.has(token);
+}
+function parseOrPredicateSeparator(index, state) {
+	state.sawOr = true;
+	state.lastOrTokenIndex = index;
+	if (state.currentBranch.length === 0 && !state.currentSideAllowsEmptyBranch) {
+		state.diagnostics.push(createMissingExpressionDiagnostic("left", index));
+		return index + 1;
+	}
+	state.predicateBranches.push(state.currentBranch);
+	state.currentBranch = [];
+	state.currentSideAllowsEmptyBranch = false;
+	return index + 1;
+}
+function parsePatternPredicate(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
 		state.diagnostics.push(createMissingValueDiagnostic(token, index));
 		return index + 1;
 	}
-	state.predicates.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) {
@@ -865,12 +938,23 @@ function parseTypePredicate(argv, index, state) {
 	}
 	const parsedType = parseFindTypeValue(valueWord, index + 1);
 	if ("diagnostic" in parsedType) state.diagnostics.push(parsedType.diagnostic);
-	else state.predicates.push({
+	else state.currentBranch.push({
 		kind: "type",
 		types: parsedType.types
 	});
 	return index + 2;
 }
+function finalizePredicateBranches(state) {
+	if (state.currentBranch.length > 0) state.predicateBranches.push(state.currentBranch);
+	else if (state.sawOr && state.lastOrTokenIndex !== null) {
+		if (state.currentSideAllowsEmptyBranch) {
+			state.predicateBranches.push(state.currentBranch);
+			return state.predicateBranches;
+		}
+		state.diagnostics.push(createMissingExpressionDiagnostic("right", state.lastOrTokenIndex));
+	}
+	return state.predicateBranches;
+}
 function parseTraversalOption(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
@@ -884,6 +968,7 @@ function parseTraversalOption(argv, index, token, state) {
 	}
 	if (token === "-maxdepth") state.traversal.maxdepth = parsedNumericValue.value;
 	else state.traversal.mindepth = parsedNumericValue.value;
+	state.currentSideAllowsEmptyBranch = true;
 	return index + 2;
 }
 function parseFindTypeValue(word, tokenIndex) {
@@ -948,7 +1033,9 @@ const parseGrepWords = createWordParser({
 		long: "before-context",
 		short: "B"
 	}),
+	binaryFiles: grepValueFlag({ long: "binary-files" }),
 	binaryFile: grepValueFlag({ long: "binary-file" }),
+	binaryWithoutMatch: grepBooleanFlag({ short: "I" }),
 	byteOffset: grepBooleanFlag({
 		long: "byte-offset",
 		short: "b"
@@ -1085,7 +1172,7 @@ function parseGrepArgs(argv) {
 	applyModeOption(parsed, options);
 	applyFilenameMode(parsed, options);
 	applyFileListingMode(parsed, options);
-	applyBinaryFileOption(parsed, argv, options);
+	applyBinaryFileOption(parsed, argv, options, diagnostics);
 	applyDirectoriesOption(parsed, argv, options);
 	applyMaxCountOption(parsed, argv, options, diagnostics);
 	applyContextOptions(parsed, argv, options, diagnostics);
@@ -1194,8 +1281,58 @@ function applyFileListingMode(parsed, options) {
 		options.listFilesWithMatches = false;
 	}
 }
-function applyBinaryFileOption(parsed, argv, options) {
-	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) options.binaryWithoutMatch = occurrence.value === "without-match";
+function applyBinaryFileOption(parsed, argv, options, diagnostics) {
+	const modeOccurrences = [];
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFiles")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const order of parsed.flagOccurrenceOrder.binaryWithoutMatch ?? []) modeOccurrences.push({
+		mode: "without-match",
+		order
+	});
+	for (const order of parsed.flagOccurrenceOrder.textMode ?? []) modeOccurrences.push({
+		mode: "text",
+		order
+	});
+	modeOccurrences.sort((a, b) => a.order - b.order);
+	for (const occurrence of modeOccurrences) switch (occurrence.mode) {
+		case "binary":
+			options.binaryWithoutMatch = false;
+			options.textMode = false;
+			break;
+		case "text":
+			options.binaryWithoutMatch = false;
+			options.textMode = true;
+			break;
+		case "without-match":
+			options.binaryWithoutMatch = true;
+			options.textMode = false;
+			break;
+		default: break;
+	}
+}
+function parseBinaryMode(value) {
+	if (value === "binary" || value === "text" || value === "without-match") return value;
+	return null;
 }
 function applyDirectoriesOption(parsed, argv, options) {
 	for (const occurrence of getValueOccurrences(parsed, argv, "directories")) options.directories = occurrence.value === "skip" ? "skip" : "read";
@@ -1724,6 +1861,139 @@ function compileTouch(cmd) {
 		}
 	};
 }
+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 = {
@@ -1744,7 +2014,8 @@ let CommandHandler;
 		string: compileString,
 		tail: compileTail,
 		test: compileTest,
-		touch: compileTouch
+		touch: compileTouch,
+		xargs: compileXargs
 	};
 	function get(name) {
 		const handler = handlers[name];
@@ -1834,6 +2105,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)
 		};
 	}
@@ -1910,11 +2187,47 @@ 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 "&|";
+		if (pipeRedirections.length === 1) return this.serializeRedirection(pipeRedirections[0]);
+		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("");
@@ -2839,11 +3152,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);
@@ -2856,6 +3181,7 @@ var Redirection = class extends ASTNode {
 * - Simple commands (name + args)
 * - Redirections (< > Phase 2)
 */
+const DIGITS_ONLY_REGEX = /^[0-9]+$/;
 /**
 * Parser for commands.
 *
@@ -2904,40 +3230,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.
@@ -2946,6 +3350,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.
@@ -3117,8 +3586,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");
@@ -3159,6 +3636,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.
@@ -3514,8 +4012,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");
@@ -3527,7 +4037,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;
@@ -3579,7 +4089,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}`;
@@ -3589,7 +4099,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";
@@ -3616,7 +4126,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;
@@ -3626,17 +4136,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) {
@@ -3651,7 +4161,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 = [];
@@ -3673,12 +4183,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);
 }
@@ -3686,12 +4196,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
@@ -3755,33 +4265,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) {
@@ -3836,10 +4319,156 @@ async function isDirectoryRecord(fs, record) {
 		return false;
 	}
 }
-function formatRecord(record) {
-	return formatStdoutRecord(record);
+//#endregion
+//#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);
+	}
+	const stdinDescriptor = ensureInputDescriptor(descriptors, 0);
+	return {
+		path: stdinDescriptor.kind === "path" ? stdinDescriptor.path ?? null : null,
+		closed: stdinDescriptor.kind === "closed"
+	};
+}
+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) {
@@ -4179,9 +4808,9 @@ async function* find(fs, context, args) {
 		writeDiagnosticsToStderr(context, args.diagnostics);
 		return;
 	}
-	let resolvedPredicates;
+	let resolvedPredicateBranches;
 	try {
-		resolvedPredicates = await resolvePredicates(args.predicates, fs, context);
+		resolvedPredicateBranches = await resolvePredicates(args.predicateBranches, fs, context);
 	} catch (error) {
 		context.status = diagnosticExitCode(error);
 		writeErrorToStderr(context, error);
@@ -4196,6 +4825,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 {
@@ -4208,77 +4838,111 @@ async function* find(fs, context, args) {
 		yield* walkEntry(fs, context, {
 			...startPath,
 			depth: 0,
-			isDirectory: startStat.isDirectory
-		}, args, resolvedPredicates, state);
+			isDirectory: startStat.isDirectory,
+			size: startStat.size
+		}, args, resolvedPredicateBranches, state, hasEmptyPredicate);
 	}
 	context.status = state.hadError ? 1 : 0;
 }
-async function* walkEntry(fs, context, entry, args, predicates, state) {
-	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicates);
+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, predicates, 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);
 }
-async function resolvePredicates(predicates, fs, context) {
+async function resolvePredicates(predicateBranches, fs, context) {
 	const resolved = [];
-	for (const predicate of predicates) switch (predicate.kind) {
-		case "name": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "name",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "path": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "path",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "type":
-			resolved.push({
-				kind: "type",
-				types: new Set(predicate.types)
-			});
-			break;
-		default: {
-			const _exhaustive = predicate;
-			throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+	for (const branch of predicateBranches) {
+		const resolvedBranch = [];
+		for (const predicate of branch) switch (predicate.kind) {
+			case "name": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "name",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				break;
+			}
+			case "path": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "path",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				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",
+					types: new Set(predicate.types)
+				});
+				break;
+			default: {
+				const _exhaustive = predicate;
+				throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+			}
 		}
+		resolved.push(resolvedBranch);
 	}
 	return resolved;
 }
@@ -4296,20 +4960,65 @@ async function resolveStartPaths(fs, context, startPathWords) {
 	}
 	return startPaths;
 }
-function matchesPredicates(entry, predicates) {
-	for (const predicate of predicates) {
-		if (predicate.kind === "name") {
-			if (!predicate.matcher(basename$2(entry.displayPath))) return false;
+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, childPaths)) return true;
+	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, 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;
 		}
-		if (predicate.kind === "path") {
-			if (!predicate.matcher(entry.displayPath)) return false;
+		index += 1;
+		if (isEmacsEscapedOperatorChar(escapedChar)) {
+			translated += escapedChar;
 			continue;
 		}
-		const entryType = entry.isDirectory ? "d" : "f";
-		if (!predicate.types.has(entryType)) return false;
+		translated += escapeJsRegexLiteralChar(escapedChar);
 	}
-	return true;
+	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 = [];
@@ -4367,53 +5076,6 @@ 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();
@@ -4486,23 +5148,21 @@ async function runGrepCommandInner(options) {
 			lines: [],
 			selectedLineCount: 0
 		};
-		if (target.stdin) result = searchBuffer(stdinBytes ?? new Uint8Array(), target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
+		let binaryInput = false;
+		let targetBytes = null;
+		if (target.stdin) targetBytes = stdinBytes ?? new Uint8Array();
 		else {
 			if (target.absolutePath === null) continue;
-			let bytes;
 			try {
-				bytes = await options.fs.readFile(target.absolutePath);
+				targetBytes = await options.fs.readFile(target.absolutePath);
 			} catch {
 				hadError = true;
 				continue;
 			}
-			if (parsed.options.binaryWithoutMatch && !parsed.options.textMode && isBinaryBuffer(bytes)) result = {
-				hasSelectedLine: false,
-				lines: [],
-				selectedLineCount: 0
-			};
-			else result = searchBuffer(bytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		}
+		if (targetBytes === null) continue;
+		binaryInput = shouldTreatAsBinaryInput(targetBytes, parsed.options);
+		if (!(binaryInput && parsed.options.binaryWithoutMatch)) result = searchBuffer(targetBytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		if (parsed.options.listFilesWithMatches) {
 			if (result.hasSelectedLine) {
 				lines.push(target.displayPath);
@@ -4528,7 +5188,8 @@ async function runGrepCommandInner(options) {
 			continue;
 		}
 		if (result.hasSelectedLine) anySelected = true;
-		if (!parsed.options.quiet) lines.push(...result.lines);
+		if (!parsed.options.quiet) if (shouldPrintBinaryMatchMessage(binaryInput, result.hasSelectedLine, parsed.options)) lines.push(`Binary file ${target.displayPath} matches`);
+		else lines.push(...result.lines);
 		if (parsed.options.quiet && anySelected) break;
 	}
 	const corpusOverride = await maybeOverrideWithCorpusStatus(parsed.options.mode, normalized.patterns, searchTargets.targets, options.fs);
@@ -5287,6 +5948,15 @@ function isValidUtf8(bytes) {
 function isBinaryBuffer(bytes) {
 	return bytes.includes(0);
 }
+function shouldTreatAsBinaryInput(bytes, options) {
+	if (options.textMode || options.nullData) return false;
+	return isBinaryBuffer(bytes);
+}
+function shouldPrintBinaryMatchMessage(binaryInput, hasSelectedLine, options) {
+	if (!(binaryInput && hasSelectedLine)) return false;
+	if (options.binaryWithoutMatch || options.countOnly || options.listFilesWithMatches || options.listFilesWithoutMatch) return false;
+	return true;
+}
 function byteLengthOfPrefix(text, charIndex) {
 	return UTF8_ENCODER.encode(text.slice(0, charIndex)).byteLength;
 }
@@ -5443,8 +6113,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
@@ -5500,173 +6170,345 @@ function touch(fs) {
 	};
 }
 //#endregion
-//#region src/execute/producers.ts
-async function* files(...paths) {
-	for (const path of paths) yield {
-		kind: "file",
-		path
-	};
-}
-//#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);
+//#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* 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);
+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
+	};
 }
-function isScriptIR(ir) {
-	return "statements" in ir;
+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 toScriptIR(pipeline) {
-	return { statements: [{
-		chainMode: "always",
-		pipeline
-	}] };
+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 isPipelineSink(pipeline) {
-	const finalStep = pipeline.steps.at(-1);
-	if (!finalStep) return false;
-	return isEffectStep(finalStep) || hasRedirect(finalStep.redirections, "output");
+function splitDelimited(input, delimiter) {
+	if (delimiter === "") return input === "" ? [] : [input];
+	const parts = input.split(delimiter);
+	if (input.endsWith(delimiter)) parts.pop();
+	return parts;
 }
-function shouldExecuteStatement(chainMode, previousStatus) {
-	if (chainMode === "always") return true;
-	if (chainMode === "and") return previousStatus === 0;
-	return previousStatus !== 0;
+function splitInputLines(input) {
+	const lines = input.split("\n");
+	if (input.endsWith("\n")) lines.pop();
+	return lines;
 }
-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)
+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 {
-		kind: "stream",
-		value: runScriptToStream(script, fs, context)
+		items,
+		stopped: pushToken(items, state.current, eof)
 	};
 }
-async function runScriptToCompletion(script, fs, context) {
-	for (const statement of script.statements) {
-		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
-		try {
-			await drainResult(executePipeline(statement.pipeline, fs, context));
-		} catch (error) {
-			context.status = 1;
-			throw error;
-		}
-	}
+function appendEscapedChar(state, char) {
+	state.current += char;
+	state.escaped = false;
 }
-async function* runScriptToStream(script, fs, context) {
-	for (const statement of script.statements) {
-		if (!shouldExecuteStatement(statement.chainMode, context.status)) continue;
-		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;
-		}
+function appendQuotedChar(state, char) {
+	if (char === state.quote) {
+		state.quote = null;
+		return;
+	}
+	if (char === "\\") {
+		state.escaped = true;
+		return;
 	}
+	state.current += char;
 }
-async function drainResult(result) {
-	if (result.kind === "sink") {
-		await result.value;
+function appendUnquotedChar(state, char) {
+	if (char === "\"" || char === "'") {
+		state.quote = char;
+		return;
+	}
+	if (char === "\\") {
+		state.escaped = true;
 		return;
 	}
-	for await (const _record of result.value);
+	state.current += char;
 }
-function executePipeline(ir, fs, context) {
-	if (ir.steps.length === 0) return {
-		kind: "stream",
-		value: emptyStream()
+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 lastStep = ir.steps.at(-1);
-	if (!lastStep) return {
-		kind: "stream",
-		value: emptyStream()
+	const childContext = {
+		cwd: context.cwd,
+		globalVars: context.globalVars,
+		localVars: context.localVars,
+		status: context.status,
+		stderr: new BufferedOutputStream()
 	};
-	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)
-		};
+	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 [];
 	}
-	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;
-		})()
+	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
 	};
-	return applyOutputRedirect({
-		kind: "stream",
-		value: executePipelineToStream(ir.steps, fs, context)
-	}, lastStep, fs, context);
 }
-function executePipelineToStream(steps, fs, context, options = {}) {
+//#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"
+];
+const STREAM_COMMAND_SET = new Set(STREAM_COMMANDS);
+const ROOT_DIRECTORY$1 = "/";
+function lineRecordsFromPath(fs, path) {
 	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;
+		for await (const line of fs.readLines(path)) yield {
+			kind: "line",
+			text: line
+		};
 	})();
 }
-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);
+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}`);
 	}
-	await executeEffectStep(finalStep, fs, context);
+	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);
 }
-function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath) {
-	const builtinRuntime = createBuiltinRuntime(fs, context, input);
-	switch (step.cmd) {
-		case "cat": return (async function* () {
+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,
@@ -5686,7 +6528,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,
@@ -5696,14 +6543,44 @@ 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
 			};
 		})();
-		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) {
@@ -5714,7 +6591,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);
@@ -5732,7 +6614,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) {
@@ -5743,118 +6630,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-khztC2iY.mjs.map
+//# sourceMappingURL=execute-D1oWUkmO.mjs.map