shfs 0.3.3 → 0.3.4

package/dist/{execute-DV1hpsh-.mjs → execute-BinccNiS.mjs}

@@ -655,7 +655,7 @@ function compileCat(cmd) {
 /**
 * cd command handler for the AST-based compiler.
 */
-const ROOT_DIRECTORY$4 = "/";
+const ROOT_DIRECTORY$5 = "/";
 /**
 * Compile a cd command from SimpleCommandIR to StepIR.
 */
@@ -664,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$4) }
+		args: { path: positionalArgs[0] ?? literal(ROOT_DIRECTORY$5) }
 	};
 }
 /**
@@ -1179,8 +1179,8 @@ function parseGrepArgs(argv) {
 	options.excludeFiles = collectStringValues(parsed, argv, "exclude");
 	options.excludeDir = collectStringValues(parsed, argv, "excludeDir");
 	options.includeFiles = collectStringValues(parsed, argv, "include");
-	const explicitPatterns = collectExpandedValues(parsed, argv, "pattern");
-	const patternFiles = collectExpandedValues(parsed, argv, "file");
+	const explicitPatterns = collectExpandedValues$1(parsed, argv, "pattern");
+	const patternFiles = collectExpandedValues$1(parsed, argv, "file");
 	return {
 		diagnostics,
 		explicitPatterns,
@@ -1436,7 +1436,7 @@ function assignImplicitPattern(explicitPatterns, patternFiles, positionalOperand
 function collectStringValues(parsed, argv, canonical) {
 	return getValueOccurrences(parsed, argv, canonical).map((occurrence) => occurrence.value);
 }
-function collectExpandedValues(parsed, argv, canonical) {
+function collectExpandedValues$1(parsed, argv, canonical) {
 	const values = [];
 	for (const occurrence of getValueOccurrences(parsed, argv, canonical)) {
 		if (occurrence.source === "arg") {
@@ -1449,7 +1449,7 @@ function collectExpandedValues(parsed, argv, canonical) {
 	return values;
 }
 function getValueOccurrences(parsed, argv, canonical) {
-	const values = normalizeValueList(parsed.flags[canonical]);
+	const values = normalizeValueList$1(parsed.flags[canonical]);
 	const valueIndices = parsed.consumedValueIndices[canonical] ?? [];
 	const valueSources = parsed.consumedValueSources[canonical] ?? [];
 	const orders = parsed.flagOccurrenceOrder[canonical] ?? [];
@@ -1478,7 +1478,7 @@ function getValueOccurrences(parsed, argv, canonical) {
 	occurrences.sort((a, b) => a.order - b.order);
 	return occurrences;
 }
-function normalizeValueList(value) {
+function normalizeValueList$1(value) {
 	if (typeof value === "string") return [value];
 	if (Array.isArray(value)) return value;
 	return [];
@@ -1756,6 +1756,229 @@ function compileSet(cmd) {
 		}
 	};
 }
+const COMMAND = "sort";
+const CHECK_OPTION = "c";
+const QUIET_CHECK_OPTION = "C";
+const FIELD_SEPARATOR_OPTION = "t";
+const KEY_OPTION = "k";
+const NUMERIC_OPTION = "n";
+const UNIQUE_OPTION = "u";
+const DEFAULT_CHECK_MODE = "none";
+function compileSort(command) {
+	return {
+		cmd: COMMAND,
+		args: parseSortArgs(command.args)
+	};
+}
+function createDefaultSortArgs() {
+	return {
+		checkMode: DEFAULT_CHECK_MODE,
+		diagnostics: [],
+		fieldSeparator: null,
+		files: [],
+		keys: [],
+		numeric: false,
+		unique: false
+	};
+}
+function parseSortArgs(argv) {
+	const args = createDefaultSortArgs();
+	for (let index = 0; index < argv.length; index += 1) {
+		const word = argv[index];
+		if (!word) continue;
+		const token = expandedWordToString(word);
+		if (token === "--") {
+			args.files.push(...argv.slice(index + 1));
+			break;
+		}
+		if (!isOptionToken(token)) {
+			args.files.push(word);
+			continue;
+		}
+		if (token === `-${KEY_OPTION}`) {
+			const value = argv[index + 1];
+			addSeparatedKey(args, value, token, index);
+			index += 1;
+			continue;
+		}
+		if (token.startsWith(`-${KEY_OPTION}`)) {
+			addKey(args, token.slice(2), token, index);
+			continue;
+		}
+		if (token === `-${FIELD_SEPARATOR_OPTION}`) {
+			const value = argv[index + 1];
+			addSeparatedFieldSeparator(args, value, token, index);
+			index += 1;
+			continue;
+		}
+		if (token.startsWith(`-${FIELD_SEPARATOR_OPTION}`)) {
+			addFieldSeparator(args, token.slice(2), token, index);
+			continue;
+		}
+		applyShortOptions(args, token, index);
+	}
+	return args;
+}
+function isOptionToken(token) {
+	return token.startsWith("-") && token !== "-";
+}
+function addSeparatedKey(args, value, token, tokenIndex) {
+	if (!value) {
+		addDiagnostic(args, "missing-key", "option requires an argument", token, tokenIndex);
+		return;
+	}
+	addKey(args, expandedWordToString(value), token, tokenIndex);
+}
+function addKey(args, raw, token, tokenIndex) {
+	const parsed = parseSortKey(raw, token, tokenIndex, args.diagnostics);
+	if (parsed) args.keys.push(parsed);
+}
+function addSeparatedFieldSeparator(args, value, token, tokenIndex) {
+	if (!value) {
+		addDiagnostic(args, "missing-separator", "option requires an argument", token, tokenIndex);
+		return;
+	}
+	addFieldSeparator(args, expandedWordToString(value), token, tokenIndex);
+}
+function addFieldSeparator(args, raw, token, tokenIndex) {
+	const characters = Array.from(raw);
+	const separator = characters.at(0);
+	if (separator === void 0) {
+		addDiagnostic(args, "empty-separator", "empty tab", token, tokenIndex);
+		return;
+	}
+	if (characters.length > 1) {
+		addDiagnostic(args, "multi-character-separator", `multi-character tab '${raw}'`, token, tokenIndex);
+		return;
+	}
+	args.fieldSeparator = separator;
+}
+function applyShortOptions(args, token, tokenIndex) {
+	const options = token.slice(1);
+	for (const option of options) switch (option) {
+		case CHECK_OPTION:
+			applyCheckMode(args, "diagnose-first", token, tokenIndex);
+			break;
+		case QUIET_CHECK_OPTION:
+			applyCheckMode(args, "quiet", token, tokenIndex);
+			break;
+		case NUMERIC_OPTION:
+			args.numeric = true;
+			break;
+		case UNIQUE_OPTION:
+			args.unique = true;
+			break;
+		default: addDiagnostic(args, "unknown-option", `invalid option -- '${option}'`, token, tokenIndex);
+	}
+}
+function applyCheckMode(args, checkMode, token, tokenIndex) {
+	if (args.checkMode !== "none" && args.checkMode !== checkMode) addDiagnostic(args, "incompatible-options", "options '-cC' are incompatible", token, tokenIndex);
+	args.checkMode = checkMode;
+}
+function parseSortKey(raw, token, tokenIndex, diagnostics) {
+	const commaIndex = raw.indexOf(",");
+	const start = parseKeyPosition({
+		diagnostics,
+		partEnd: commaIndex === -1 ? raw.length : commaIndex,
+		partStart: 0,
+		raw,
+		token,
+		tokenIndex,
+		type: "start"
+	});
+	const end = commaIndex === -1 ? null : parseKeyPosition({
+		diagnostics,
+		partEnd: raw.length,
+		partStart: commaIndex + 1,
+		raw,
+		token,
+		tokenIndex,
+		type: "end"
+	});
+	if (!start || commaIndex !== -1 && !end) return null;
+	return {
+		end: end?.position ?? null,
+		options: { numeric: start.numeric || (end?.numeric ?? false) },
+		raw,
+		start: start.position
+	};
+}
+function parseKeyPosition(options) {
+	const { diagnostics, partEnd, partStart, raw, token, tokenIndex, type } = options;
+	const fieldDigits = readDigits(raw, partStart, partEnd);
+	if (fieldDigits.value === "") {
+		addInvalidNumberDiagnostic(diagnostics, raw, partStart, token, tokenIndex);
+		return null;
+	}
+	const field = Number(fieldDigits.value);
+	if (field === 0) {
+		diagnostics.push(createSortDiagnostic("invalid-key", `invalid field specification '${raw}'`, token, tokenIndex));
+		return null;
+	}
+	let cursor = fieldDigits.nextIndex;
+	let character = null;
+	if (raw.at(cursor) === "." && cursor < partEnd) {
+		const characterDigits = readDigits(raw, cursor + 1, partEnd);
+		if (characterDigits.value === "") {
+			addCharacterNumberDiagnostic(diagnostics, raw, cursor + 1, token, tokenIndex);
+			return null;
+		}
+		character = Number(characterDigits.value);
+		if (character === 0 && type === "start") {
+			diagnostics.push(createSortDiagnostic("invalid-key", "character offset is zero", token, tokenIndex), createSortDiagnostic("invalid-key", `invalid field specification '${raw}'`, token, tokenIndex));
+			return null;
+		}
+		cursor = characterDigits.nextIndex;
+	}
+	const ordering = readOrderingOptions(raw, cursor, partEnd, token, tokenIndex, diagnostics);
+	if (!ordering) return null;
+	return {
+		numeric: ordering.numeric,
+		position: {
+			character,
+			field
+		}
+	};
+}
+function readDigits(text, start, end) {
+	let cursor = start;
+	while (cursor < end) {
+		const character = text.at(cursor);
+		if (character === void 0 || character < "0" || character > "9") break;
+		cursor += 1;
+	}
+	return {
+		nextIndex: cursor,
+		value: text.slice(start, cursor)
+	};
+}
+function readOrderingOptions(raw, start, end, token, tokenIndex, diagnostics) {
+	let numeric = false;
+	for (let cursor = start; cursor < end; cursor += 1) {
+		if (raw.at(cursor) === NUMERIC_OPTION) {
+			numeric = true;
+			continue;
+		}
+		diagnostics.push(createSortDiagnostic("invalid-key", `invalid count at start of '${raw.slice(cursor)}'`, token, tokenIndex));
+		return null;
+	}
+	return { numeric };
+}
+function addInvalidNumberDiagnostic(diagnostics, raw, position, token, tokenIndex) {
+	diagnostics.push(createSortDiagnostic("invalid-key", "invalid number after ','", token, tokenIndex), createSortDiagnostic("invalid-key", `invalid count at start of '${raw.slice(position)}'`, token, tokenIndex));
+}
+function addCharacterNumberDiagnostic(diagnostics, raw, position, token, tokenIndex) {
+	diagnostics.push(createSortDiagnostic("invalid-key", "invalid number after '.'", token, tokenIndex), createSortDiagnostic("invalid-key", `invalid count at start of '${raw.slice(position)}'`, token, tokenIndex));
+}
+function addDiagnostic(args, code, message, token, tokenIndex) {
+	args.diagnostics.push(createSortDiagnostic(code, message, token, tokenIndex));
+}
+function createSortDiagnostic(code, message, token, tokenIndex) {
+	return createCommandDiagnostic(COMMAND, code, message, {
+		token,
+		tokenIndex
+	});
+}
 function compileString(cmd) {
 	const [subcommand, ...operands] = cmd.args;
 	if (!subcommand) throw new Error("string requires a subcommand");
@@ -1861,6 +2084,109 @@ function compileTouch(cmd) {
 		}
 	};
 }
+/**
+* tree command handler for the AST-based compiler.
+*/
+const parseTreeArgs = createWordParser({
+	ascii: {
+		short: "A",
+		takesValue: false
+	},
+	classify: {
+		short: "F",
+		takesValue: false
+	},
+	dirsOnly: {
+		short: "d",
+		takesValue: false
+	},
+	excludePattern: {
+		short: "I",
+		takesValue: true,
+		multiple: true,
+		allowFlagLikeValue: true
+	},
+	fullPath: {
+		short: "f",
+		takesValue: false
+	},
+	includePattern: {
+		short: "P",
+		takesValue: true,
+		multiple: true,
+		allowFlagLikeValue: true
+	},
+	matchDirs: {
+		long: "matchdirs",
+		takesValue: false
+	},
+	maxDepth: {
+		short: "L",
+		takesValue: true
+	},
+	noReport: {
+		long: "noreport",
+		takesValue: false
+	},
+	prune: {
+		long: "prune",
+		takesValue: false
+	},
+	showAll: {
+		short: "a",
+		takesValue: false
+	}
+}, expandedWordToString);
+function compileTree(command) {
+	const parsed = parseTreeArgs(command.args);
+	return {
+		cmd: "tree",
+		args: {
+			ascii: parsed.flags.ascii === true,
+			classify: parsed.flags.classify === true,
+			dirsOnly: parsed.flags.dirsOnly === true,
+			excludePatterns: collectExpandedValues(parsed, command.args, "excludePattern"),
+			fullPath: parsed.flags.fullPath === true,
+			includePatterns: collectExpandedValues(parsed, command.args, "includePattern"),
+			matchDirs: parsed.flags.matchDirs === true,
+			maxDepth: parseMaxDepth(parsed.flags.maxDepth),
+			noReport: parsed.flags.noReport === true,
+			paths: parsed.positionalWords.length === 0 ? [literal(".")] : parsed.positionalWords,
+			prune: parsed.flags.prune === true,
+			showAll: parsed.flags.showAll === true
+		}
+	};
+}
+function parseMaxDepth(value) {
+	if (typeof value !== "string") return null;
+	const maxDepth = Number.parseInt(value, 10);
+	if (!Number.isFinite(maxDepth) || maxDepth < 0) throw new Error(`tree: invalid level, '${value}'`);
+	return maxDepth;
+}
+function collectExpandedValues(parsed, argv, canonical) {
+	const values = [];
+	const rawValues = normalizeValueList(parsed.flags[canonical]);
+	const valueIndices = parsed.consumedValueIndices[canonical] ?? [];
+	const valueSources = parsed.consumedValueSources[canonical] ?? [];
+	const count = Math.min(rawValues.length, valueIndices.length);
+	for (let index = 0; index < count; index += 1) {
+		const rawValue = rawValues[index];
+		const valueIndex = valueIndices[index];
+		const source = valueSources[index];
+		if (rawValue === void 0 || valueIndex === void 0) continue;
+		if (source === "arg") {
+			values.push(argv[valueIndex] ?? literal(rawValue));
+			continue;
+		}
+		values.push(literal(rawValue));
+	}
+	return values;
+}
+function normalizeValueList(value) {
+	if (typeof value === "string") return [value];
+	if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
+	return [];
+}
 const DEFAULT_TOTAL_MODE = "auto";
 function compileWc(command) {
 	return {
@@ -2148,10 +2474,12 @@ let CommandHandler;
 		read: compileRead,
 		rm: compileRm,
 		set: compileSet,
+		sort: compileSort,
 		string: compileString,
 		tail: compileTail,
 		test: compileTest,
 		touch: compileTouch,
+		tree: compileTree,
 		wc: compileWc,
 		xargs: compileXargs
 	};
@@ -4238,8 +4566,8 @@ function toErrorMessage$1(diagnostic) {
 //#endregion
 //#region src/execute/path.ts
 const MULTIPLE_SLASH_REGEX$2 = /\/+/g;
-const ROOT_DIRECTORY$3 = "/";
-const TRAILING_SLASH_REGEX$2 = /\/+$/;
+const ROOT_DIRECTORY$4 = "/";
+const TRAILING_SLASH_REGEX$3 = /\/+$/;
 const VARIABLE_REFERENCE_REGEX = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
 const NO_GLOB_MATCH_MESSAGE = "no matches found";
 async function collectOutputRecords(result) {
@@ -4265,7 +4593,7 @@ function expandVariables(input, context) {
 	});
 }
 function normalizeAbsolutePath(path) {
-	const segments = (path.startsWith(ROOT_DIRECTORY$3) ? path : `${ROOT_DIRECTORY$3}${path}`).replace(MULTIPLE_SLASH_REGEX$2, "/").split(ROOT_DIRECTORY$3);
+	const segments = (path.startsWith(ROOT_DIRECTORY$4) ? path : `${ROOT_DIRECTORY$4}${path}`).replace(MULTIPLE_SLASH_REGEX$2, "/").split(ROOT_DIRECTORY$4);
 	const normalizedSegments = [];
 	for (const segment of segments) {
 		if (segment === "" || segment === ".") continue;
@@ -4275,17 +4603,17 @@ function normalizeAbsolutePath(path) {
 		}
 		normalizedSegments.push(segment);
 	}
-	const normalizedPath = `${ROOT_DIRECTORY$3}${normalizedSegments.join(ROOT_DIRECTORY$3)}`;
-	return normalizedPath === "" ? ROOT_DIRECTORY$3 : normalizedPath;
+	const normalizedPath = `${ROOT_DIRECTORY$4}${normalizedSegments.join(ROOT_DIRECTORY$4)}`;
+	return normalizedPath === "" ? ROOT_DIRECTORY$4 : normalizedPath;
 }
 function normalizeCwd(cwd) {
-	if (cwd === "") return ROOT_DIRECTORY$3;
-	const trimmed = normalizeAbsolutePath(cwd).replace(TRAILING_SLASH_REGEX$2, "");
-	return trimmed === "" ? ROOT_DIRECTORY$3 : trimmed;
+	if (cwd === "") return ROOT_DIRECTORY$4;
+	const trimmed = normalizeAbsolutePath(cwd).replace(TRAILING_SLASH_REGEX$3, "");
+	return trimmed === "" ? ROOT_DIRECTORY$4 : trimmed;
 }
 function resolvePathFromCwd(cwd, path) {
 	if (path === "") return cwd;
-	if (path.startsWith(ROOT_DIRECTORY$3)) return normalizeAbsolutePath(path);
+	if (path.startsWith(ROOT_DIRECTORY$4)) return normalizeAbsolutePath(path);
 	return normalizeAbsolutePath(`${cwd}/${path}`);
 }
 function resolvePathsFromCwd(cwd, paths) {
@@ -4300,7 +4628,7 @@ async function readDirectoryPaths(fs, directoryPath) {
 	children.sort((left, right) => left.localeCompare(right));
 	return children;
 }
-async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$3) {
+async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$4) {
 	const normalizedRoot = normalizeAbsolutePath(rootDir);
 	if (!(await fs.stat(normalizedRoot)).isDirectory) throw new Error(`Not a directory: ${normalizedRoot}`);
 	const entries = [];
@@ -4322,12 +4650,12 @@ async function walkFilesystemEntries(fs, rootDir = ROOT_DIRECTORY$3) {
 	return entries;
 }
 function toRelativePathFromCwd$1(path, cwd) {
-	if (cwd === ROOT_DIRECTORY$3) {
-		if (path === ROOT_DIRECTORY$3) return null;
-		return path.startsWith(ROOT_DIRECTORY$3) ? path.slice(1) : path;
+	if (cwd === ROOT_DIRECTORY$4) {
+		if (path === ROOT_DIRECTORY$4) return null;
+		return path.startsWith(ROOT_DIRECTORY$4) ? path.slice(1) : path;
 	}
 	if (path === cwd) return null;
-	const prefix = `${cwd}${ROOT_DIRECTORY$3}`;
+	const prefix = `${cwd}${ROOT_DIRECTORY$4}`;
 	if (!path.startsWith(prefix)) return null;
 	return path.slice(prefix.length);
 }
@@ -4335,12 +4663,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$3}`;
+	if (directoryOnly) return `${basePath}${ROOT_DIRECTORY$4}`;
 	return basePath;
 }
 async function expandGlobPattern(pattern, fs, context) {
-	const directoryOnly = pattern.endsWith(ROOT_DIRECTORY$3);
-	const isAbsolutePattern = pattern.startsWith(ROOT_DIRECTORY$3);
+	const directoryOnly = pattern.endsWith(ROOT_DIRECTORY$4);
+	const isAbsolutePattern = pattern.startsWith(ROOT_DIRECTORY$4);
 	const matcher = picomatch(pattern, {
 		bash: true,
 		dot: false
@@ -4405,28 +4733,10 @@ async function evaluateExpandedWordPart(part, fs, context) {
 }
 //#endregion
 //#region src/execute/records.ts
-async function* toLineStream(fs, input) {
-	for await (const record of input) {
-		if (record.kind === "line") {
-			yield record;
-			continue;
-		}
-		if (record.kind === "file") {
-			yield* fileRecordToLines(fs, record);
-			continue;
-		}
-		yield {
-			kind: "line",
-			text: JSON.stringify(record.value)
-		};
-	}
-}
 /**
-* Converts any ShellRecord stream into LineRecords by formatting each record
-* as its display text. Unlike `toLineStream`, this does NOT read file contents —
-* FileRecords are rendered as their path, which is the correct behavior for
-* line-oriented transducers (tail, head) receiving piped input from commands
-* like `find` that produce path listings.
+* Converts records into stdin-style line text. Unlike `toLineStream`, this does
+* not read FileRecord contents. FileRecords are rendered as paths, matching the
+* shell pipe boundary where downstream line-oriented commands consume text.
 */
 async function* toFormattedLineStream(input) {
 	for await (const record of input) {
@@ -4440,16 +4750,6 @@ async function* toFormattedLineStream(input) {
 		};
 	}
 }
-async function* fileRecordToLines(fs, record) {
-	if (await isDirectoryRecord(fs, record)) return;
-	let lineNum = 1;
-	for await (const text of fs.readLines(record.path)) yield {
-		kind: "line",
-		text,
-		file: record.path,
-		lineNum: lineNum++
-	};
-}
 async function isDirectoryRecord(fs, record) {
 	if (record.isDirectory !== void 0) return record.isDirectory;
 	try {
@@ -4458,14 +4758,12 @@ 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]+$/;
+const NULL_DEVICE_PATH = "/dev/null";
 function getSourceFd$1(redirection) {
 	return redirection.sourceFd ?? (redirection.kind === "input" ? 0 : 1);
 }
@@ -4572,6 +4870,7 @@ async function readExistingFileText(fs, path) {
 	}
 }
 async function writeTextToFile(fs, path, content, options) {
+	if (isNullDevicePath(path)) return;
 	if (!(options.append ?? false)) {
 		await fs.writeFile(path, textEncoder.encode(content));
 		return;
@@ -4581,8 +4880,12 @@ async function writeTextToFile(fs, path, content, options) {
 	await fs.writeFile(path, textEncoder.encode(`${existing}${separator}${content}`));
 }
 async function ensureNoclobberWritable(fs, path) {
+	if (isNullDevicePath(path)) return true;
 	return !await fs.exists(path);
 }
+function isNullDevicePath(path) {
+	return path === NULL_DEVICE_PATH;
+}
 //#endregion
 //#region src/builtin/cd/cd.ts
 const cd = async (runtime, args) => {
@@ -4616,21 +4919,9 @@ const VARIABLE_NAME_REGEX$1 = /^[A-Za-z_][A-Za-z0-9_]*$/;
 async function readFirstValue(runtime) {
 	if (!runtime.input) return null;
 	let firstValue = null;
-	for await (const record of runtime.input) {
-		const value = await recordToText(runtime, record);
-		if (value !== null && firstValue === null) firstValue = value;
-	}
+	for await (const line of runtime.stdin.lines()) if (firstValue === null) firstValue = line;
 	return firstValue;
 }
-async function recordToText(runtime, record) {
-	if (record.kind === "line") return record.text;
-	if (record.kind === "file") {
-		if (await isDirectoryRecord(runtime.fs, record)) return null;
-		for await (const line of runtime.fs.readLines(record.path)) return line;
-		return "";
-	}
-	return JSON.stringify(record.value);
-}
 const read = (runtime, args) => {
 	return (async function* () {
 		const name = await evaluateExpandedWord(args.name, runtime.fs, runtime.context);
@@ -4661,14 +4952,21 @@ const set = (runtime, args) => {
 };
 //#endregion
 //#region src/builtin/string/string.ts
+async function collectStdinLines(runtime) {
+	if (!runtime.input) return [];
+	const lines = [];
+	for await (const line of runtime.stdin.lines()) lines.push(line);
+	return lines;
+}
 function replace(runtime, operands) {
 	return (async function* () {
 		if (operands[0]?.startsWith("-")) throw new Error(`string replace: unsupported flag: ${operands[0]}`);
-		if (operands.length < 3) throw new Error("string replace requires pattern replacement text");
+		if (operands.length < 2) throw new Error("string replace requires pattern replacement text");
 		const pattern = operands.at(0);
 		const replacement = operands.at(1);
-		const inputs = operands.slice(2);
 		if (pattern === void 0 || replacement === void 0) throw new Error("string replace requires pattern replacement text");
+		if (operands.length === 2 && !runtime.input) throw new Error("string replace requires pattern replacement text");
+		const inputs = operands.length > 2 ? operands.slice(2) : await collectStdinLines(runtime);
 		if (inputs.length === 0) {
 			runtime.context.status = 1;
 			return;
@@ -4680,29 +4978,44 @@ function replace(runtime, operands) {
 		runtime.context.status = 0;
 	})();
 }
+async function parseMatchInvocation(runtime, operands) {
+	let quiet = false;
+	let offset = 0;
+	while (operands[offset]?.startsWith("-")) {
+		const flag = operands[offset];
+		if (flag === "-q" && !quiet) {
+			quiet = true;
+			offset += 1;
+			continue;
+		}
+		throw new Error(`string match: unsupported flag: ${flag}`);
+	}
+	const filtered = operands.slice(offset);
+	const [pattern] = filtered;
+	if (!pattern) throw new Error("string match requires pattern and value");
+	if (filtered.length > 2) throw new Error("string match: unsupported arguments");
+	if (filtered.length === 1 && !runtime.input) throw new Error("string match requires pattern and value");
+	const values = filtered.length > 1 ? filtered.slice(1) : await collectStdinLines(runtime);
+	return {
+		pattern,
+		quiet,
+		values
+	};
+}
 function match(runtime, operands) {
 	return (async function* () {
-		let quiet = false;
-		let offset = 0;
-		while (operands[offset]?.startsWith("-")) {
-			const flag = operands[offset];
-			if (flag === "-q" && !quiet) {
-				quiet = true;
-				offset += 1;
-				continue;
-			}
-			throw new Error(`string match: unsupported flag: ${flag}`);
-		}
-		const filtered = operands.slice(offset);
-		const [pattern, value] = filtered;
-		if (!(pattern && value !== void 0)) throw new Error("string match requires pattern and value");
-		if (filtered.length > 2) throw new Error("string match: unsupported arguments");
-		const isMatch = picomatch(pattern, { dot: true })(value);
-		runtime.context.status = isMatch ? 0 : 1;
-		if (isMatch && !quiet) yield {
-			kind: "line",
-			text: value
-		};
+		const { pattern, quiet, values } = await parseMatchInvocation(runtime, operands);
+		const matcher = picomatch(pattern, { dot: true });
+		let matched = false;
+		for (const value of values) {
+			if (!matcher(value)) continue;
+			matched = true;
+			if (!quiet) yield {
+				kind: "line",
+				text: value
+			};
+		}
+		runtime.context.status = matched ? 0 : 1;
 	})();
 }
 const string = (runtime, args) => {
@@ -4851,16 +5164,16 @@ function cat(fs, options) {
 }
 //#endregion
 //#region src/operator/cp/cp.ts
-const TRAILING_SLASH_REGEX$1 = /\/+$/;
+const TRAILING_SLASH_REGEX$2 = /\/+$/;
 const MULTIPLE_SLASH_REGEX$1 = /\/+/g;
 function trimTrailingSlash$2(path) {
 	if (path === "/") return path;
-	return path.replace(TRAILING_SLASH_REGEX$1, "");
+	return path.replace(TRAILING_SLASH_REGEX$2, "");
 }
 function joinPath$1(base, suffix) {
 	return `${trimTrailingSlash$2(base)}/${suffix}`.replace(MULTIPLE_SLASH_REGEX$1, "/");
 }
-function basename$3(path) {
+function basename$4(path) {
 	const normalized = trimTrailingSlash$2(path);
 	const slashIndex = normalized.lastIndexOf("/");
 	if (slashIndex === -1) return normalized;
@@ -4911,7 +5224,7 @@ async function copyDirectoryRecursive(fs, srcDir, destDir, force, interactive) {
 		if (!current) continue;
 		const childPaths = await readDirectory(current.sourcePath);
 		for (const childPath of childPaths) {
-			const childName = basename$3(childPath);
+			const childName = basename$4(childPath);
 			const targetPath = joinPath$1(current.targetPath, childName);
 			if ((await fs.stat(childPath)).isDirectory) {
 				await ensureDirectory(targetPath);
@@ -4932,7 +5245,7 @@ function cp(fs) {
 		if (srcs.length > 1 && !destinationIsDirectory) throw new Error("cp destination must be a directory for multiple sources");
 		for (const src of srcs) {
 			const srcStat = await fs.stat(src);
-			const targetPath = destinationIsDirectory || srcs.length > 1 ? joinPath$1(dest, basename$3(src)) : dest;
+			const targetPath = destinationIsDirectory || srcs.length > 1 ? joinPath$1(dest, basename$4(src)) : dest;
 			if (srcStat.isDirectory) {
 				if (!recursive) throw new Error(`cp: omitting directory "${src}" (use -r)`);
 				await copyDirectoryRecursive(fs, src, targetPath, force, interactive);
@@ -5004,12 +5317,12 @@ async function* walkEntry(fs, context, entry, args, predicateBranches, state, ha
 			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)) })]);
+			writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "missing-path", "No such file or directory", { path: appendDisplayPath(entry.displayPath, basename$3(childAbsolutePath)) })]);
 			continue;
 		}
 		yield* walkEntry(fs, context, {
 			absolutePath: childAbsolutePath,
-			displayPath: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)),
+			displayPath: appendDisplayPath(entry.displayPath, basename$3(childAbsolutePath)),
 			depth: entry.depth + 1,
 			isDirectory: childStat.isDirectory,
 			size: childStat.size
@@ -5113,7 +5426,7 @@ function matchesBranch(entry, entryType, branch, childPaths) {
 	return true;
 }
 function matchesPredicate(entry, entryType, predicate, childPaths) {
-	if (predicate.kind === "name") return predicate.matcher(basename$2(entry.displayPath));
+	if (predicate.kind === "name") return predicate.matcher(basename$3(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;
@@ -5172,7 +5485,7 @@ function appendDisplayPath(parentPath, childName) {
 	if (parentPath === ".") return `./${childName}`;
 	return `${parentPath}/${childName}`;
 }
-function basename$2(path) {
+function basename$3(path) {
 	if (path === "/") return "/";
 	const normalized = trimTrailingSlashes(path);
 	const slashIndex = normalized.lastIndexOf("/");
@@ -5218,6 +5531,54 @@ function trimTrailingSlashes(path) {
 	return path.replace(/\/+$/g, "");
 }
 //#endregion
+//#region src/execute/io.ts
+const UTF8_ENCODER$2 = new TextEncoder();
+const NEWLINE = "\n";
+var EmptyInput = class {
+	async *records() {}
+	async *lines() {}
+	async bytes() {
+		return new Uint8Array();
+	}
+};
+var RecordInput = class {
+	input;
+	constructor(input) {
+		this.input = input;
+	}
+	records() {
+		return this.input;
+	}
+	async *lines() {
+		for await (const record of this.input) yield formatStdoutRecord(record);
+	}
+	async bytes(options = {}) {
+		const lines = [];
+		for await (const line of this.lines()) lines.push(line);
+		if (lines.length === 0) return new Uint8Array();
+		const text = options.trailingNewline ? `${lines.join(NEWLINE)}${NEWLINE}` : lines.join(NEWLINE);
+		return UTF8_ENCODER$2.encode(text);
+	}
+};
+var BufferedShellOutput = class {
+	bufferedRecords = [];
+	write(record) {
+		this.bufferedRecords.push(record);
+	}
+	writeLine(text) {
+		this.write({
+			kind: "line",
+			text
+		});
+	}
+	records() {
+		return [...this.bufferedRecords];
+	}
+};
+function createShellInput(input) {
+	return input ? new RecordInput(input) : new EmptyInput();
+}
+//#endregion
 //#region src/operator/grep/grep.ts
 const UTF8_DECODER$1 = new TextDecoder();
 const UTF8_ENCODER$1 = new TextEncoder();
@@ -5280,7 +5641,12 @@ async function runGrepCommandInner(options) {
 	hadError ||= matcherBuild.compileError;
 	const searchTargets = await collectSearchTargets(normalized.fileOperands, parsed.options, options.fs, options.context);
 	hadError ||= searchTargets.hadError;
-	const stdinBytes = normalized.readsFromStdin ? await readStdinBytes(options.fs, options.input, inputRedirectPath) : null;
+	const stdinBytes = normalized.readsFromStdin ? await readStdinBytes({
+		fs: options.fs,
+		input: options.input,
+		inputRedirect: inputRedirectPath,
+		stdin: options.stdin
+	}) : null;
 	const displayFilename = shouldDisplayFilename(parsed.options, normalized.fileOperands);
 	const lines = [];
 	let anySelected = false;
@@ -5456,7 +5822,7 @@ async function collectSearchTargets(fileOperands, options, fs, context) {
 	const excludeMatchers = options.excludeFiles.map((pattern) => picomatch(pattern, { dot: true }));
 	const excludeDirMatchers = options.excludeDir.map((pattern) => picomatch(pattern, { dot: true }));
 	const shouldIncludeFile = (filePath) => {
-		const name = basename$1(filePath);
+		const name = basename$2(filePath);
 		if (excludeMatchers.some((matcher) => matcher(name))) return false;
 		if (includeMatchers.length > 0 && !includeMatchers.some((matcher) => matcher(name))) return false;
 		return true;
@@ -5472,7 +5838,7 @@ async function collectSearchTargets(fileOperands, options, fs, context) {
 				continue;
 			}
 			if (stat.isDirectory) {
-				const childName = basename$1(childPath);
+				const childName = basename$2(childPath);
 				if (excludeDirMatchers.some((matcher) => matcher(childName))) continue;
 				await walkDirectory(childPath, preferRelative);
 				continue;
@@ -5538,7 +5904,7 @@ function trimTrailingSlash$1(path) {
 	if (path === "/") return path;
 	return path.replace(/\/+$/g, "");
 }
-function basename$1(path) {
+function basename$2(path) {
 	const normalized = trimTrailingSlash$1(path);
 	const slashIndex = normalized.lastIndexOf("/");
 	if (slashIndex === -1) return normalized;
@@ -5551,17 +5917,15 @@ function toDisplayPath(path, cwd, preferRelative) {
 	if (!path.startsWith(prefix)) return path;
 	return path.slice(prefix.length);
 }
-async function readStdinBytes(fs, input, inputRedirect) {
+async function readStdinBytes(options) {
+	const { fs, input, inputRedirect, stdin } = options;
 	if (inputRedirect !== null) try {
 		return await fs.readFile(inputRedirect);
 	} catch {
 		return new Uint8Array();
 	}
 	if (input === null) return new Uint8Array();
-	const lines = [];
-	for await (const line of toLineStream(fs, input)) lines.push(line.text);
-	if (lines.length === 0) return new Uint8Array();
-	return UTF8_ENCODER$1.encode(`${lines.join("\n")}\n`);
+	return await (stdin ?? createShellInput(input)).bytes({ trailingNewline: true });
 }
 function hasInputOutputConflict(fileOperands, readsFromStdin, cwd, inputRedirect, outputRedirect) {
 	if (outputRedirect === null) return false;
@@ -6182,7 +6546,7 @@ function headWithN(fs, n) {
 }
 //#endregion
 //#region src/operator/ls/ls.ts
-function basename(path) {
+function basename$1(path) {
 	const normalized = path.replace(/\/+$/g, "");
 	const slashIndex = normalized.lastIndexOf("/");
 	if (slashIndex === -1) return normalized;
@@ -6198,7 +6562,7 @@ async function* ls(fs, path, options) {
 		return;
 	}
 	for await (const childPath of fs.readdir(path)) {
-		if (!showAll && basename(childPath).startsWith(".")) continue;
+		if (!showAll && basename$1(childPath).startsWith(".")) continue;
 		yield {
 			kind: "file",
 			path: childPath
@@ -6214,10 +6578,10 @@ function mkdir(fs) {
 }
 //#endregion
 //#region src/operator/mv/mv.ts
-const TRAILING_SLASH_REGEX = /\/+$/;
+const TRAILING_SLASH_REGEX$1 = /\/+$/;
 const MULTIPLE_SLASH_REGEX = /\/+/g;
 function trimTrailingSlash(path) {
-	return path.replace(TRAILING_SLASH_REGEX, "");
+	return path.replace(TRAILING_SLASH_REGEX$1, "");
 }
 function extractFileName(path) {
 	const normalized = trimTrailingSlash(path);
@@ -6255,8 +6619,8 @@ function mv(fs) {
 }
 //#endregion
 //#region src/operator/pwd/pwd.ts
-const ROOT_DIRECTORY$2 = "/";
-async function* pwd(cwd = ROOT_DIRECTORY$2) {
+const ROOT_DIRECTORY$3 = "/";
+async function* pwd(cwd = ROOT_DIRECTORY$3) {
 	yield {
 		kind: "line",
 		text: cwd
@@ -6283,6 +6647,377 @@ function rm(fs) {
 	};
 }
 //#endregion
+//#region src/operator/sort/sort.ts
+const STDIN_FILE_NAME$1 = "-";
+const UTF8_ENCODER = new TextEncoder();
+async function runSortCommand(options) {
+	if (options.parsed.diagnostics.length > 0) return {
+		exitCode: 2,
+		stderr: options.parsed.diagnostics.map((diagnostic) => `sort: ${diagnostic.message}`),
+		stdout: []
+	};
+	const fileOperands = await evaluateExpandedPathWords("sort", options.parsed.files, options.fs, options.context);
+	const stdinReader = createStdinLineReader(options);
+	if (options.parsed.checkMode !== "none") return runCheckMode(options, fileOperands, stdinReader);
+	const input = await collectSortInput(options, fileOperands, stdinReader);
+	if (input.exitCode !== 0) return {
+		exitCode: input.exitCode,
+		stderr: input.stderr,
+		stdout: []
+	};
+	const sortedLines = sortLines(input.lines, options.parsed);
+	return {
+		exitCode: 0,
+		stderr: [],
+		stdout: options.parsed.unique ? uniqueSortedLines(sortedLines, options.parsed) : sortedLines.map((line) => line.text)
+	};
+}
+async function runCheckMode(options, fileOperands, stdinReader) {
+	if (fileOperands.length > 1) return {
+		exitCode: 2,
+		stderr: [`sort: extra operand '${fileOperands[1] ?? ""}' not allowed with -${checkModeOption(options.parsed)}`],
+		stdout: []
+	};
+	const fileOperand = fileOperands.at(0);
+	if (fileOperand === STDIN_FILE_NAME$1) return checkStdinLines(stdinReader, options.parsed);
+	if (fileOperand !== void 0) return checkPathLines(options.fs, resolvePathFromCwd(options.context.cwd, fileOperand), fileOperand, options.parsed);
+	return checkStdinLines(stdinReader, options.parsed);
+}
+function checkModeOption(args) {
+	return args.checkMode === "quiet" ? "C" : "c";
+}
+async function checkStdinLines(stdinReader, args) {
+	try {
+		return await checkSortedLines(stdinReader.read(), args);
+	} catch {
+		return createStdinCheckReadError(stdinReader.displayPath);
+	}
+}
+async function checkPathLines(fs, path, displayPath, args) {
+	try {
+		return await checkSortedLines(fs.readLines(path), args);
+	} catch {
+		return {
+			exitCode: 2,
+			stderr: [`sort: cannot read: ${displayPath}: No such file or directory`],
+			stdout: []
+		};
+	}
+}
+async function checkSortedLines(lines, args) {
+	let previousLine = null;
+	for await (const text of lines) {
+		const currentLine = prepareSortLine(text, args);
+		if (previousLine && !isSortedPair(previousLine, currentLine, args)) return {
+			exitCode: 1,
+			stderr: args.checkMode === "quiet" ? [] : [`sort: disorder: ${currentLine.text}`],
+			stdout: []
+		};
+		previousLine = currentLine;
+	}
+	return {
+		exitCode: 0,
+		stderr: [],
+		stdout: []
+	};
+}
+function isSortedPair(previousLine, currentLine, args) {
+	if (args.unique) return comparePrimary(previousLine, currentLine, args) < 0;
+	return compareSortLines(previousLine, currentLine, args) <= 0;
+}
+async function collectSortInput(options, fileOperands, stdinReader) {
+	if (fileOperands.length > 0) return collectFileOperandLines(options, fileOperands, stdinReader);
+	return collectStdinLinesToArray(stdinReader);
+}
+async function collectFileOperandLines(options, fileOperands, stdinReader) {
+	const lines = [];
+	const stderr = [];
+	for (const operand of fileOperands) {
+		if (operand === STDIN_FILE_NAME$1) {
+			const result = await collectStdinLinesToArray(stdinReader);
+			if (result.exitCode !== 0) {
+				stderr.push(...result.stderr);
+				continue;
+			}
+			lines.push(...result.lines);
+			continue;
+		}
+		const path = resolvePathFromCwd(options.context.cwd, operand);
+		const result = await collectPathLines(options.fs, path, operand);
+		if (result.exitCode !== 0) {
+			stderr.push(...result.stderr);
+			continue;
+		}
+		lines.push(...result.lines);
+	}
+	return {
+		exitCode: stderr.length > 0 ? 2 : 0,
+		lines: stderr.length > 0 ? [] : lines,
+		stderr
+	};
+}
+async function collectPathLines(fs, path, displayPath) {
+	const lines = [];
+	try {
+		for await (const line of fs.readLines(path)) lines.push(line);
+	} catch {
+		return {
+			exitCode: 2,
+			lines: [],
+			stderr: [`sort: cannot read: ${displayPath}: No such file or directory`]
+		};
+	}
+	return {
+		exitCode: 0,
+		lines,
+		stderr: []
+	};
+}
+function createStdinLineReader(options) {
+	let hasRead = false;
+	return {
+		displayPath: options.inputPath,
+		read() {
+			if (hasRead) return emptyLines();
+			hasRead = true;
+			if (options.inputPath) return options.fs.readLines(options.inputPath);
+			return (options.stdin ?? createShellInput(options.input)).lines();
+		}
+	};
+}
+async function collectStdinLinesToArray(stdinReader) {
+	const lines = [];
+	try {
+		for await (const line of stdinReader.read()) lines.push(line);
+	} catch {
+		return createStdinInputReadError(stdinReader.displayPath);
+	}
+	return {
+		exitCode: 0,
+		lines,
+		stderr: []
+	};
+}
+async function* emptyLines() {}
+function createStdinCheckReadError(path) {
+	return {
+		exitCode: 2,
+		stderr: [createStdinReadErrorMessage(path)],
+		stdout: []
+	};
+}
+function createStdinInputReadError(path) {
+	return {
+		exitCode: 2,
+		lines: [],
+		stderr: [createStdinReadErrorMessage(path)]
+	};
+}
+function createStdinReadErrorMessage(path) {
+	return `sort: cannot read: ${path ?? STDIN_FILE_NAME$1}: No such file or directory`;
+}
+function sortLines(lines, args) {
+	return lines.map((line) => prepareSortLine(line, args)).sort((left, right) => compareSortLines(left, right, args));
+}
+function uniqueSortedLines(lines, args) {
+	const uniqueLines = [];
+	let previous = null;
+	for (const line of lines) {
+		if (previous && comparePrimary(previous, line, args) === 0) continue;
+		uniqueLines.push(line.text);
+		previous = line;
+	}
+	return uniqueLines;
+}
+function prepareSortLine(text, args) {
+	const value = createSortValue(text);
+	return {
+		keyValues: args.keys.map((key) => createSortValue(extractKey(text, key, args.fieldSeparator))),
+		text,
+		value
+	};
+}
+function createSortValue(text) {
+	return {
+		bytes: UTF8_ENCODER.encode(text),
+		numeric: parseNumericValue(text)
+	};
+}
+function compareSortLines(left, right, args) {
+	const primaryComparison = comparePrimary(left, right, args);
+	if (primaryComparison !== 0) return primaryComparison;
+	if (args.unique) return 0;
+	return compareBytes(left.value.bytes, right.value.bytes);
+}
+function comparePrimary(left, right, args) {
+	if (args.keys.length === 0) return compareValues(left.value, right.value, args.numeric);
+	for (const [index, key] of args.keys.entries()) {
+		const leftValue = left.keyValues[index];
+		const rightValue = right.keyValues[index];
+		if (!(leftValue && rightValue)) continue;
+		const comparison = compareValues(leftValue, rightValue, args.numeric || key.options.numeric);
+		if (comparison !== 0) return comparison;
+	}
+	return 0;
+}
+function compareValues(left, right, numeric) {
+	if (numeric) return compareNumericValues(left.numeric, right.numeric);
+	return compareBytes(left.bytes, right.bytes);
+}
+function compareNumericValues(left, right) {
+	if (left.sign !== right.sign) return left.sign - right.sign;
+	if (left.sign === 0) return 0;
+	const magnitudeComparison = compareNumericMagnitude(left, right);
+	return left.sign > 0 ? magnitudeComparison : -magnitudeComparison;
+}
+function compareNumericMagnitude(left, right) {
+	if (left.integer.length !== right.integer.length) return left.integer.length - right.integer.length;
+	const integerComparison = compareAsciiDigits(left.integer, right.integer);
+	if (integerComparison !== 0) return integerComparison;
+	const maxFractionLength = Math.max(left.fraction.length, right.fraction.length);
+	for (let index = 0; index < maxFractionLength; index += 1) {
+		const leftDigit = digitValue(left.fraction.at(index));
+		const rightDigit = digitValue(right.fraction.at(index));
+		if (leftDigit !== rightDigit) return leftDigit - rightDigit;
+	}
+	return 0;
+}
+function compareAsciiDigits(left, right) {
+	for (let index = 0; index < left.length; index += 1) {
+		const difference = digitValue(left.at(index)) - digitValue(right.at(index));
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+function parseNumericValue(value) {
+	let index = skipLeadingBlanks(value);
+	let sign = 1;
+	if (value.at(index) === "-") {
+		sign = -1;
+		index += 1;
+	}
+	const integerStart = index;
+	while (isAsciiDigit(value.at(index))) index += 1;
+	const integer = value.slice(integerStart, index);
+	let fraction = "";
+	if (value.at(index) === ".") {
+		index += 1;
+		const fractionStart = index;
+		while (isAsciiDigit(value.at(index))) index += 1;
+		fraction = value.slice(fractionStart, index);
+	}
+	if (integer === "" && fraction === "") return createZeroNumericValue();
+	const normalizedInteger = integer.replace(/^0+/g, "");
+	const normalizedFraction = fraction.replace(/0+$/g, "");
+	if (normalizedInteger === "" && normalizedFraction === "") return createZeroNumericValue();
+	return {
+		fraction: normalizedFraction,
+		integer: normalizedInteger,
+		sign
+	};
+}
+function createZeroNumericValue() {
+	return {
+		fraction: "",
+		integer: "",
+		sign: 0
+	};
+}
+function skipLeadingBlanks(value) {
+	let index = 0;
+	while (isBlank(value.at(index))) index += 1;
+	return index;
+}
+function isAsciiDigit(character) {
+	return character !== void 0 && character >= "0" && character <= "9";
+}
+function digitValue(character) {
+	return character === void 0 ? 0 : character.charCodeAt(0) - 48;
+}
+function compareBytes(left, right) {
+	const length = Math.min(left.byteLength, right.byteLength);
+	for (let index = 0; index < length; index += 1) {
+		const difference = (left[index] ?? 0) - (right[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return left.byteLength - right.byteLength;
+}
+function extractKey(line, key, fieldSeparator) {
+	const layout = createFieldLayout(line, fieldSeparator);
+	const start = keyPositionToStartIndex(line, layout, key.start);
+	const end = key.end ? keyPositionToEndIndex(line, layout, key.end) : line.length;
+	if (end < start) return "";
+	return line.slice(start, end);
+}
+function keyPositionToStartIndex(line, layout, position) {
+	const fieldStart = fieldStartIndex(layout, position.field, line.length);
+	if (position.character === null) return fieldStart;
+	return Math.min(fieldStart + position.character - 1, line.length);
+}
+function keyPositionToEndIndex(line, layout, position) {
+	const fieldStart = fieldStartIndex(layout, position.field, line.length);
+	if (position.character === null || position.character === 0) return fieldEndIndex(layout, position.field, line.length);
+	return Math.min(fieldStart + position.character, line.length);
+}
+function createFieldLayout(line, fieldSeparator) {
+	if (fieldSeparator !== null) return createSeparatedFieldLayout(line, fieldSeparator);
+	return createBlankDelimitedFieldLayout(line);
+}
+function createSeparatedFieldLayout(line, fieldSeparator) {
+	if (fieldSeparator === "") return {
+		ends: [line.length],
+		starts: [0]
+	};
+	const starts = [0];
+	const ends = [];
+	let index = 0;
+	while (index < line.length) {
+		if (!line.startsWith(fieldSeparator, index)) {
+			index += 1;
+			continue;
+		}
+		ends.push(index);
+		index += fieldSeparator.length;
+		starts.push(index);
+	}
+	ends.push(line.length);
+	return {
+		ends,
+		starts
+	};
+}
+function createBlankDelimitedFieldLayout(line) {
+	const starts = [0];
+	const ends = [];
+	let index = 0;
+	while (index < line.length) {
+		if (!isBlank(line.at(index))) {
+			index += 1;
+			continue;
+		}
+		const blankStart = index;
+		while (index < line.length && isBlank(line.at(index))) index += 1;
+		if (blankStart === 0) continue;
+		if (index >= line.length) continue;
+		ends.push(blankStart);
+		starts.push(blankStart);
+	}
+	while (ends.length < starts.length) ends.push(line.length);
+	return {
+		ends,
+		starts
+	};
+}
+function isBlank(character) {
+	return character === " " || character === "	";
+}
+function fieldStartIndex(layout, field, lineLength) {
+	return layout.starts[field - 1] ?? lineLength;
+}
+function fieldEndIndex(layout, field, lineLength) {
+	return layout.ends[field - 1] ?? lineLength;
+}
+//#endregion
 //#region src/operator/tail/tail.ts
 function tail(n) {
 	return async function* (input) {
@@ -6312,9 +7047,205 @@ function touch(fs) {
 	};
 }
 //#endregion
+//#region src/operator/tree/tree.ts
+const ROOT_DIRECTORY$2 = "/";
+const TRAILING_SLASH_REGEX = /\/+$/;
+const LINE_DRAWING = {
+	ascii: {
+		blank: "    ",
+		last: "`-- ",
+		mid: "|-- ",
+		pipe: "|   "
+	},
+	utf8: {
+		blank: "    ",
+		last: "└── ",
+		mid: "├── ",
+		pipe: "│   "
+	}
+};
+async function runTreeCommand(fs, cwd, args) {
+	const stdout = [];
+	const stderr = [];
+	const totals = {
+		dirs: 0,
+		files: 0
+	};
+	let exitCode = 0;
+	for (const path of args.paths) {
+		const resolvedPath = resolvePathFromCwd(cwd, path);
+		let stat;
+		try {
+			stat = await fs.stat(resolvedPath);
+		} catch {
+			stderr.push(`tree: ${path}: No such file or directory`);
+			exitCode = 1;
+			continue;
+		}
+		const rootEntry = await buildTreeEntry({
+			args,
+			depth: 0,
+			forceIncludeAll: false,
+			fs,
+			isDirectory: stat.isDirectory,
+			path: resolvedPath,
+			rootDisplayPath: path
+		});
+		if (!rootEntry) continue;
+		appendRenderedTree(stdout, rootEntry, args);
+		accumulateTotals(rootEntry, totals);
+	}
+	if (!args.noReport) appendReport(stdout, totals, args);
+	return {
+		exitCode,
+		stderr,
+		stdout
+	};
+}
+function createTreeResolvedArgs(args) {
+	return {
+		...args,
+		excludePatterns: createPatternSet(args.excludePatterns),
+		includePatterns: createPatternSet(args.includePatterns)
+	};
+}
+async function buildTreeEntry({ args, depth, forceIncludeAll, fs, isDirectory, path, rootDisplayPath }) {
+	const name = basename(path);
+	const isRoot = depth === 0;
+	const displayName = isRoot ? formatRootDisplayName(rootDisplayPath, path, args) : formatChildDisplayName(path, isDirectory, args);
+	if (!isRoot && shouldHide(name, args)) return null;
+	if (!isRoot && matchesPattern(args.excludePatterns, name, path)) return null;
+	if (!isRoot && args.dirsOnly && !isDirectory) return null;
+	if (!isDirectory) {
+		if (!forceIncludeAll && args.includePatterns.matchers.length > 0 && !matchesPattern(args.includePatterns, name, path)) return null;
+		return {
+			children: [],
+			displayName,
+			isDirectory,
+			path
+		};
+	}
+	const dirMatchesInclude = !isRoot && args.matchDirs && matchesPattern(args.includePatterns, name, path);
+	const childForceIncludeAll = forceIncludeAll || dirMatchesInclude;
+	const children = canDescend(depth, args) && isDirectory ? await buildChildEntries({
+		args,
+		depth,
+		forceIncludeAll: childForceIncludeAll,
+		fs,
+		path
+	}) : [];
+	if (!isRoot && args.prune && !dirMatchesInclude && children.length === 0) return null;
+	return {
+		children,
+		displayName,
+		isDirectory,
+		path
+	};
+}
+async function buildChildEntries({ args, depth, forceIncludeAll, fs, path }) {
+	const childPaths = await readSortedChildren(fs, path);
+	const entries = [];
+	for (const childPath of childPaths) {
+		const childDepth = depth + 1;
+		if (args.maxDepth !== null && childDepth > args.maxDepth) continue;
+		const childEntry = await buildTreeEntry({
+			args,
+			depth: childDepth,
+			forceIncludeAll,
+			fs,
+			isDirectory: (await fs.stat(childPath)).isDirectory,
+			path: childPath,
+			rootDisplayPath: childPath
+		});
+		if (childEntry) entries.push(childEntry);
+	}
+	return entries;
+}
+async function readSortedChildren(fs, path) {
+	const children = [];
+	for await (const childPath of fs.readdir(path)) children.push(childPath);
+	children.sort((left, right) => basename(left).localeCompare(basename(right)));
+	return children;
+}
+function appendRenderedTree(stdout, rootEntry, args) {
+	stdout.push(rootEntry.displayName);
+	const drawing = args.ascii ? LINE_DRAWING.ascii : LINE_DRAWING.utf8;
+	for (const [index, child] of rootEntry.children.entries()) appendRenderedEntry({
+		drawing,
+		entry: child,
+		isLast: index === rootEntry.children.length - 1,
+		prefix: "",
+		stdout
+	});
+}
+function appendRenderedEntry({ drawing, entry, isLast, prefix, stdout }) {
+	stdout.push(`${prefix}${isLast ? drawing.last : drawing.mid}${entry.displayName}`);
+	const childPrefix = `${prefix}${isLast ? drawing.blank : drawing.pipe}`;
+	for (const [index, child] of entry.children.entries()) appendRenderedEntry({
+		drawing,
+		entry: child,
+		isLast: index === entry.children.length - 1,
+		prefix: childPrefix,
+		stdout
+	});
+}
+function appendReport(stdout, totals, args) {
+	stdout.push("");
+	if (args.dirsOnly) {
+		stdout.push(`${totals.dirs} ${totals.dirs === 1 ? "directory" : "directories"}`);
+		return;
+	}
+	stdout.push(`${totals.dirs} ${totals.dirs === 1 ? "directory" : "directories"}, ${totals.files} ${totals.files === 1 ? "file" : "files"}`);
+}
+function accumulateTotals(entry, totals) {
+	if (entry.isDirectory) totals.dirs += 1;
+	else totals.files += 1;
+	for (const child of entry.children) accumulateTotals(child, totals);
+}
+function createPatternSet(patterns) {
+	return { matchers: patterns.flatMap(splitAlternatePatterns).map((pattern) => picomatch(pattern, {
+		bash: true,
+		dot: true
+	})) };
+}
+function splitAlternatePatterns(pattern) {
+	return pattern.split("|").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function matchesPattern(patterns, name, path) {
+	if (patterns.matchers.length === 0) return false;
+	const normalizedPath = normalizeAbsolutePath(path);
+	const relativePath = normalizedPath.startsWith(ROOT_DIRECTORY$2) ? normalizedPath.slice(1) : normalizedPath;
+	return patterns.matchers.some((matcher) => matcher(name) || matcher(relativePath));
+}
+function shouldHide(name, args) {
+	return !args.showAll && name.startsWith(".");
+}
+function canDescend(depth, args) {
+	return args.maxDepth === null || depth < args.maxDepth;
+}
+function formatRootDisplayName(displayPath, resolvedPath, args) {
+	const rootName = args.fullPath ? resolvedPath : displayPath;
+	if (args.classify) return withDirectorySlash(rootName);
+	return rootName;
+}
+function formatChildDisplayName(path, isDirectory, args) {
+	const displayName = args.fullPath ? path : basename(path);
+	if (args.classify && isDirectory) return withDirectorySlash(displayName);
+	return displayName;
+}
+function withDirectorySlash(path) {
+	if (path === ROOT_DIRECTORY$2 || path.endsWith(ROOT_DIRECTORY$2)) return path;
+	return `${path}/`;
+}
+function basename(path) {
+	const normalized = path.replace(TRAILING_SLASH_REGEX, "");
+	const slashIndex = normalized.lastIndexOf(ROOT_DIRECTORY$2);
+	if (slashIndex === -1) return normalized;
+	return normalized.slice(slashIndex + 1);
+}
+//#endregion
 //#region src/operator/wc/wc.ts
 const UTF8_DECODER = new TextDecoder();
-const UTF8_ENCODER = new TextEncoder();
 const DEFAULT_STDIN_DISPLAY_PATH = null;
 const DEFAULT_STDIO_BYTES = new Uint8Array();
 const STDIN_FILE_NAME = "-";
@@ -6410,7 +7341,7 @@ async function runWcCommand(options) {
 		stderr,
 		stdout: []
 	};
-	const readStdinBytes = createStdinReader(options.input, redirectedInputBytes);
+	const readStdinBytes = createStdinReader(options.input, redirectedInputBytes, options.stdin);
 	const fileOperands = await evaluateExpandedPathWords("wc", options.parsed.files, options.fs, options.context);
 	if (options.parsed.files0From && fileOperands.length > 0) return {
 		exitCode: 1,
@@ -6544,19 +7475,17 @@ async function readFileOrReport(fs, path, stderr) {
 		return null;
 	}
 }
-function createStdinReader(input, redirectedInputBytes) {
+function createStdinReader(input, redirectedInputBytes, stdin) {
 	let hasRead = false;
 	return async () => {
 		if (hasRead) return DEFAULT_STDIO_BYTES;
 		hasRead = true;
-		return redirectedInputBytes ?? readStreamBytes(input);
+		return redirectedInputBytes ?? readStreamBytes(input, stdin);
 	};
 }
-async function readStreamBytes(input) {
+async function readStreamBytes(input, stdin) {
 	if (!input) return DEFAULT_STDIO_BYTES;
-	const textParts = [];
-	for await (const record of input) textParts.push(formatRecord(record));
-	return UTF8_ENCODER.encode(textParts.join("\n"));
+	return await (stdin ?? createShellInput(input)).bytes({ trailingNewline: true });
 }
 function countBytes(bytes) {
 	const text = UTF8_DECODER.decode(bytes);
@@ -6743,7 +7672,7 @@ 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));
+	for await (const line of (options.stdin ?? createShellInput(options.input)).lines()) records.push(line);
 	return records.join("\n");
 }
 function buildBatches(input, args) {
@@ -6932,9 +7861,11 @@ const STREAM_COMMANDS = [
 	"pwd",
 	"read",
 	"set",
+	"sort",
 	"string",
 	"tail",
 	"test",
+	"tree",
 	"xargs",
 	"wc"
 ];
@@ -6986,10 +7917,17 @@ async function executeEffectStep$1({ step, fs, context }) {
 	});
 }
 function createBuiltinRuntime(fs, context, input) {
+	const stdin = createShellInput(input);
 	return {
 		fs,
 		context,
-		input
+		input,
+		io: {
+			stderr: context.stderr,
+			stdin,
+			stdout: new BufferedShellOutput()
+		},
+		stdin
 	};
 }
 function formatLongListing(path, stat) {
@@ -7055,7 +7993,7 @@ CommandRegistry.register("cat", {
 				context.status = 0;
 				return;
 			}
-			if (input) yield* cat(fs, options)(input);
+			if (input) yield* cat(fs, options)(toFormattedLineStream(input));
 			context.status = 0;
 		})();
 	}
@@ -7070,7 +8008,8 @@ CommandRegistry.register("grep", {
 				input,
 				parsed: step.args,
 				redirections: step.redirections,
-				resolvedOutputRedirectPath
+				resolvedOutputRedirectPath,
+				stdin: createShellInput(input)
 			});
 			context.status = result.exitCode;
 			context.stderr.appendLines(result.stderr);
@@ -7096,7 +8035,8 @@ CommandRegistry.register("xargs", {
 				fs,
 				input,
 				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
-				parsed: step.args
+				parsed: step.args,
+				stdin: createShellInput(input)
 			});
 			context.status = result.exitCode;
 			context.stderr.appendLines(result.stderr);
@@ -7116,7 +8056,8 @@ CommandRegistry.register("wc", {
 				fs,
 				input,
 				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
-				parsed: step.args
+				parsed: step.args,
+				stdin: createShellInput(input)
 			});
 			context.status = result.exitCode;
 			context.stderr.appendLines(result.stderr);
@@ -7127,6 +8068,49 @@ CommandRegistry.register("wc", {
 		})();
 	}
 });
+CommandRegistry.register("sort", {
+	kind: "stream",
+	handler: ({ step, fs, input, context }) => {
+		return (async function* () {
+			const result = await runSortCommand({
+				context,
+				fs,
+				input,
+				inputPath: await resolveRedirectPath(step.cmd, step.redirections, "input", fs, context),
+				parsed: step.args,
+				stdin: createShellInput(input)
+			});
+			context.status = result.exitCode;
+			context.stderr.appendLines(result.stderr);
+			for (const text of result.stdout) yield {
+				kind: "line",
+				text
+			};
+		})();
+	}
+});
+CommandRegistry.register("tree", {
+	kind: "stream",
+	handler: ({ step, fs, context }) => {
+		return (async function* () {
+			const paths = resolvePathsFromCwd(context.cwd, await evaluateExpandedPathWords("tree", step.args.paths, fs, context));
+			const includePatterns = await evaluateExpandedWords(step.args.includePatterns, fs, context);
+			const excludePatterns = await evaluateExpandedWords(step.args.excludePatterns, fs, context);
+			const result = await runTreeCommand(fs, context.cwd, createTreeResolvedArgs({
+				...step.args,
+				excludePatterns,
+				includePatterns,
+				paths
+			}));
+			context.status = result.exitCode;
+			context.stderr.appendLines(result.stderr);
+			for (const text of result.stdout) yield {
+				kind: "line",
+				text
+			};
+		})();
+	}
+});
 CommandRegistry.register("head", {
 	kind: "stream",
 	handler: ({ step, fs, input, context }) => {
@@ -7511,11 +8495,13 @@ function getTargetFd(redirection) {
 }
 async function resolveFileDestination(command, redirection, fs, context) {
 	const targetPath = await evaluateExpandedSinglePath(command, "redirection target must expand to exactly 1 path", redirection.target, fs, context);
+	const resolvedPath = resolvePathFromCwd(context.cwd, targetPath);
+	if (isNullDevicePath(resolvedPath)) return { kind: "nullDevice" };
 	return {
 		kind: "file",
 		append: redirection.append ?? false,
 		noclobber: redirection.noclobber ?? false,
-		path: resolvePathFromCwd(context.cwd, targetPath)
+		path: resolvedPath
 	};
 }
 function destinationForFd(routing, fd, _isLastStep) {
@@ -7675,6 +8661,7 @@ async function routeStdout(stdoutRecords, stdoutText, destination, hasNextStep,
 			});
 			return;
 		case "closed": return;
+		case "nullDevice": return;
 		default: {
 			const _exhaustive = destination;
 			throw new Error(`Unknown stdout destination: ${_exhaustive}`);
@@ -7707,6 +8694,7 @@ async function routeStderr(stderrLines, stderrText, destination, hasNextStep, pi
 			});
 			return;
 		case "closed": return;
+		case "nullDevice": return;
 		default: {
 			const _exhaustive = destination;
 			throw new Error(`Unknown stderr destination: ${_exhaustive}`);
@@ -7716,4 +8704,4 @@ async function routeStderr(stderrLines, stderrText, destination, hasNextStep, pi
 //#endregion
 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-DV1hpsh-.mjs.map
+//# sourceMappingURL=execute-BinccNiS.mjs.map