shfs 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import { map, pipe } from "remeda";
-
 //#region ../compiler/dist/index.mjs
 /**
 * Create a literal ExpandedWord.
@@ -62,9 +60,9 @@ function extractPathsFromExpandedWords(words) {
 		}
 	});
 }
-const NEGATIVE_NUMBER_REGEX$2 = /^(?:-\d+(?:\.\d+)?|-\.\d+)$/;
+const NEGATIVE_NUMBER_REGEX = /^(?:-\d+(?:\.\d+)?|-\.\d+)$/;
 function isNegativeNumberToken(token) {
-	return NEGATIVE_NUMBER_REGEX$2.test(token);
+	return NEGATIVE_NUMBER_REGEX.test(token);
 }
 function startsWithLongPrefix(token) {
 	return token.length >= 2 && token[0] === "-" && token[1] === "-";
@@ -81,68 +79,203 @@ function splitNameBeforeEquals(token) {
 }
 const SHORT_NAME_REGEX = /^[A-Za-z]$/;
 const LONG_NAME_REGEX = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
-function parseArgs(args, flagDefs) {
+const UNKNOWN_FLAG_PREFIX$2 = "Unknown flag: ";
+function createArgParser(flagDefs) {
 	const index = buildFlagIndex(flagDefs);
-	const flags$1 = Object.create(null);
+	return (args, options) => {
+		return parseArgsWithIndex(args, index, options);
+	};
+}
+function createWordParser(flagDefs, wordToString) {
+	const parseWithIndex = createArgParser(flagDefs);
+	return (words, options) => {
+		const parsed = parseWithIndex(words.map(wordToString), options);
+		const positionalWords = parsed.positionalIndices.flatMap((index) => {
+			const word = words[index];
+			return word === void 0 ? [] : [word];
+		});
+		return {
+			...parsed,
+			positionalWords
+		};
+	};
+}
+function parseArgsWithIndex(args, index, options) {
+	const normalizedOptions = normalizeOptions$1(options);
+	const negativeNumberValueEntry = getNegativeNumberValueEntry(normalizedOptions, index);
+	let consumedValueIndices = Object.create(null);
+	let flags = Object.create(null);
 	const positional = [];
+	const positionalIndices = [];
 	let endOfFlags = false;
 	for (let i = 0; i < args.length; i++) {
 		const token = args[i];
 		if (token === void 0) continue;
-		if (endOfFlags) {
-			positional.push(token);
-			continue;
-		}
-		if (token === "--") {
-			endOfFlags = true;
-			continue;
-		}
-		if (token === "-") {
-			positional.push(token);
-			continue;
-		}
-		if (isNegativeNumberToken(token)) {
-			positional.push(token);
-			continue;
-		}
-		if (startsWithLongPrefix(token)) {
-			i = parseLongToken(args, i, token, index, flags$1);
-			continue;
-		}
-		if (startsWithShortPrefix(token)) {
-			i = parseShortToken(args, i, token, index, flags$1);
-			continue;
+		const result = processToken({
+			args,
+			consumedValueIndices,
+			endOfFlags,
+			flags,
+			flagsIndex: index,
+			index: i,
+			negativeNumberValueEntry,
+			positional,
+			positionalIndices,
+			token,
+			unknownFlagPolicy: normalizedOptions.unknownFlagPolicy
+		});
+		consumedValueIndices = result.consumedValueIndices;
+		endOfFlags = result.endOfFlags;
+		flags = result.flags;
+		i = result.newIndex;
+	}
+	return {
+		consumedValueIndices,
+		flags,
+		positional,
+		positionalIndices
+	};
+}
+function processToken(params) {
+	const { args, consumedValueIndices, endOfFlags, flags, flagsIndex, index, negativeNumberValueEntry, positional, positionalIndices, token, unknownFlagPolicy } = params;
+	if (endOfFlags || token === "-") {
+		appendPositional(positional, positionalIndices, token, index);
+		return {
+			consumedValueIndices,
+			endOfFlags,
+			flags,
+			newIndex: index
+		};
+	}
+	if (token === "--") return {
+		consumedValueIndices,
+		endOfFlags: true,
+		flags,
+		newIndex: index
+	};
+	if (isNegativeNumberToken(token)) {
+		if (!negativeNumberValueEntry) {
+			appendPositional(positional, positionalIndices, token, index);
+			return {
+				consumedValueIndices,
+				endOfFlags,
+				flags,
+				newIndex: index
+			};
 		}
-		positional.push(token);
+		setValue(flags, consumedValueIndices, negativeNumberValueEntry, token.slice(1), index);
+		return {
+			consumedValueIndices,
+			endOfFlags,
+			flags,
+			newIndex: index
+		};
+	}
+	const parser = getTokenParser(token);
+	if (!parser) {
+		appendPositional(positional, positionalIndices, token, index);
+		return {
+			consumedValueIndices,
+			endOfFlags,
+			flags,
+			newIndex: index
+		};
 	}
+	const parsed = parsePotentialFlagToken(args, index, token, flagsIndex, flags, consumedValueIndices, unknownFlagPolicy, parser);
+	if (!parsed) {
+		handleUnrecognizedToken(unknownFlagPolicy, positional, positionalIndices, token, index);
+		return {
+			consumedValueIndices,
+			endOfFlags,
+			flags,
+			newIndex: index
+		};
+	}
+	return {
+		consumedValueIndices: parsed.consumedValueIndices,
+		endOfFlags,
+		flags: parsed.flags,
+		newIndex: parsed.newIndex
+	};
+}
+function getTokenParser(token) {
+	if (startsWithLongPrefix(token)) return parseLongToken;
+	if (startsWithShortPrefix(token)) return parseShortToken;
+}
+function normalizeOptions$1(options) {
 	return {
-		flags: flags$1,
-		positional
+		negativeNumberPolicy: options?.negativeNumberPolicy ?? "positional",
+		negativeNumberFlag: options?.negativeNumberFlag,
+		unknownFlagPolicy: options?.unknownFlagPolicy ?? "error"
+	};
+}
+function getNegativeNumberValueEntry(options, index) {
+	if (options.negativeNumberPolicy === "positional") return;
+	if (!options.negativeNumberFlag) throw new Error("negativeNumberFlag is required when negativeNumberPolicy is \"value\".");
+	const entry = index.canonical.get(options.negativeNumberFlag);
+	if (!entry) throw new Error(`Unknown negativeNumberFlag: "${options.negativeNumberFlag}".`);
+	if (!entry.def.takesValue) throw new Error(`negativeNumberFlag "${options.negativeNumberFlag}" must reference a flag that takes a value.`);
+	return entry;
+}
+function appendPositional(positional, positionalIndices, token, index) {
+	positional.push(token);
+	positionalIndices.push(index);
+}
+function parsePotentialFlagToken(args, index, token, flagsIndex, currentFlags, currentConsumedValueIndices, unknownFlagPolicy, parser) {
+	if (unknownFlagPolicy === "error") return {
+		consumedValueIndices: currentConsumedValueIndices,
+		flags: currentFlags,
+		newIndex: parser(args, index, token, flagsIndex, currentFlags, currentConsumedValueIndices)
 	};
+	const candidateFlags = cloneFlags(currentFlags);
+	const candidateConsumedValueIndices = cloneConsumedValueIndices(currentConsumedValueIndices);
+	try {
+		return {
+			consumedValueIndices: candidateConsumedValueIndices,
+			flags: candidateFlags,
+			newIndex: parser(args, index, token, flagsIndex, candidateFlags, candidateConsumedValueIndices)
+		};
+	} catch (error) {
+		if (isUnknownFlagError(error)) return null;
+		throw error;
+	}
+}
+function handleUnrecognizedToken(policy, positional, positionalIndices, token, index) {
+	if (policy === "positional") appendPositional(positional, positionalIndices, token, index);
+}
+function cloneFlags(source) {
+	const cloned = Object.create(null);
+	for (const [key, value] of Object.entries(source)) cloned[key] = Array.isArray(value) ? [...value] : value;
+	return cloned;
+}
+function cloneConsumedValueIndices(source) {
+	const cloned = Object.create(null);
+	for (const [key, value] of Object.entries(source)) cloned[key] = [...value];
+	return cloned;
 }
 function buildFlagIndex(flagDefs) {
+	const canonical = /* @__PURE__ */ new Map();
 	const short = /* @__PURE__ */ new Map();
 	const long = /* @__PURE__ */ new Map();
-	const add = (map$1, token, entry) => {
-		const prev = map$1.get(token);
+	const add = (map, token, entry) => {
+		const prev = map.get(token);
 		if (!prev) {
-			map$1.set(token, entry);
+			map.set(token, entry);
 			return;
 		}
 		throw new Error(`Duplicate flag token "${token}" for "${entry.canonical}" and "${prev.canonical}"`);
 	};
-	for (const [canonical, def] of Object.entries(flagDefs)) {
-		if (!SHORT_NAME_REGEX.test(def.short)) throw new Error(`Invalid short flag for "${canonical}": "${def.short}". Expected a single letter [A-Za-z].`);
-		add(short, `-${def.short}`, {
-			canonical,
+	for (const [canonicalName, def] of Object.entries(flagDefs)) {
+		if (!SHORT_NAME_REGEX.test(def.short)) throw new Error(`Invalid short flag for "${canonicalName}": "${def.short}". Expected a single letter [A-Za-z].`);
+		const entry = {
+			canonical: canonicalName,
 			def
-		});
+		};
+		canonical.set(canonicalName, entry);
+		add(short, `-${def.short}`, entry);
 		if (def.long) {
-			if (!LONG_NAME_REGEX.test(def.long)) throw new Error(`Invalid long flag for "${canonical}": "${def.long}". Expected [A-Za-z0-9][A-Za-z0-9-]*.`);
-			add(long, `--${def.long}`, {
-				canonical,
-				def
-			});
+			if (!LONG_NAME_REGEX.test(def.long)) throw new Error(`Invalid long flag for "${canonicalName}": "${def.long}". Expected [A-Za-z0-9][A-Za-z0-9-]*.`);
+			add(long, `--${def.long}`, entry);
 		}
 	}
 	const isFlagToken = (token) => {
@@ -166,16 +299,17 @@ function buildFlagIndex(flagDefs) {
 		return false;
 	};
 	return {
+		canonical,
 		short,
 		long,
 		isFlagToken
 	};
 }
-function parseLongToken(args, index, token, flagsIndex, out) {
+function parseLongToken(args, index, token, flagsIndex, out, consumedValueIndices) {
 	if (startsWithNoLongPrefix(token) && !token.includes("=")) {
 		const base = `--${token.slice(5)}`;
 		const entry$1 = flagsIndex.long.get(base);
-		if (!entry$1) throw new Error(`Unknown flag: ${token}`);
+		if (!entry$1) throwUnknownFlag(token);
 		if (entry$1.def.takesValue) throw new Error(`Flag ${base} takes a value; "${token}" is invalid.`);
 		setBoolean(out, entry$1.canonical, false);
 		return index;
@@ -185,69 +319,91 @@ function parseLongToken(args, index, token, flagsIndex, out) {
 		const name = token.slice(0, eq);
 		const value$1 = token.slice(eq + 1);
 		const entry$1 = flagsIndex.long.get(name);
-		if (!entry$1) throw new Error(`Unknown flag: ${name}`);
+		if (!entry$1) throwUnknownFlag(name);
 		if (!entry$1.def.takesValue) throw new Error(`Flag ${name} does not take a value.`);
-		setValue(out, entry$1, value$1);
+		setValue(out, consumedValueIndices, entry$1, value$1, index);
 		return index;
 	}
 	const entry = flagsIndex.long.get(token);
-	if (!entry) throw new Error(`Unknown flag: ${token}`);
+	if (!entry) throwUnknownFlag(token);
 	if (!entry.def.takesValue) {
 		setBoolean(out, entry.canonical, true);
 		return index;
 	}
-	const { value, newIndex } = consumeValue(args, index, token, flagsIndex);
-	setValue(out, entry, value);
+	const { newIndex, value, valueIndex } = consumeValue(args, index, token, flagsIndex);
+	setValue(out, consumedValueIndices, entry, value, valueIndex);
 	return newIndex;
 }
-function parseShortToken(args, index, token, flagsIndex, out) {
-	if (token.length >= 3 && token[2] === "=") {
-		const name = token.slice(0, 2);
-		const value = token.slice(3);
-		const entry = flagsIndex.short.get(name);
-		if (!entry) throw new Error(`Unknown flag: ${name}`);
-		if (!entry.def.takesValue) throw new Error(`Flag ${name} does not take a value.`);
-		setValue(out, entry, value);
+function parseShortToken(args, index, token, flagsIndex, out, consumedValueIndices) {
+	if (token.length >= 3 && token[2] === "=") return parseShortEqualsToken(index, token, flagsIndex, out, consumedValueIndices);
+	if (token.length === 2) return parseSingleShortToken(args, index, token, flagsIndex, out, consumedValueIndices);
+	return parseShortClusterToken(args, index, token, flagsIndex, out, consumedValueIndices);
+}
+function parseShortEqualsToken(index, token, flagsIndex, out, consumedValueIndices) {
+	const name = token.slice(0, 2);
+	const value = token.slice(3);
+	const entry = getRequiredShortEntry(flagsIndex, name);
+	assertTakesValue(entry, name);
+	setValue(out, consumedValueIndices, entry, value, index);
+	return index;
+}
+function parseSingleShortToken(args, index, token, flagsIndex, out, consumedValueIndices) {
+	const entry = getRequiredShortEntry(flagsIndex, token);
+	if (!entry.def.takesValue) {
+		setBoolean(out, entry.canonical, true);
 		return index;
 	}
-	if (token.length === 2) {
-		const entry = flagsIndex.short.get(token);
-		if (!entry) throw new Error(`Unknown flag: ${token}`);
-		if (!entry.def.takesValue) {
-			setBoolean(out, entry.canonical, true);
-			return index;
-		}
-		const { value, newIndex } = consumeValue(args, index, token, flagsIndex);
-		setValue(out, entry, value);
-		return newIndex;
-	}
+	const { newIndex, value, valueIndex } = consumeValue(args, index, token, flagsIndex);
+	setValue(out, consumedValueIndices, entry, value, valueIndex);
+	return newIndex;
+}
+function parseShortClusterToken(args, index, token, flagsIndex, out, consumedValueIndices) {
 	for (let j = 1; j < token.length; j++) {
 		const ch = token[j] ?? "";
-		if (!SHORT_NAME_REGEX.test(ch)) throw new Error(`Invalid short flag character "${ch}" in "${token}". Short flags must be letters.`);
+		assertValidShortCharacter(token, ch);
 		const name = `-${ch}`;
-		const entry = flagsIndex.short.get(name);
-		if (!entry) throw new Error(`Unknown flag: ${name}`);
+		const entry = getRequiredShortEntry(flagsIndex, name);
 		if (!entry.def.takesValue) {
 			setBoolean(out, entry.canonical, true);
 			continue;
 		}
-		const rest = token.slice(j + 1);
-		if (rest.startsWith("=")) {
-			setValue(out, entry, rest.slice(1));
-			return index;
-		}
-		if (rest.length === 0) {
-			const { value, newIndex } = consumeValue(args, index, name, flagsIndex);
-			setValue(out, entry, value);
-			return newIndex;
-		}
-		const first = rest[0] ?? "";
-		if (SHORT_NAME_REGEX.test(first) && flagsIndex.short.has(`-${first}`)) throw new Error(`Ambiguous short flag cluster "${token}": ${name} takes a value, but "${rest}" begins with "-${first}" which is also a flag. Use "${name}=${rest}" or pass the value as a separate argument.`);
-		setValue(out, entry, rest);
+		return parseValueFlagInShortCluster(args, index, token, j, name, entry, flagsIndex, out, consumedValueIndices);
+	}
+	return index;
+}
+function parseValueFlagInShortCluster(args, index, token, flagPosition, name, entry, flagsIndex, out, consumedValueIndices) {
+	const rest = token.slice(flagPosition + 1);
+	if (rest.startsWith("=")) {
+		setValue(out, consumedValueIndices, entry, rest.slice(1), index);
 		return index;
 	}
+	if (rest.length === 0) {
+		const { newIndex, value, valueIndex } = consumeValue(args, index, name, flagsIndex);
+		setValue(out, consumedValueIndices, entry, value, valueIndex);
+		return newIndex;
+	}
+	assertNotAmbiguousShortValue(token, name, rest, flagsIndex);
+	setValue(out, consumedValueIndices, entry, rest, index);
 	return index;
 }
+function getRequiredShortEntry(flagsIndex, name) {
+	const entry = flagsIndex.short.get(name);
+	if (!entry) throwUnknownFlag(name);
+	return entry;
+}
+function assertValidShortCharacter(token, ch) {
+	if (SHORT_NAME_REGEX.test(ch)) return;
+	throw new Error(`Invalid short flag character "${ch}" in "${token}". Short flags must be letters.`);
+}
+function assertTakesValue(entry, token) {
+	if (entry.def.takesValue) return;
+	throw new Error(`Flag ${token} does not take a value.`);
+}
+function assertNotAmbiguousShortValue(token, name, rest, flagsIndex) {
+	const first = rest[0] ?? "";
+	if (!(SHORT_NAME_REGEX.test(first) && flagsIndex.short.has(`-${first}`))) return;
+	throw new Error(`Ambiguous short flag cluster "${token}": ${name} takes a value, but "${rest}" begins with "-${first}" which is also a flag. Use "${name}=${rest}" or pass the value as a separate argument.`);
+}
 function consumeValue(args, index, flagToken, flagsIndex) {
 	const nextIndex = index + 1;
 	if (nextIndex >= args.length) throw new Error(`Flag ${flagToken} requires a value.`);
@@ -257,34 +413,53 @@ function consumeValue(args, index, flagToken, flagsIndex) {
 	if (flagsIndex.isFlagToken(next)) throw new Error(`Flag ${flagToken} requires a value (got "${next}").`);
 	return {
 		value: next,
-		newIndex: nextIndex
+		newIndex: nextIndex,
+		valueIndex: nextIndex
 	};
 }
 function setBoolean(out, canonical, value) {
 	out[canonical] = value;
 }
-function setValue(out, entry, value) {
+function setValue(out, consumedValueIndices, entry, value, valueIndex) {
 	const { canonical, def } = entry;
 	const existing = out[canonical];
 	if (existing === void 0) {
 		out[canonical] = value;
+		recordConsumedValueIndex(consumedValueIndices, canonical, valueIndex);
 		return;
 	}
 	if (!def.multiple) throw new Error(`Duplicate flag "${canonical}". If it is intended to repeat, set { multiple: true } in its definition.`);
 	if (Array.isArray(existing)) {
 		existing.push(value);
+		recordConsumedValueIndex(consumedValueIndices, canonical, valueIndex);
 		return;
 	}
 	if (typeof existing === "string") {
 		out[canonical] = [existing, value];
+		recordConsumedValueIndex(consumedValueIndices, canonical, valueIndex);
 		return;
 	}
 	throw new Error(`Invalid state for flag "${canonical}".`);
 }
+function recordConsumedValueIndex(consumedValueIndices, canonical, valueIndex) {
+	const existing = consumedValueIndices[canonical];
+	if (!existing) {
+		consumedValueIndices[canonical] = [valueIndex];
+		return;
+	}
+	existing.push(valueIndex);
+}
+function throwUnknownFlag(token) {
+	throw new Error(`${UNKNOWN_FLAG_PREFIX$2}${token}`);
+}
+function isUnknownFlagError(error) {
+	if (!(error instanceof Error)) return false;
+	return error.message.startsWith(UNKNOWN_FLAG_PREFIX$2);
+}
 /**
 * cat command handler for the AST-based compiler.
 */
-const flags = {
+const parseCatArgs = createArgParser({
 	number: {
 		short: "n",
 		takesValue: false
@@ -313,14 +488,17 @@ const flags = {
 		short: "s",
 		takesValue: false
 	}
-};
+});
 /**
 * Compile a cat command from SimpleCommandIR to StepIR.
 */
 function compileCat(cmd$1) {
-	const parsed = parseArgs(cmd$1.args.map(expandedWordToString), flags);
+	const parsed = parseCatArgs(cmd$1.args.map(expandedWordToString));
 	const fileArgs = [];
-	for (const arg of cmd$1.args) if (!expandedWordToString(arg).startsWith("-")) fileArgs.push(arg);
+	for (const positionalIndex of parsed.positionalIndices) {
+		const arg = cmd$1.args[positionalIndex];
+		if (arg !== void 0) fileArgs.push(arg);
+	}
 	const hasInputRedirection = cmd$1.redirections.some((redirection) => redirection.kind === "input");
 	if (fileArgs.length === 0 && !hasInputRedirection) throw new Error("cat requires at least one file");
 	return {
@@ -338,19 +516,45 @@ function compileCat(cmd$1) {
 	};
 }
 /**
+* cd command handler for the AST-based compiler.
+*/
+const ROOT_DIRECTORY$3 = "/";
+/**
+* Compile a cd command from SimpleCommandIR to StepIR.
+*/
+function compileCd(cmd$1) {
+	if (cmd$1.args.length > 1) throw new Error("cd accepts at most one path");
+	return {
+		cmd: "cd",
+		args: { path: cmd$1.args[0] ?? literal(ROOT_DIRECTORY$3) }
+	};
+}
+/**
 * cp command handler for the AST-based compiler.
 */
+const parseCpArgs = createWordParser({
+	force: {
+		short: "f",
+		takesValue: false
+	},
+	interactive: {
+		short: "i",
+		takesValue: false
+	},
+	recursive: {
+		short: "r",
+		takesValue: false
+	}
+}, expandedWordToString);
 /**
 * Compile a cp command from SimpleCommandIR to StepIR.
 */
 function compileCp(cmd$1) {
-	let recursive = false;
-	const filteredArgs = [];
-	for (const arg of cmd$1.args) {
-		const argStr = expandedWordToString(arg);
-		if (argStr === "-r") recursive = true;
-		else if (argStr !== "-f" && argStr !== "-i") filteredArgs.push(arg);
-	}
+	const parsed = parseCpArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const recursive = parsed.flags.recursive === true;
+	const force = parsed.flags.force === true;
+	const interactive = parsed.flags.interactive === true;
+	const filteredArgs = parsed.positionalWords;
 	if (filteredArgs.length < 2) throw new Error("cp requires source and destination");
 	const dest = filteredArgs.pop();
 	if (!dest) throw new Error("cp requires source and destination");
@@ -358,6 +562,8 @@ function compileCp(cmd$1) {
 		cmd: "cp",
 		args: {
 			dest,
+			force,
+			interactive,
 			recursive,
 			srcs: filteredArgs
 		}
@@ -366,67 +572,102 @@ function compileCp(cmd$1) {
 /**
 * head command handler for the AST-based compiler.
 */
-const NEGATIVE_NUMBER_REGEX$1 = /^-\d+$/;
+const DEFAULT_LINE_COUNT$1 = 10;
+const parseHeadArgs = createWordParser({ lines: {
+	multiple: true,
+	short: "n",
+	takesValue: true
+} }, expandedWordToString);
+const MISSING_N_VALUE_PREFIX$1 = "Flag -n requires a value";
+const UNKNOWN_FLAG_PREFIX$1 = "Unknown flag:";
 /**
 * Compile a head command from SimpleCommandIR to StepIR.
 */
 function compileHead(cmd$1) {
-	let n = 10;
-	const files$1 = [];
-	let skipNext = false;
-	for (let i = 0; i < cmd$1.args.length; i++) {
-		if (skipNext) {
-			skipNext = false;
-			continue;
-		}
-		const arg = cmd$1.args[i];
-		if (!arg) continue;
-		const argStr = expandedWordToString(arg);
-		if (argStr === "-n") {
-			const numArg = cmd$1.args[i + 1];
-			if (!numArg) throw new Error("head -n requires a number");
-			n = Number(expandedWordToString(numArg));
-			if (!Number.isFinite(n)) throw new Error("Invalid head count");
-			skipNext = true;
-		} else if (argStr.startsWith("-") && NEGATIVE_NUMBER_REGEX$1.test(argStr)) n = Number(argStr.slice(1));
-		else if (argStr.startsWith("-")) throw new Error("Unknown head option");
-		else files$1.push(arg);
-	}
+	const parsed = parseHeadArgsOrThrow(cmd$1.args);
+	const n = parseHeadCount(parsed.flags.lines);
 	return {
 		cmd: "head",
 		args: {
-			files: files$1,
+			files: parsed.positionalWords,
 			n
 		}
 	};
 }
+function parseHeadCount(value) {
+	const lastValue = getLastValueToken$1(value);
+	if (lastValue === void 0) return DEFAULT_LINE_COUNT$1;
+	const parsedValue = Number(lastValue);
+	if (!Number.isFinite(parsedValue)) throw new Error("Invalid head count");
+	return parsedValue;
+}
+function getLastValueToken$1(value) {
+	if (value === void 0) return;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.at(-1);
+	throw new Error("Invalid head count");
+}
+function parseHeadArgsOrThrow(args) {
+	try {
+		return parseHeadArgs(args, {
+			negativeNumberFlag: "lines",
+			negativeNumberPolicy: "value"
+		});
+	} catch (error) {
+		if (!(error instanceof Error)) throw new Error("Unknown head option");
+		if (error.message.startsWith(MISSING_N_VALUE_PREFIX$1)) throw new Error("head -n requires a number");
+		if (error.message.startsWith(UNKNOWN_FLAG_PREFIX$1)) throw new Error("Unknown head option");
+		throw error;
+	}
+}
 /**
 * ls command handler for the AST-based compiler.
 */
+const parseLsArgs = createWordParser({
+	longFormat: {
+		short: "l",
+		takesValue: false
+	},
+	showAll: {
+		short: "a",
+		takesValue: false
+	}
+}, expandedWordToString);
 /**
 * Compile an ls command from SimpleCommandIR to StepIR.
 */
 function compileLs(cmd$1) {
+	const parsed = parseLsArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const paths = parsed.positionalWords.length === 0 ? [literal(".")] : parsed.positionalWords;
 	return {
 		cmd: "ls",
-		args: { paths: cmd$1.args.length === 0 ? [literal(".")] : cmd$1.args }
+		args: {
+			longFormat: parsed.flags.longFormat === true,
+			paths,
+			showAll: parsed.flags.showAll === true
+		}
 	};
 }
 /**
 * mkdir command handler for the AST-based compiler.
 */
+const parseMkdirArgs = createWordParser({ parents: {
+	short: "p",
+	takesValue: false
+} }, expandedWordToString);
 /**
 * Compile a mkdir command from SimpleCommandIR to StepIR.
 */
 function compileMkdir(cmd$1) {
-	let recursive = false;
-	const paths = [];
-	for (const arg of cmd$1.args) if (expandedWordToString(arg) === "-p") recursive = true;
-	else paths.push(arg);
+	const parsed = parseMkdirArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const parents = parsed.flags.parents === true;
+	const recursive = parents;
+	const paths = parsed.positionalWords;
 	if (paths.length === 0) throw new Error("mkdir requires at least one path");
 	return {
 		cmd: "mkdir",
 		args: {
+			parents,
 			paths,
 			recursive
 		}
@@ -435,15 +676,24 @@ function compileMkdir(cmd$1) {
 /**
 * mv command handler for the AST-based compiler.
 */
+const parseMvArgs = createWordParser({
+	force: {
+		short: "f",
+		takesValue: false
+	},
+	interactive: {
+		short: "i",
+		takesValue: false
+	}
+}, expandedWordToString);
 /**
 * Compile a mv command from SimpleCommandIR to StepIR.
 */
 function compileMv(cmd$1) {
-	const filteredArgs = [];
-	for (const arg of cmd$1.args) {
-		const argStr = expandedWordToString(arg);
-		if (argStr !== "-f" && argStr !== "-i") filteredArgs.push(arg);
-	}
+	const parsed = parseMvArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const force = parsed.flags.force === true;
+	const interactive = parsed.flags.interactive === true;
+	const filteredArgs = parsed.positionalWords;
 	if (filteredArgs.length < 2) throw new Error("mv requires source and destination");
 	const dest = filteredArgs.pop();
 	if (!dest) throw new Error("mv requires source and destination");
@@ -451,28 +701,54 @@ function compileMv(cmd$1) {
 		cmd: "mv",
 		args: {
 			dest,
+			force,
+			interactive,
 			srcs: filteredArgs
 		}
 	};
 }
 /**
+* Compile a pwd command from SimpleCommandIR to StepIR.
+*/
+function compilePwd(cmd$1) {
+	if (cmd$1.args.length > 0) throw new Error("pwd does not take any arguments");
+	return {
+		cmd: "pwd",
+		args: {}
+	};
+}
+/**
 * rm command handler for the AST-based compiler.
 */
+const parseRmArgs = createWordParser({
+	force: {
+		short: "f",
+		takesValue: false
+	},
+	interactive: {
+		short: "i",
+		takesValue: false
+	},
+	recursive: {
+		short: "r",
+		takesValue: false
+	}
+}, expandedWordToString);
 /**
 * Compile a rm command from SimpleCommandIR to StepIR.
 */
 function compileRm(cmd$1) {
-	let recursive = false;
-	const paths = [];
-	for (const arg of cmd$1.args) {
-		const argStr = expandedWordToString(arg);
-		if (argStr === "-r") recursive = true;
-		else if (argStr !== "-f" && argStr !== "-i") paths.push(arg);
-	}
+	const parsed = parseRmArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const recursive = parsed.flags.recursive === true;
+	const force = parsed.flags.force === true;
+	const interactive = parsed.flags.interactive === true;
+	const paths = parsed.positionalWords;
 	if (paths.length === 0) throw new Error("rm requires at least one path");
 	return {
 		cmd: "rm",
 		args: {
+			force,
+			interactive,
 			paths,
 			recursive
 		}
@@ -481,64 +757,101 @@ function compileRm(cmd$1) {
 /**
 * tail command handler for the AST-based compiler.
 */
-const NEGATIVE_NUMBER_REGEX = /^-\d+$/;
+const DEFAULT_LINE_COUNT = 10;
+const parseTailArgs = createWordParser({ lines: {
+	multiple: true,
+	short: "n",
+	takesValue: true
+} }, expandedWordToString);
+const MISSING_N_VALUE_PREFIX = "Flag -n requires a value";
+const UNKNOWN_FLAG_PREFIX = "Unknown flag:";
 /**
 * Compile a tail command from SimpleCommandIR to StepIR.
 */
 function compileTail(cmd$1) {
-	let n = 10;
-	const files$1 = [];
-	let skipNext = false;
-	for (let i = 0; i < cmd$1.args.length; i++) {
-		if (skipNext) {
-			skipNext = false;
-			continue;
-		}
-		const arg = cmd$1.args[i];
-		if (!arg) continue;
-		const argStr = expandedWordToString(arg);
-		if (argStr === "-n") {
-			const numArg = cmd$1.args[i + 1];
-			if (!numArg) throw new Error("tail -n requires a number");
-			n = Number(expandedWordToString(numArg));
-			if (!Number.isFinite(n)) throw new Error("Invalid tail count");
-			skipNext = true;
-		} else if (argStr.startsWith("-") && NEGATIVE_NUMBER_REGEX.test(argStr)) n = Number(argStr.slice(1));
-		else if (argStr.startsWith("-")) throw new Error("Unknown tail option");
-		else files$1.push(arg);
-	}
+	const parsed = parseTailArgsOrThrow(cmd$1.args);
+	const n = parseTailCount(parsed.flags.lines);
 	return {
 		cmd: "tail",
 		args: {
-			files: files$1,
+			files: parsed.positionalWords,
 			n
 		}
 	};
 }
+function parseTailCount(value) {
+	const lastValue = getLastValueToken(value);
+	if (lastValue === void 0) return DEFAULT_LINE_COUNT;
+	const parsedValue = Number(lastValue);
+	if (!Number.isFinite(parsedValue)) throw new Error("Invalid tail count");
+	return parsedValue;
+}
+function getLastValueToken(value) {
+	if (value === void 0) return;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.at(-1);
+	throw new Error("Invalid tail count");
+}
+function parseTailArgsOrThrow(args) {
+	try {
+		return parseTailArgs(args, {
+			negativeNumberFlag: "lines",
+			negativeNumberPolicy: "value"
+		});
+	} catch (error) {
+		throw normalizeTailParseError(error);
+	}
+}
+function normalizeTailParseError(error) {
+	if (!(error instanceof Error)) return /* @__PURE__ */ new Error("Unknown tail option");
+	if (error.message.startsWith(MISSING_N_VALUE_PREFIX)) return /* @__PURE__ */ new Error("tail -n requires a number");
+	if (error.message.startsWith(UNKNOWN_FLAG_PREFIX)) return /* @__PURE__ */ new Error("Unknown tail option");
+	return error;
+}
 /**
 * touch command handler for the AST-based compiler.
 */
+const parseTouchArgs = createWordParser({
+	accessTimeOnly: {
+		short: "a",
+		takesValue: false
+	},
+	modificationTimeOnly: {
+		short: "m",
+		takesValue: false
+	}
+}, expandedWordToString);
 /**
 * Compile a touch command from SimpleCommandIR to StepIR.
 */
 function compileTouch(cmd$1) {
-	const files$1 = [];
-	for (const arg of cmd$1.args) if (!expandedWordToString(arg).startsWith("-")) files$1.push(arg);
+	const parsed = parseTouchArgs(cmd$1.args, { unknownFlagPolicy: "positional" });
+	const accessTimeOnly = parsed.flags.accessTimeOnly === true;
+	const modificationTimeOnly = parsed.flags.modificationTimeOnly === true;
+	const files$1 = parsed.positionalWords.filter((arg) => {
+		return !expandedWordToString(arg).startsWith("-");
+	});
 	if (files$1.length === 0) throw new Error("touch requires at least one file");
 	return {
 		cmd: "touch",
-		args: { files: files$1 }
+		args: {
+			accessTimeOnly,
+			files: files$1,
+			modificationTimeOnly
+		}
 	};
 }
 let CommandHandler;
 (function(_CommandHandler) {
 	const handlers = {
 		cat: compileCat,
+		cd: compileCd,
 		cp: compileCp,
 		head: compileHead,
 		ls: compileLs,
 		mkdir: compileMkdir,
 		mv: compileMv,
+		pwd: compilePwd,
 		rm: compileRm,
 		tail: compileTail,
 		touch: compileTouch
@@ -880,8 +1193,8 @@ function createEmptyFlags() {
 /**
 * Check if any quote flag is set.
 */
-function isQuoted(flags$1) {
-	return flags$1.quoted || flags$1.singleQuoted || flags$1.doubleQuoted;
+function isQuoted(flags) {
+	return flags.quoted || flags.singleQuoted || flags.doubleQuoted;
 }
 /**
 * Human-readable names for token kinds.
@@ -923,11 +1236,11 @@ var Token = class Token$1 {
 	spelling;
 	span;
 	flags;
-	constructor(kind, spelling, span, flags$1 = createEmptyFlags()) {
+	constructor(kind, spelling, span, flags = createEmptyFlags()) {
 		this.kind = kind;
 		this.spelling = spelling;
 		this.span = span;
-		this.flags = flags$1;
+		this.flags = flags;
 	}
 	/**
 	* Get the canonical spelling for a token kind.
@@ -1184,16 +1497,16 @@ var Scanner = class {
 	readComplexWord(start) {
 		this.stateCtx.reset();
 		let spelling = "";
-		let flags$1 = createEmptyFlags();
+		let flags = createEmptyFlags();
 		while (!this.source.eof) {
 			const c = this.source.peek();
 			if (!this.stateCtx.inQuotes && this.isWordBoundary(c)) break;
 			const result = this.processChar(c);
 			spelling += result.chars;
-			flags$1 = mergeFlags(flags$1, result.flags);
+			flags = mergeFlags(flags, result.flags);
 			if (result.done) break;
 		}
-		return this.classifyWord(spelling, start, flags$1);
+		return this.classifyWord(spelling, start, flags);
 	}
 	processChar(c) {
 		if (c === "'" && !this.stateCtx.inDoubleQuote) return this.handleSingleQuote();
@@ -1211,11 +1524,11 @@ var Scanner = class {
 	}
 	handleGlobChar(c) {
 		this.source.advance();
-		const flags$1 = createEmptyFlags();
-		flags$1.containsGlob = true;
+		const flags = createEmptyFlags();
+		flags.containsGlob = true;
 		return {
 			chars: c,
-			flags: flags$1,
+			flags,
 			done: false
 		};
 	}
@@ -1231,12 +1544,12 @@ var Scanner = class {
 		}
 		this.stateCtx.push(LexerState.SINGLE_QUOTED);
 		this.source.advance();
-		const flags$1 = createEmptyFlags();
-		flags$1.singleQuoted = true;
-		flags$1.quoted = true;
+		const flags = createEmptyFlags();
+		flags.singleQuoted = true;
+		flags.quoted = true;
 		return {
 			chars: "",
-			flags: flags$1,
+			flags,
 			done: false
 		};
 	}
@@ -1252,12 +1565,12 @@ var Scanner = class {
 		}
 		this.stateCtx.push(LexerState.DOUBLE_QUOTED);
 		this.source.advance();
-		const flags$1 = createEmptyFlags();
-		flags$1.doubleQuoted = true;
-		flags$1.quoted = true;
+		const flags = createEmptyFlags();
+		flags.doubleQuoted = true;
+		flags.quoted = true;
 		return {
 			chars: "",
-			flags: flags$1,
+			flags,
 			done: false
 		};
 	}
@@ -1317,11 +1630,11 @@ var Scanner = class {
 				if (!this.source.eof) result += this.source.advance();
 			} else result += this.source.advance();
 		}
-		const flags$1 = createEmptyFlags();
-		flags$1.containsExpansion = true;
+		const flags = createEmptyFlags();
+		flags.containsExpansion = true;
 		return {
 			chars: result,
-			flags: flags$1,
+			flags,
 			done: false
 		};
 	}
@@ -1332,11 +1645,11 @@ var Scanner = class {
 		if (this.source.peek() === "]") result += this.source.advance();
 		while (!this.source.eof && this.source.peek() !== "]") result += this.source.advance();
 		if (this.source.peek() === "]") result += this.source.advance();
-		const flags$1 = createEmptyFlags();
-		flags$1.containsGlob = true;
+		const flags = createEmptyFlags();
+		flags.containsGlob = true;
 		return {
 			chars: result,
-			flags: flags$1,
+			flags,
 			done: false
 		};
 	}
@@ -1351,10 +1664,10 @@ var Scanner = class {
 		if (this.source.peek() === quoteChar) result += this.source.advance();
 		return result;
 	}
-	classifyWord(spelling, start, flags$1) {
-		if (NUMBER_PATTERN.test(spelling)) return this.makeToken(TokenKind.NUMBER, spelling, start, flags$1);
-		if (NAME_PATTERN.test(spelling)) return this.makeToken(TokenKind.NAME, spelling, start, flags$1);
-		return this.makeToken(TokenKind.WORD, spelling, start, flags$1);
+	classifyWord(spelling, start, flags) {
+		if (NUMBER_PATTERN.test(spelling)) return this.makeToken(TokenKind.NUMBER, spelling, start, flags);
+		if (NAME_PATTERN.test(spelling)) return this.makeToken(TokenKind.NAME, spelling, start, flags);
+		return this.makeToken(TokenKind.WORD, spelling, start, flags);
 	}
 	skipWhitespace() {
 		while (!this.source.eof) {
@@ -1377,8 +1690,8 @@ var Scanner = class {
 	isWordBoundary(c) {
 		return WORD_BOUNDARY_CHARS.has(c) || c === "\0";
 	}
-	makeToken(kind, spelling, start, flags$1 = createEmptyFlags()) {
-		return new Token(kind, spelling, start.span(this.source.position), flags$1);
+	makeToken(kind, spelling, start, flags = createEmptyFlags()) {
+		return new Token(kind, spelling, start.span(this.source.position), flags);
 	}
 };
 /**
@@ -2153,31 +2466,187 @@ function collect() {
 
 //#endregion
 //#region src/operator/cat/cat.ts
-function cat(fs) {
+function isLineRecord(record) {
+	return record.kind === "line";
+}
+function formatNonPrinting(text) {
+	let formatted = "";
+	for (const char of text) {
+		const code = char.charCodeAt(0);
+		if (code === 9) {
+			formatted += "	";
+			continue;
+		}
+		if (code < 32) {
+			formatted += `^${String.fromCharCode(code + 64)}`;
+			continue;
+		}
+		if (code === 127) {
+			formatted += "^?";
+			continue;
+		}
+		formatted += char;
+	}
+	return formatted;
+}
+function renderLineText(text, lineNumber, options) {
+	let rendered = text;
+	const showNonprinting = options.showAll || options.showNonprinting;
+	const showTabs = options.showAll || options.showTabs;
+	const showEnds = options.showAll || options.showEnds;
+	if (showNonprinting) rendered = formatNonPrinting(rendered);
+	if (showTabs) rendered = rendered.replaceAll("	", "^I");
+	if (showEnds) rendered = `${rendered}$`;
+	if (lineNumber !== null) rendered = `${lineNumber.toString().padStart(6, " ")}\t${rendered}`;
+	return rendered;
+}
+function normalizeOptions(options) {
+	return {
+		numberLines: options?.numberLines ?? false,
+		numberNonBlank: options?.numberNonBlank ?? false,
+		showAll: options?.showAll ?? false,
+		showEnds: options?.showEnds ?? false,
+		showNonprinting: options?.showNonprinting ?? false,
+		showTabs: options?.showTabs ?? false,
+		squeezeBlank: options?.squeezeBlank ?? false
+	};
+}
+function nextRenderedLine(text, state, options) {
+	const isBlank = text.length === 0;
+	if (options.squeezeBlank && isBlank && state.previousWasBlank) return {
+		isSkipped: true,
+		lineNumber: null,
+		text
+	};
+	state.previousWasBlank = isBlank;
+	return {
+		isSkipped: false,
+		lineNumber: (options.numberNonBlank ? !isBlank : options.numberLines) ? state.renderedLineNumber++ : null,
+		text
+	};
+}
+async function* emitLineRecord(record, state, options) {
+	const rendered = nextRenderedLine(record.text, state, options);
+	if (rendered.isSkipped) return;
+	yield {
+		...record,
+		text: renderLineText(rendered.text, rendered.lineNumber, options)
+	};
+}
+async function* emitJsonRecord(value, state, options) {
+	const rendered = nextRenderedLine(JSON.stringify(value), state, options);
+	if (rendered.isSkipped) return;
+	yield {
+		kind: "line",
+		text: renderLineText(rendered.text, rendered.lineNumber, options)
+	};
+}
+async function* emitFileLines(fs, path, state, options) {
+	let sourceLineNum = 1;
+	for await (const rawText of fs.readLines(path)) {
+		const rendered = nextRenderedLine(rawText, state, options);
+		if (rendered.isSkipped) continue;
+		yield {
+			file: path,
+			kind: "line",
+			lineNum: sourceLineNum++,
+			text: renderLineText(rendered.text, rendered.lineNumber, options)
+		};
+	}
+}
+function cat(fs, options) {
+	const normalized = normalizeOptions(options);
+	const state = {
+		previousWasBlank: false,
+		renderedLineNumber: 1
+	};
 	return async function* (input) {
-		for await (const file of input) {
-			let lineNum = 1;
-			for await (const text of fs.readLines(file.path)) yield {
-				file: file.path,
-				kind: "line",
-				lineNum: lineNum++,
-				text
-			};
+		for await (const record of input) {
+			if (isLineRecord(record)) {
+				yield* emitLineRecord(record, state, normalized);
+				continue;
+			}
+			if (record.kind === "json") {
+				yield* emitJsonRecord(record.value, state, normalized);
+				continue;
+			}
+			yield* emitFileLines(fs, record.path, state, normalized);
 		}
 	};
 }
 
 //#endregion
 //#region src/operator/cp/cp.ts
+const TRAILING_SLASH_REGEX$3 = /\/+$/;
+const MULTIPLE_SLASH_REGEX$3 = /\/+/g;
+function trimTrailingSlash$2(path) {
+	return path.replace(TRAILING_SLASH_REGEX$3, "");
+}
+function joinPath$1(base, suffix) {
+	return `${trimTrailingSlash$2(base)}/${suffix}`.replace(MULTIPLE_SLASH_REGEX$3, "/");
+}
+function basename$1(path) {
+	const normalized = trimTrailingSlash$2(path);
+	const slashIndex = normalized.lastIndexOf("/");
+	if (slashIndex === -1) return normalized;
+	return normalized.slice(slashIndex + 1);
+}
+async function isDirectory$1(fs, path) {
+	try {
+		return (await fs.stat(path)).isDirectory;
+	} catch {
+		return false;
+	}
+}
+async function assertCanWriteDestination(fs, path, force, interactive) {
+	if (!await fs.exists(path)) return;
+	if (interactive) throw new Error(`cp: destination exists (interactive): ${path}`);
+	if (!force) throw new Error(`cp: destination exists (use -f to overwrite): ${path}`);
+}
+async function copyFileWithPolicy(fs, src, dest, force, interactive) {
+	await assertCanWriteDestination(fs, dest, force, interactive);
+	const content = await fs.readFile(src);
+	await fs.writeFile(dest, content);
+}
+async function copyDirectoryRecursive(fs, srcDir, destDir, force, interactive) {
+	const normalizedSrc = trimTrailingSlash$2(srcDir);
+	const glob$1 = `${normalizedSrc}/**/*`;
+	for await (const srcPath of fs.readdir(glob$1)) {
+		const targetPath = joinPath$1(destDir, srcPath.slice(normalizedSrc.length + 1));
+		if ((await fs.stat(srcPath)).isDirectory) continue;
+		await copyFileWithPolicy(fs, srcPath, targetPath, force, interactive);
+	}
+}
 function cp(fs) {
-	return async ({ src, dest }) => {
-		const content = await fs.readFile(src);
-		await fs.writeFile(dest, content);
+	return async ({ srcs, dest, force = false, interactive = false, recursive }) => {
+		if (srcs.length === 0) throw new Error("cp requires at least one source");
+		const destinationIsDirectory = await isDirectory$1(fs, dest);
+		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$1(src)) : dest;
+			if (srcStat.isDirectory) {
+				if (!recursive) throw new Error(`cp: omitting directory "${src}" (use -r)`);
+				await copyDirectoryRecursive(fs, src, targetPath, force, interactive);
+				continue;
+			}
+			await copyFileWithPolicy(fs, src, targetPath, force, interactive);
+		}
 	};
 }
 
 //#endregion
 //#region src/operator/head/head.ts
+function headLines(n) {
+	return async function* (input) {
+		let emitted = 0;
+		for await (const line of input) {
+			if (emitted >= n) break;
+			emitted++;
+			yield line;
+		}
+	};
+}
 function headWithN(fs, n) {
 	return async function* (input) {
 		for await (const file of input) {
@@ -2197,11 +2666,21 @@ function headWithN(fs, n) {
 
 //#endregion
 //#region src/operator/ls/ls.ts
-async function* ls(fs, path) {
-	for await (const p of fs.readdir(path)) yield {
-		kind: "file",
-		path: p
-	};
+function basename(path) {
+	const normalized = path.replace(/\/+$/g, "");
+	const slashIndex = normalized.lastIndexOf("/");
+	if (slashIndex === -1) return normalized;
+	return normalized.slice(slashIndex + 1);
+}
+async function* ls(fs, path, options) {
+	const showAll = options?.showAll ?? false;
+	for await (const listedPath of fs.readdir(path)) {
+		if (!showAll && basename(listedPath).startsWith(".")) continue;
+		yield {
+			kind: "file",
+			path: listedPath
+		};
+	}
 }
 
 //#endregion
@@ -2214,27 +2693,42 @@ function mkdir(fs) {
 
 //#endregion
 //#region src/operator/mv/mv.ts
-const MULTIPLE_SLASH_REGEX = /\/+/g;
+const TRAILING_SLASH_REGEX$2 = /\/+$/;
+const MULTIPLE_SLASH_REGEX$2 = /\/+/g;
+function trimTrailingSlash$1(path) {
+	return path.replace(TRAILING_SLASH_REGEX$2, "");
+}
 function extractFileName(path) {
-	const lastSlashIndex = path.lastIndexOf("/");
-	if (lastSlashIndex === -1) return path;
-	return path.slice(lastSlashIndex + 1);
+	const normalized = trimTrailingSlash$1(path);
+	const lastSlashIndex = normalized.lastIndexOf("/");
+	if (lastSlashIndex === -1) return normalized;
+	return normalized.slice(lastSlashIndex + 1);
+}
+function joinPath(base, suffix) {
+	return `${trimTrailingSlash$1(base)}/${suffix}`.replace(MULTIPLE_SLASH_REGEX$2, "/");
+}
+async function isDirectory(fs, path) {
+	try {
+		return (await fs.stat(path)).isDirectory;
+	} catch {
+		return false;
+	}
+}
+async function assertCanMoveToDestination(fs, dest, force, interactive) {
+	if (!await fs.exists(dest)) return;
+	if (interactive) throw new Error(`mv: destination exists (interactive): ${dest}`);
+	if (!force) throw new Error(`mv: destination exists (use -f to overwrite): ${dest}`);
 }
 function mv(fs) {
-	return async ({ srcs, dest }) => {
-		if (srcs.length === 1) {
-			const src = srcs[0];
-			if (src === void 0) throw new Error("Source path is required");
-			try {
-				if ((await fs.stat(dest)).isDirectory) await moveFile(fs, src, `${dest}/${extractFileName(src)}`.replace(MULTIPLE_SLASH_REGEX, "/"));
-				else throw new Error(`Destination file already exists: ${dest}`);
-			} catch (error) {
-				if (error.message.includes("already exists")) throw error;
-				await moveFile(fs, src, dest);
-			}
-		} else for (const src of srcs) {
-			const fileName = extractFileName(src);
-			await moveFile(fs, src, (dest.endsWith("/") ? dest + fileName : `${dest}/${fileName}`).replace(MULTIPLE_SLASH_REGEX, "/"));
+	return async ({ srcs, dest, force = false, interactive = false }) => {
+		if (srcs.length === 0) throw new Error("mv requires at least one source");
+		const destinationIsDirectory = await isDirectory(fs, dest);
+		if (srcs.length > 1 && !destinationIsDirectory) throw new Error("mv destination must be a directory for multiple sources");
+		for (const src of srcs) {
+			if ((await fs.stat(src)).isDirectory) throw new Error(`mv: directory moves are not supported: ${src}`);
+			const targetPath = destinationIsDirectory || srcs.length > 1 ? joinPath(dest, extractFileName(src)) : dest;
+			await assertCanMoveToDestination(fs, targetPath, force, interactive);
+			await moveFile(fs, src, targetPath);
 		}
 	};
 }
@@ -2244,11 +2738,34 @@ async function moveFile(fs, src, dest) {
 	await fs.deleteFile(src);
 }
 
+//#endregion
+//#region src/operator/pwd/pwd.ts
+const ROOT_DIRECTORY$2 = "/";
+async function* pwd(cwd = ROOT_DIRECTORY$2) {
+	yield {
+		kind: "line",
+		text: cwd
+	};
+}
+
 //#endregion
 //#region src/operator/rm/rm.ts
 function rm(fs) {
-	return async ({ path }) => {
-		await fs.deleteFile(path);
+	return async ({ path, recursive, force = false, interactive = false }) => {
+		if (interactive) throw new Error(`rm: interactive mode is not supported: ${path}`);
+		let stat = null;
+		try {
+			stat = await fs.stat(path);
+		} catch {
+			if (force) return;
+			throw new Error(`File not found: ${path}`);
+		}
+		if (!stat.isDirectory) {
+			await fs.deleteFile(path);
+			return;
+		}
+		if (!recursive) throw new Error(`rm: cannot remove '${path}': Is a directory`);
+		await fs.deleteDirectory(path, true);
 	};
 }
 
@@ -2268,8 +2785,18 @@ function tail(n) {
 //#endregion
 //#region src/operator/touch/touch.ts
 function touch(fs) {
-	return async ({ files: files$1 }) => {
-		for (const file of files$1) if (!await fs.exists(file)) await fs.writeFile(file, new Uint8Array());
+	return async ({ files: files$1, accessTimeOnly = false, modificationTimeOnly = false }) => {
+		const shouldUpdateMtime = !accessTimeOnly || modificationTimeOnly;
+		for (const file of files$1) {
+			if (!await fs.exists(file)) {
+				await fs.writeFile(file, new Uint8Array());
+				continue;
+			}
+			if (shouldUpdateMtime) {
+				const content = await fs.readFile(file);
+				await fs.writeFile(file, content);
+			}
+		}
 	};
 }
 
@@ -2285,115 +2812,274 @@ async function* files(...paths) {
 //#endregion
 //#region src/execute/execute.ts
 const textEncoder = new TextEncoder();
+const EFFECT_COMMANDS = new Set([
+	"cd",
+	"cp",
+	"mkdir",
+	"mv",
+	"rm",
+	"touch"
+]);
+const LS_GLOB_PATTERN_REGEX = /[*?]/;
+const MULTIPLE_SLASH_REGEX$1 = /\/+/g;
+const TRAILING_SLASH_REGEX$1 = /\/+$/;
+const ROOT_DIRECTORY$1 = "/";
+function isEffectStep(step) {
+	return EFFECT_COMMANDS.has(step.cmd);
+}
+async function* emptyStream() {}
 /**
 * Execute compiles a PipelineIR into an executable result.
 * Returns either a stream (for producers/transducers) or a promise (for sinks).
 */
-function execute(ir, fs) {
-	const step = ir.steps[0];
-	if (!step) return {
+function execute(ir, fs, context = { cwd: ROOT_DIRECTORY$1 }) {
+	const normalizedContext = normalizeContext(context);
+	if (ir.steps.length === 0) return {
+		kind: "stream",
+		value: emptyStream()
+	};
+	const lastStep = ir.steps.at(-1);
+	if (!lastStep) return {
 		kind: "stream",
-		value: (async function* () {})()
+		value: emptyStream()
 	};
-	let result;
+	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`);
+		return applyOutputRedirect({
+			kind: "sink",
+			value: executePipelineToSink(ir.steps, fs, normalizedContext)
+		}, lastStep, fs);
+	}
+	return applyOutputRedirect({
+		kind: "stream",
+		value: executePipelineToStream(ir.steps, fs, normalizedContext)
+	}, lastStep, fs);
+}
+function executePipelineToStream(steps, fs, context) {
+	return (async function* () {
+		let stream = null;
+		for (const step of steps) {
+			if (isEffectStep(step)) throw new Error(`Unsupported pipeline: "${step.cmd}" requires being the final command`);
+			stream = executeStreamStep(step, fs, stream, context);
+		}
+		if (!stream) return;
+		yield* stream;
+	})();
+}
+async function executePipelineToSink(steps, fs, context) {
+	const finalStep = steps.at(-1);
+	if (!(finalStep && isEffectStep(finalStep))) return;
+	if (steps.length > 1) {
+		const stream = executePipelineToStream(steps.slice(0, -1), fs, context);
+		for await (const _record of stream);
+	}
+	await executeEffectStep(finalStep, fs, context);
+}
+function executeStreamStep(step, fs, input, context) {
 	switch (step.cmd) {
 		case "cat": {
-			const inputPath = getRedirectPath(step.redirections, "input");
-			result = {
-				kind: "stream",
-				value: pipe(files(...withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath)), cat(fs))
+			const options = {
+				numberLines: step.args.numberLines,
+				numberNonBlank: step.args.numberNonBlank,
+				showAll: step.args.showAll,
+				showEnds: step.args.showEnds,
+				showNonprinting: step.args.showNonprinting,
+				showTabs: step.args.showTabs,
+				squeezeBlank: step.args.squeezeBlank
 			};
-			break;
-		}
-		case "cp": {
-			const srcPaths = extractPathsFromExpandedWords(step.args.srcs);
-			const destPath = expandedWordToString(step.args.dest);
-			result = {
-				kind: "sink",
-				value: Promise.all(map(srcPaths, (src) => cp(fs)({
-					src,
-					dest: destPath,
-					recursive: step.args.recursive
-				}))).then()
-			};
-			break;
+			const inputPath = getRedirectPath(step.redirections, "input");
+			const filePaths = withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath);
+			if (filePaths.length > 0) return cat(fs, options)(files(...filePaths));
+			if (input) return cat(fs, options)(input);
+			return emptyStream();
 		}
 		case "head": {
 			const inputPath = getRedirectPath(step.redirections, "input");
-			result = {
-				kind: "stream",
-				value: pipe(files(...withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath)), headWithN(fs, step.args.n))
-			};
-			break;
+			const filePaths = withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath);
+			if (filePaths.length > 0) return headWithN(fs, step.args.n)(files(...filePaths));
+			if (!input) return emptyStream();
+			return headLines(step.args.n)(toLineStream(fs, input));
 		}
 		case "ls": {
 			const paths = extractPathsFromExpandedWords(step.args.paths);
-			result = {
-				kind: "stream",
-				value: (async function* () {
-					const results = await Promise.all(map(paths, (path) => ls(fs, path))).then();
-					for (const file of results) yield* file;
-				})()
-			};
+			return (async function* () {
+				for (const inputPath of paths) {
+					const resolvedPath = await resolveLsPath(fs, inputPath);
+					for await (const fileRecord of ls(fs, resolvedPath, { showAll: step.args.showAll })) {
+						if (step.args.longFormat) {
+							const stat = await fs.stat(fileRecord.path);
+							yield {
+								kind: "line",
+								text: formatLongListing(fileRecord.path, stat)
+							};
+							continue;
+						}
+						yield fileRecord;
+					}
+				}
+			})();
+		}
+		case "tail": {
+			const inputPath = getRedirectPath(step.redirections, "input");
+			const filePaths = withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath);
+			if (filePaths.length > 0) return (async function* () {
+				for (const filePath of filePaths) yield* tail(step.args.n)(cat(fs)(files(filePath)));
+			})();
+			if (!input) return emptyStream();
+			return tail(step.args.n)(toLineStream(fs, input));
+		}
+		case "pwd": return pwd(context.cwd);
+		default: {
+			const _exhaustive = step;
+			throw new Error(`Unknown command: ${String(_exhaustive.cmd)}`);
+		}
+	}
+}
+function normalizeAbsolutePath$1(path) {
+	const segments = (path.startsWith(ROOT_DIRECTORY$1) ? path : `${ROOT_DIRECTORY$1}${path}`).replace(MULTIPLE_SLASH_REGEX$1, "/").split(ROOT_DIRECTORY$1);
+	const normalizedSegments = [];
+	for (const segment of segments) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			normalizedSegments.pop();
+			continue;
+		}
+		normalizedSegments.push(segment);
+	}
+	const normalizedPath = `${ROOT_DIRECTORY$1}${normalizedSegments.join(ROOT_DIRECTORY$1)}`;
+	return normalizedPath === "" ? ROOT_DIRECTORY$1 : normalizedPath;
+}
+function normalizeCwd$1(cwd) {
+	if (cwd === "") return ROOT_DIRECTORY$1;
+	const trimmed = normalizeAbsolutePath$1(cwd).replace(TRAILING_SLASH_REGEX$1, "");
+	return trimmed === "" ? ROOT_DIRECTORY$1 : trimmed;
+}
+function normalizeContext(context) {
+	context.cwd = normalizeCwd$1(context.cwd);
+	return context;
+}
+function resolvePathFromCwd(cwd, path) {
+	if (path === "") return cwd;
+	if (path.startsWith(ROOT_DIRECTORY$1)) return normalizeAbsolutePath$1(path);
+	return normalizeAbsolutePath$1(`${cwd}/${path}`);
+}
+async function executeEffectStep(step, fs, context) {
+	switch (step.cmd) {
+		case "cd": {
+			const requestedPath = expandedWordToString(step.args.path);
+			const resolvedPath = resolvePathFromCwd(context.cwd, requestedPath);
+			let stat;
+			try {
+				stat = await fs.stat(resolvedPath);
+			} catch {
+				throw new Error(`cd: no such file or directory: ${requestedPath}`);
+			}
+			if (!stat.isDirectory) throw new Error(`cd: not a directory: ${requestedPath}`);
+			context.cwd = resolvedPath;
+			break;
+		}
+		case "cp": {
+			const srcPaths = extractPathsFromExpandedWords(step.args.srcs);
+			const destPath = expandedWordToString(step.args.dest);
+			await cp(fs)({
+				srcs: srcPaths,
+				dest: destPath,
+				force: step.args.force,
+				interactive: step.args.interactive,
+				recursive: step.args.recursive
+			});
 			break;
 		}
 		case "mkdir": {
 			const paths = extractPathsFromExpandedWords(step.args.paths);
-			result = {
-				kind: "sink",
-				value: Promise.all(map(paths, (path) => mkdir(fs)({
-					path,
-					recursive: step.args.recursive
-				}))).then()
-			};
+			for (const path of paths) await mkdir(fs)({
+				path,
+				recursive: step.args.recursive
+			});
 			break;
 		}
 		case "mv": {
 			const srcPaths = extractPathsFromExpandedWords(step.args.srcs);
 			const destPath = expandedWordToString(step.args.dest);
-			result = {
-				kind: "sink",
-				value: mv(fs)({
-					srcs: srcPaths,
-					dest: destPath
-				})
-			};
+			await mv(fs)({
+				srcs: srcPaths,
+				dest: destPath,
+				force: step.args.force,
+				interactive: step.args.interactive
+			});
 			break;
 		}
 		case "rm": {
 			const paths = extractPathsFromExpandedWords(step.args.paths);
-			result = {
-				kind: "sink",
-				value: Promise.all(map(paths, (path) => rm(fs)({
-					path,
-					recursive: step.args.recursive
-				}))).then()
-			};
-			break;
-		}
-		case "tail": {
-			const inputPath = getRedirectPath(step.redirections, "input");
-			const filePaths = withInputRedirect(extractPathsFromExpandedWords(step.args.files), inputPath);
-			result = {
-				kind: "stream",
-				value: (async function* () {
-					const results = await Promise.all(map(filePaths, (file) => pipe(files(file), cat(fs), tail(step.args.n))));
-					for (const lines of results) yield* lines;
-				})()
-			};
+			for (const path of paths) await rm(fs)({
+				path,
+				force: step.args.force,
+				interactive: step.args.interactive,
+				recursive: step.args.recursive
+			});
 			break;
 		}
 		case "touch": {
 			const filePaths = extractPathsFromExpandedWords(step.args.files);
-			result = {
-				kind: "sink",
-				value: touch(fs)({ files: filePaths })
-			};
+			await touch(fs)({
+				files: filePaths,
+				accessTimeOnly: step.args.accessTimeOnly,
+				modificationTimeOnly: step.args.modificationTimeOnly
+			});
 			break;
 		}
-		default: throw new Error(`Unknown command: ${String(step.cmd)}`);
+		default: {
+			const _exhaustive = step;
+			throw new Error(`Unknown command: ${String(_exhaustive.cmd)}`);
+		}
 	}
-	return applyOutputRedirect(result, step, fs);
+}
+async function* toLineStream(fs, input) {
+	for await (const record of input) {
+		if (record.kind === "line") {
+			yield record;
+			continue;
+		}
+		if (record.kind === "file") {
+			let lineNum = 1;
+			for await (const text of fs.readLines(record.path)) yield {
+				kind: "line",
+				text,
+				file: record.path,
+				lineNum: lineNum++
+			};
+			continue;
+		}
+		yield {
+			kind: "line",
+			text: JSON.stringify(record.value)
+		};
+	}
+}
+function formatLongListing(path, stat) {
+	return `${stat.isDirectory ? "d" : "-"} ${String(stat.size).padStart(8, " ")} ${stat.mtime.toISOString()} ${path}`;
+}
+function normalizeLsPath(path) {
+	if (path === "." || path === "./") return "/";
+	if (path.startsWith("./")) return `/${path.slice(2)}`;
+	if (path.startsWith("/")) return path;
+	return `/${path}`;
+}
+function trimTrailingSlash(path) {
+	if (path === "/") return path;
+	return path.replace(TRAILING_SLASH_REGEX$1, "");
+}
+async function resolveLsPath(fs, path) {
+	const normalizedPath = normalizeLsPath(path);
+	if (LS_GLOB_PATTERN_REGEX.test(normalizedPath)) return normalizedPath;
+	try {
+		if (!(await fs.stat(normalizedPath)).isDirectory) return normalizedPath;
+	} catch {
+		return normalizedPath;
+	}
+	const directoryPath = trimTrailingSlash(normalizedPath);
+	if (directoryPath === "/") return "/*";
+	return `${directoryPath}/*`;
 }
 function getRedirectPath(redirections, kind) {
 	if (!redirections) return null;
@@ -2448,6 +3134,27 @@ function lazy(fn) {
 
 //#endregion
 //#region src/shell/shell.ts
+const ROOT_DIRECTORY = "/";
+const MULTIPLE_SLASH_REGEX = /\/+/g;
+const TRAILING_SLASH_REGEX = /\/+$/;
+function normalizeAbsolutePath(path) {
+	const segments = (path.startsWith(ROOT_DIRECTORY) ? path : `${ROOT_DIRECTORY}${path}`).replace(MULTIPLE_SLASH_REGEX, "/").split(ROOT_DIRECTORY);
+	const normalizedSegments = [];
+	for (const segment of segments) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			normalizedSegments.pop();
+			continue;
+		}
+		normalizedSegments.push(segment);
+	}
+	return `${ROOT_DIRECTORY}${normalizedSegments.join(ROOT_DIRECTORY)}`;
+}
+function normalizeCwd(cwd) {
+	if (cwd === "") return ROOT_DIRECTORY;
+	const trimmed = normalizeAbsolutePath(cwd).replace(TRAILING_SLASH_REGEX, "");
+	return trimmed === "" ? ROOT_DIRECTORY : trimmed;
+}
 async function collectRecords(result) {
 	if (result.kind === "sink") {
 		await result.value;
@@ -2457,8 +3164,10 @@ async function collectRecords(result) {
 }
 var Shell = class {
 	fs;
-	constructor(fs) {
+	currentCwd;
+	constructor(fs, options = {}) {
 		this.fs = fs;
+		this.currentCwd = normalizeCwd(options.cwd ?? ROOT_DIRECTORY);
 	}
 	$ = (strings, ...exprs) => {
 		return this._exec(strings, ...exprs);
@@ -2466,32 +3175,58 @@ var Shell = class {
 	exec(strings, ...exprs) {
 		return this._exec(strings, ...exprs);
 	}
+	cwd(newCwd) {
+		this.currentCwd = normalizeCwd(newCwd);
+	}
 	_exec(strings, ...exprs) {
 		const source = String.raw(strings, ...exprs);
 		const fs = this.fs;
+		let cwdOverride;
+		const runWithContext = async () => {
+			const commandStartCwd = normalizeCwd(cwdOverride ?? this.currentCwd);
+			const context = { cwd: commandStartCwd };
+			try {
+				return await collectRecords(execute(ir(), fs, context));
+			} finally {
+				if (cwdOverride === void 0 || context.cwd !== commandStartCwd) this.currentCwd = context.cwd;
+			}
+		};
+		const runStdoutWithContext = async () => {
+			const commandStartCwd = normalizeCwd(cwdOverride ?? this.currentCwd);
+			const context = { cwd: commandStartCwd };
+			try {
+				const result = execute(ir(), fs, context);
+				if (result.kind === "sink") {
+					await result.value;
+					return;
+				}
+				for await (const r of result.value) if (r.kind === "line") process.stdout.write(`${r.text}\n`);
+			} finally {
+				if (cwdOverride === void 0 || context.cwd !== commandStartCwd) this.currentCwd = context.cwd;
+			}
+		};
 		const ir = lazy(() => {
 			return compile(parse(source));
 		});
-		return {
+		const command = {
+			cwd(path) {
+				cwdOverride = normalizeCwd(path);
+				return command;
+			},
 			async json() {
-				return (await collectRecords(execute(ir(), fs))).filter((r) => r.kind === "json").map((r) => r.value);
+				return (await runWithContext()).filter((r) => r.kind === "json").map((r) => r.value);
 			},
 			async lines() {
-				return (await collectRecords(execute(ir(), fs))).filter((r) => r.kind === "line").map((r) => r.text);
+				return (await runWithContext()).filter((r) => r.kind === "line").map((r) => r.text);
 			},
 			async raw() {
-				return await collectRecords(execute(ir(), fs));
+				return await runWithContext();
 			},
 			async stdout() {
-				const result = execute(ir(), fs);
-				if (result.kind === "sink") {
-					await result.value;
-					return;
-				}
-				for await (const r of result.value) if (r.kind === "line") process.stdout.write(`${r.text}\n`);
+				await runStdoutWithContext();
 			},
 			async text() {
-				return (await collectRecords(execute(ir(), fs))).map((r) => {
+				return (await runWithContext()).map((r) => {
 					if (r.kind === "line") return r.text;
 					if (r.kind === "file") return r.path;
 					if (r.kind === "json") return JSON.stringify(r.value);
@@ -2499,6 +3234,7 @@ var Shell = class {
 				}).join("\n");
 			}
 		};
+		return command;
 	}
 };