shfs 0.2.2 → 0.3.1

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

@@ -1,23 +1,17 @@
 import picomatch from "picomatch";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-
 //#endregion
 //#region ../compiler/dist/index.mjs
 /**
@@ -718,6 +712,66 @@ function compileEcho(cmd) {
 		args: { values: [...cmd.args] }
 	};
 }
+function createDiagnostic(options) {
+	return {
+		code: options.code,
+		location: { ...options.location },
+		message: options.message,
+		phase: options.phase,
+		severity: options.severity ?? "error"
+	};
+}
+function createParserDiagnostic(message, span, options = {}) {
+	return createDiagnostic({
+		code: options.code ?? "syntax-error",
+		location: { span },
+		message,
+		phase: "parse",
+		severity: options.severity
+	});
+}
+function createCommandDiagnostic(command, code, message, options = {}) {
+	return createDiagnostic({
+		code,
+		location: {
+			command,
+			token: options.token,
+			tokenIndex: options.tokenIndex
+		},
+		message,
+		phase: "compile",
+		severity: options.severity
+	});
+}
+function createExpansionDiagnostic(command, code, message, options = {}) {
+	return createDiagnostic({
+		code,
+		location: {
+			command,
+			path: options.path
+		},
+		message,
+		phase: "expansion",
+		severity: options.severity
+	});
+}
+function createRuntimeDiagnostic(command, code, message, options = {}) {
+	return createDiagnostic({
+		code,
+		location: {
+			command,
+			path: options.path,
+			token: options.token,
+			tokenIndex: options.tokenIndex
+		},
+		message,
+		phase: "runtime",
+		severity: options.severity
+	});
+}
+function hasErrorDiagnostics(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
 const DEFAULT_ACTION = {
 	explicit: false,
 	kind: "print"
@@ -737,8 +791,12 @@ function compileFind(command) {
 function parseFindArgs(argv) {
 	const state = {
 		action: { ...DEFAULT_ACTION },
+		currentBranch: [],
+		currentSideAllowsEmptyBranch: false,
 		diagnostics: [],
-		predicates: [],
+		lastOrTokenIndex: null,
+		predicateBranches: [],
+		sawOr: false,
 		traversal: { ...DEFAULT_TRAVERSAL }
 	};
 	const predicateStartIndex = findPredicateStartIndex(argv);
@@ -753,22 +811,23 @@ function parseFindArgs(argv) {
 	return {
 		action: state.action,
 		diagnostics: state.diagnostics,
-		predicates: state.predicates,
+		predicateBranches: finalizePredicateBranches(state),
 		startPaths,
 		traversal: state.traversal,
 		usageError: state.diagnostics.length > 0
 	};
 }
-function createDiagnostic(code, token, tokenIndex, message) {
-	return {
-		code,
-		message,
+function createDiagnostic$1(code, token, tokenIndex, message) {
+	return createCommandDiagnostic("find", code, message, {
 		token,
 		tokenIndex
-	};
+	});
 }
 function createMissingValueDiagnostic(token, tokenIndex) {
-	return createDiagnostic("missing-value", token, tokenIndex, `find: missing argument to ${token}`);
+	return createDiagnostic$1("missing-value", token, tokenIndex, `find: missing argument to ${token}`);
+}
+function createMissingExpressionDiagnostic(side, tokenIndex) {
+	return createDiagnostic$1("invalid-expression", "-o", tokenIndex, `find: -o is missing a ${side} predicate expression`);
 }
 function findPredicateStartIndex(argv) {
 	for (const [index, word] of argv.entries()) if (expandedWordToString(word).startsWith("-")) return index;
@@ -777,20 +836,35 @@ function findPredicateStartIndex(argv) {
 function parseFindToken(argv, index, token, state) {
 	if (token === "-name" || token === "-path") return parseStringPredicate(argv, index, token, state);
 	if (token === "-type") return parseTypePredicate(argv, index, state);
+	if (token === "-o" || token === "-or") return parseOrPredicateSeparator(index, state);
 	if (token === "-maxdepth" || token === "-mindepth") return parseTraversalOption(argv, index, token, state);
 	if (token === "-depth") {
 		state.traversal.depth = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token === "-print") {
 		state.action.explicit = true;
+		state.currentSideAllowsEmptyBranch = true;
 		return index + 1;
 	}
 	if (token.startsWith("-")) {
-		state.diagnostics.push(createDiagnostic("unknown-predicate", token, index, `find: unknown predicate: ${token}`));
+		state.diagnostics.push(createDiagnostic$1("unknown-predicate", token, index, `find: unknown predicate: ${token}`));
 		return index + 1;
 	}
-	state.diagnostics.push(createDiagnostic("unexpected-operand", token, index, `find: unexpected argument: ${token}`));
+	state.diagnostics.push(createDiagnostic$1("unexpected-operand", token, index, `find: unexpected argument: ${token}`));
+	return index + 1;
+}
+function parseOrPredicateSeparator(index, state) {
+	state.sawOr = true;
+	state.lastOrTokenIndex = index;
+	if (state.currentBranch.length === 0 && !state.currentSideAllowsEmptyBranch) {
+		state.diagnostics.push(createMissingExpressionDiagnostic("left", index));
+		return index + 1;
+	}
+	state.predicateBranches.push(state.currentBranch);
+	state.currentBranch = [];
+	state.currentSideAllowsEmptyBranch = false;
 	return index + 1;
 }
 function parseStringPredicate(argv, index, token, state) {
@@ -799,7 +873,7 @@ function parseStringPredicate(argv, index, token, state) {
 		state.diagnostics.push(createMissingValueDiagnostic(token, index));
 		return index + 1;
 	}
-	state.predicates.push({
+	state.currentBranch.push({
 		kind: token === "-name" ? "name" : "path",
 		pattern: valueWord
 	});
@@ -813,12 +887,23 @@ function parseTypePredicate(argv, index, state) {
 	}
 	const parsedType = parseFindTypeValue(valueWord, index + 1);
 	if ("diagnostic" in parsedType) state.diagnostics.push(parsedType.diagnostic);
-	else state.predicates.push({
+	else state.currentBranch.push({
 		kind: "type",
 		types: parsedType.types
 	});
 	return index + 2;
 }
+function finalizePredicateBranches(state) {
+	if (state.currentBranch.length > 0) state.predicateBranches.push(state.currentBranch);
+	else if (state.sawOr && state.lastOrTokenIndex !== null) {
+		if (state.currentSideAllowsEmptyBranch) {
+			state.predicateBranches.push(state.currentBranch);
+			return state.predicateBranches;
+		}
+		state.diagnostics.push(createMissingExpressionDiagnostic("right", state.lastOrTokenIndex));
+	}
+	return state.predicateBranches;
+}
 function parseTraversalOption(argv, index, token, state) {
 	const valueWord = argv[index + 1];
 	if (!valueWord) {
@@ -832,20 +917,21 @@ function parseTraversalOption(argv, index, token, state) {
 	}
 	if (token === "-maxdepth") state.traversal.maxdepth = parsedNumericValue.value;
 	else state.traversal.mindepth = parsedNumericValue.value;
+	state.currentSideAllowsEmptyBranch = true;
 	return index + 2;
 }
 function parseFindTypeValue(word, tokenIndex) {
 	const rawValue = expandedWordToString(word);
-	if (rawValue === "") return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, "find: Arguments to -type should contain at least one letter") };
-	if (rawValue.endsWith(",")) return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, "find: Last file type in list argument to -type is missing") };
+	if (rawValue === "") return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, "find: Arguments to -type should contain at least one letter") };
+	if (rawValue.endsWith(",")) return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, "find: Last file type in list argument to -type is missing") };
 	const parts = rawValue.split(",");
-	if (parts.some((part) => part === "")) return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, "find: File type in list argument to -type is missing") };
+	if (parts.some((part) => part === "")) return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, "find: File type in list argument to -type is missing") };
 	const seen = /* @__PURE__ */ new Set();
 	const types = [];
 	for (const part of parts) {
-		if (part.length > 1) return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, "find: Must separate multiple arguments to -type with commas") };
-		if (part !== "d" && part !== "f") return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, `find: Unknown argument to -type: ${part}`) };
-		if (seen.has(part)) return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, `find: Duplicate file type in list argument to -type: ${part}`) };
+		if (part.length > 1) return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, "find: Must separate multiple arguments to -type with commas") };
+		if (part !== "d" && part !== "f") return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, `find: Unknown argument to -type: ${part}`) };
+		if (seen.has(part)) return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, `find: Duplicate file type in list argument to -type: ${part}`) };
 		seen.add(part);
 		types.push(part);
 	}
@@ -853,7 +939,7 @@ function parseFindTypeValue(word, tokenIndex) {
 }
 function parseNonNegativeInteger(token, word, tokenIndex) {
 	const rawValue = expandedWordToString(word);
-	if (!NON_NEGATIVE_INTEGER_REGEX.test(rawValue)) return { diagnostic: createDiagnostic("invalid-value", rawValue, tokenIndex, `find: ${token}: non-numeric argument: ${rawValue}`) };
+	if (!NON_NEGATIVE_INTEGER_REGEX.test(rawValue)) return { diagnostic: createDiagnostic$1("invalid-value", rawValue, tokenIndex, `find: ${token}: non-numeric argument: ${rawValue}`) };
 	return { value: Number.parseInt(rawValue, 10) };
 }
 const CONTEXT_SHORTHAND_REGEX = /^-[0-9]+$/;
@@ -896,7 +982,9 @@ const parseGrepWords = createWordParser({
 		long: "before-context",
 		short: "B"
 	}),
+	binaryFiles: grepValueFlag({ long: "binary-files" }),
 	binaryFile: grepValueFlag({ long: "binary-file" }),
+	binaryWithoutMatch: grepBooleanFlag({ short: "I" }),
 	byteOffset: grepBooleanFlag({
 		long: "byte-offset",
 		short: "b"
@@ -1033,7 +1121,7 @@ function parseGrepArgs(argv) {
 	applyModeOption(parsed, options);
 	applyFilenameMode(parsed, options);
 	applyFileListingMode(parsed, options);
-	applyBinaryFileOption(parsed, argv, options);
+	applyBinaryFileOption(parsed, argv, options, diagnostics);
 	applyDirectoriesOption(parsed, argv, options);
 	applyMaxCountOption(parsed, argv, options, diagnostics);
 	applyContextOptions(parsed, argv, options, diagnostics);
@@ -1142,8 +1230,58 @@ function applyFileListingMode(parsed, options) {
 		options.listFilesWithMatches = false;
 	}
 }
-function applyBinaryFileOption(parsed, argv, options) {
-	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) options.binaryWithoutMatch = occurrence.value === "without-match";
+function applyBinaryFileOption(parsed, argv, options, diagnostics) {
+	const modeOccurrences = [];
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFile")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const occurrence of getValueOccurrences(parsed, argv, "binaryFiles")) {
+		const mode = parseBinaryMode(occurrence.value);
+		if (mode === null) {
+			diagnostics.push(makeDiagnostic("invalid-value", occurrence.token, occurrence.tokenIndex, `Invalid value for option ${splitLongOption(occurrence.token)}.`));
+			continue;
+		}
+		modeOccurrences.push({
+			mode,
+			order: occurrence.order
+		});
+	}
+	for (const order of parsed.flagOccurrenceOrder.binaryWithoutMatch ?? []) modeOccurrences.push({
+		mode: "without-match",
+		order
+	});
+	for (const order of parsed.flagOccurrenceOrder.textMode ?? []) modeOccurrences.push({
+		mode: "text",
+		order
+	});
+	modeOccurrences.sort((a, b) => a.order - b.order);
+	for (const occurrence of modeOccurrences) switch (occurrence.mode) {
+		case "binary":
+			options.binaryWithoutMatch = false;
+			options.textMode = false;
+			break;
+		case "text":
+			options.binaryWithoutMatch = false;
+			options.textMode = true;
+			break;
+		case "without-match":
+			options.binaryWithoutMatch = true;
+			options.textMode = false;
+			break;
+		default: break;
+	}
+}
+function parseBinaryMode(value) {
+	if (value === "binary" || value === "text" || value === "without-match") return value;
+	return null;
 }
 function applyDirectoriesOption(parsed, argv, options) {
 	for (const occurrence of getValueOccurrences(parsed, argv, "directories")) options.directories = occurrence.value === "skip" ? "skip" : "read";
@@ -1319,7 +1457,7 @@ function mapParseDiagnostic(diagnostic) {
 	return makeDiagnostic("unknown-option", diagnostic.token, diagnostic.tokenIndex, diagnostic.message);
 }
 function isKnownDiagnosticToken(diagnostics, token, tokenIndex) {
-	return diagnostics.some((diagnostic) => diagnostic.token === token && diagnostic.tokenIndex === tokenIndex);
+	return diagnostics.some((diagnostic) => diagnostic.location.token === token && diagnostic.location.tokenIndex === tokenIndex);
 }
 function parseNumericOption(value) {
 	if (value === null || value === "") return null;
@@ -1343,12 +1481,10 @@ function splitLongOption(token) {
 	return token.slice(0, equalsIndex);
 }
 function makeDiagnostic(code, token, tokenIndex, message) {
-	return {
-		code,
-		message,
+	return createCommandDiagnostic("grep", code, message, {
 		token,
 		tokenIndex
-	};
+	});
 }
 /**
 * head command handler for the AST-based compiler.
@@ -2898,6 +3034,11 @@ var CommandParser = class {
 	}
 };
 /**
+* Error reporter for the Fish subset parser.
+*
+* Collects errors and warnings during parsing for reporting to the user.
+*/
+/**
 * Error reporter for collecting parser diagnostics.
 *
 * Supports both immediate error throwing and error collection modes.
@@ -2910,36 +3051,30 @@ var ErrorReporter = class {
 	* Report an error.
 	*/
 	reportError(message, span, code) {
-		this.diagnostics.push({
-			severity: "error",
-			message,
-			span,
-			code
-		});
+		this.diagnostics.push(createParserDiagnostic(message, span, {
+			code,
+			severity: "error"
+		}));
 		this.errorCount++;
 	}
 	/**
 	* Report a warning.
 	*/
 	reportWarning(message, span, code) {
-		this.diagnostics.push({
-			severity: "warning",
-			message,
-			span,
-			code
-		});
+		this.diagnostics.push(createParserDiagnostic(message, span, {
+			code,
+			severity: "warning"
+		}));
 		this.warningCount++;
 	}
 	/**
 	* Report an informational message.
 	*/
 	reportInfo(message, span, code) {
-		this.diagnostics.push({
-			severity: "info",
-			message,
-			span,
-			code
-		});
+		this.diagnostics.push(createParserDiagnostic(message, span, {
+			code,
+			severity: "info"
+		}));
 	}
 	/**
 	* Check if any errors have been reported.
@@ -2996,7 +3131,7 @@ var ErrorReporter = class {
 	*/
 	format() {
 		return this.diagnostics.map((d) => {
-			const loc = `${d.span.start.line}:${d.span.start.column}`;
+			const loc = d.location.span ? `${d.location.span.start.line}:${d.location.span.start.column}` : "unknown";
 			let prefix;
 			if (d.severity === "error") prefix = "Error";
 			else if (d.severity === "warning") prefix = "Warning";
@@ -3112,18 +3247,25 @@ var StatementParser = class {
 	}
 };
 /**
+* Syntax error exception for the Fish subset parser.
+*
+* Includes position information for error reporting.
+*/
+/**
 * Exception thrown when a syntax error is encountered during parsing.
 */
 var ParseSyntaxError = class ParseSyntaxError extends Error {
+	diagnostic;
 	/** The source span where the error occurred */
 	span;
 	/** Additional context about the error */
 	context;
-	constructor(message, span, context) {
-		super(ParseSyntaxError.formatMessage(message, span, context));
+	constructor(message, span, options = {}) {
+		super(ParseSyntaxError.formatMessage(message, span, options.context));
 		this.name = "ParseSyntaxError";
+		this.diagnostic = createParserDiagnostic(message, span, { code: options.code });
 		this.span = span;
-		this.context = context;
+		this.context = options.context;
 		if (Error.captureStackTrace) Error.captureStackTrace(this, ParseSyntaxError);
 	}
 	/**
@@ -3151,7 +3293,7 @@ var ParseSyntaxError = class ParseSyntaxError extends Error {
 */
 var UnexpectedEOFError = class extends ParseSyntaxError {
 	constructor(expected, span) {
-		super(`Unexpected end of input, expected ${expected}`, span);
+		super(`Unexpected end of input, expected ${expected}`, span, { code: "unexpected-eof" });
 		this.name = "UnexpectedEOFError";
 	}
 };
@@ -3162,7 +3304,7 @@ var UnexpectedTokenError = class extends ParseSyntaxError {
 	found;
 	expected;
 	constructor(found, expected, span) {
-		super(`Unexpected token '${found}', expected ${expected}`, span);
+		super(`Unexpected token '${found}', expected ${expected}`, span, { code: "unexpected-token" });
 		this.name = "UnexpectedTokenError";
 		this.found = found;
 		this.expected = expected;
@@ -3405,11 +3547,15 @@ var Parser = class Parser {
 	* @param expected What was expected (for error context)
 	* @throws SyntaxError always
 	*/
-	syntacticError(message, expected) {
+	syntacticError(_message, expected) {
 		const span = this._currentToken.span;
-		this.errorReporter.reportError(message, span);
-		if (this._currentToken.kind === TokenKind.EOF) throw new UnexpectedEOFError(expected, span);
-		throw new UnexpectedTokenError(this._currentToken.spelling || Token.kindName(this._currentToken.kind), expected, span);
+		if (this._currentToken.kind === TokenKind.EOF) {
+			this.errorReporter.reportError(`Unexpected end of input, expected ${expected}`, span, "unexpected-eof");
+			throw new UnexpectedEOFError(expected, span);
+		}
+		const found = this._currentToken.spelling || Token.kindName(this._currentToken.kind);
+		this.errorReporter.reportError(`Unexpected token '${found}', expected ${expected}`, span, "unexpected-token");
+		throw new UnexpectedTokenError(found, expected, span);
 	}
 	/**
 	* Parse a complete program.
@@ -3428,7 +3574,7 @@ var Parser = class Parser {
 	* @returns The parsed program
 	*/
 	parseSubstitution(input) {
-		if (this.substitutionDepth >= Parser.MAX_SUBSTITUTION_DEPTH) throw new ParseSyntaxError("Maximum command substitution depth exceeded", this._currentToken.span);
+		if (this.substitutionDepth >= Parser.MAX_SUBSTITUTION_DEPTH) throw new ParseSyntaxError("Maximum command substitution depth exceeded", this._currentToken.span, { code: "max-substitution-depth" });
 		return new Parser(input, this.errorReporter, this.substitutionDepth + 1).parse();
 	}
 };
@@ -3442,10 +3588,9 @@ var Parser = class Parser {
 function parse(input) {
 	return new Parser(input).parse();
 }
-
 //#endregion
-//#region src/record.ts
-function formatRecord$1(record) {
+//#region src/stdout-record.ts
+function formatStdoutRecord(record) {
 	switch (record.kind) {
 		case "line": return record.text;
 		case "file": return record.displayPath ?? record.path;
@@ -3453,7 +3598,80 @@ function formatRecord$1(record) {
 		default: throw new Error("Unknown record kind");
 	}
 }
-
+//#endregion
+//#region src/stderr.ts
+function appendStderrLines(context, lines) {
+	context.stderr.push(...lines);
+}
+function formatStderr(lines) {
+	return lines.join("\n");
+}
+//#endregion
+//#region src/diagnostics.ts
+const FIRST_ARGUMENT_NUMBER = 1;
+var ShellDiagnosticError = class extends Error {
+	diagnostics;
+	exitCode;
+	constructor(diagnostics, exitCode = exitCodeForDiagnostics(diagnostics)) {
+		super(diagnostics.map((diagnostic) => toErrorMessage(diagnostic)).join("\n"));
+		this.name = "ShellDiagnosticError";
+		this.diagnostics = diagnostics;
+		this.exitCode = exitCode;
+	}
+	get status() {
+		return this.exitCode;
+	}
+};
+function createDiagnosticError(diagnostics, exitCode) {
+	return new ShellDiagnosticError(Array.isArray(diagnostics) ? diagnostics : [diagnostics], exitCode);
+}
+function formatDiagnostic(diagnostic) {
+	const prefix = `${diagnostic.severity}[${diagnostic.phase}:${diagnostic.code}]`;
+	const location = formatLocation(diagnostic.location);
+	return `${prefix}${location ? ` ${location}` : ""}: ${diagnostic.message}`;
+}
+function formatDiagnostics(diagnostics) {
+	return diagnostics.map((diagnostic) => formatDiagnostic(diagnostic));
+}
+function diagnosticsToStderrLines(diagnostics) {
+	return formatDiagnostics(diagnostics);
+}
+function writeDiagnosticsToStderr(context, diagnostics) {
+	appendStderrLines(context, diagnosticsToStderrLines(diagnostics));
+}
+function isShellDiagnosticError(error) {
+	return error instanceof ShellDiagnosticError;
+}
+function exitCodeForDiagnostics(diagnostics) {
+	let exitCode = 0;
+	for (const diagnostic of diagnostics) {
+		if (diagnostic.severity !== "error") continue;
+		exitCode = Math.max(exitCode, exitCodeForDiagnostic(diagnostic));
+	}
+	return exitCode;
+}
+function formatLocation(location) {
+	const segments = [];
+	if (location.command) segments.push(location.command);
+	if (location.span) segments.push(`${location.span.start.line}:${location.span.start.column}`);
+	else if (location.tokenIndex !== void 0) {
+		segments.push(`arg ${location.tokenIndex + FIRST_ARGUMENT_NUMBER}`);
+		if (location.token !== void 0) segments.push(`("${location.token}")`);
+	}
+	if (location.path) segments.push(location.path);
+	return segments.join(" ");
+}
+function exitCodeForDiagnostic(diagnostic) {
+	if (diagnostic.phase === "compile" && diagnostic.location.command === "grep") return 2;
+	return 1;
+}
+function toErrorMessage(diagnostic) {
+	const command = diagnostic.location.command;
+	const path = diagnostic.location.path;
+	if (command && path) return `${command}: ${path}: ${diagnostic.message}`;
+	if (command) return `${command}: ${diagnostic.message}`;
+	return diagnostic.message;
+}
 //#endregion
 //#region src/execute/path.ts
 const MULTIPLE_SLASH_REGEX$2 = /\/+/g;
@@ -3467,7 +3685,7 @@ async function collectOutputRecords(result) {
 		return [];
 	}
 	const outputs = [];
-	for await (const record of result.value) outputs.push(formatRecord$1(record));
+	for await (const record of result.value) outputs.push(formatStdoutRecord(record));
 	return outputs;
 }
 async function evaluateCommandSubstitution(command, fs, context) {
@@ -3575,10 +3793,10 @@ async function expandGlobPattern(pattern, fs, context) {
 	return matches;
 }
 function expectSingleExpandedPath(command, expectation, values, allowEmpty = false) {
-	if (values.length !== 1) throw new Error(`${command}: ${expectation}, got ${values.length}`);
+	if (values.length !== 1) throw createDiagnosticError(createExpansionDiagnostic(command, "invalid-path-count", `${expectation}, got ${values.length}`));
 	const resolvedValue = values.at(0);
-	if (resolvedValue === void 0) throw new Error(`${command}: path missing after expansion`);
-	if (!allowEmpty && resolvedValue === "") throw new Error(`${command}: ${expectation}, got empty path`);
+	if (resolvedValue === void 0) throw createDiagnosticError(createExpansionDiagnostic(command, "missing-path", "path missing after expansion"));
+	if (!allowEmpty && resolvedValue === "") throw createDiagnosticError(createExpansionDiagnostic(command, "invalid-path-count", `${expectation}, got empty path`));
 	return resolvedValue;
 }
 async function evaluateExpandedPathWords(command, words, fs, context) {
@@ -3595,7 +3813,7 @@ async function evaluateExpandedPathWord(command, word, fs, context) {
 	for (const part of expandedWordParts(word)) patternSegments.push(await evaluateExpandedWordPart(part, fs, context));
 	const pattern = patternSegments.join("");
 	const matches = await expandGlobPattern(pattern, fs, context);
-	if (matches.length === 0) throw new Error(`${command}: ${NO_GLOB_MATCH_MESSAGE}: ${pattern}`);
+	if (matches.length === 0) throw createDiagnosticError(createExpansionDiagnostic(command, "no-match", `${NO_GLOB_MATCH_MESSAGE}: ${pattern}`));
 	return matches;
 }
 async function evaluateExpandedSinglePath(command, expectation, word, fs, context, options) {
@@ -3622,7 +3840,6 @@ async function evaluateExpandedWordPart(part, fs, context) {
 		}
 	}
 }
-
 //#endregion
 //#region src/builtin/cd/cd.ts
 const cd = async (runtime, args) => {
@@ -3639,7 +3856,6 @@ const cd = async (runtime, args) => {
 	runtime.context.cwd = resolvedPath;
 	runtime.context.status = 0;
 };
-
 //#endregion
 //#region src/builtin/echo/echo.ts
 const echo = (runtime, args) => {
@@ -3651,7 +3867,6 @@ const echo = (runtime, args) => {
 		runtime.context.status = 0;
 	})();
 };
-
 //#endregion
 //#region src/execute/records.ts
 async function* toLineStream(fs, input) {
@@ -3670,6 +3885,25 @@ async function* toLineStream(fs, input) {
 		};
 	}
 }
+/**
+* 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.
+*/
+async function* toFormattedLineStream(input) {
+	for await (const record of input) {
+		if (record.kind === "line") {
+			yield record;
+			continue;
+		}
+		yield {
+			kind: "line",
+			text: formatStdoutRecord(record)
+		};
+	}
+}
 async function* fileRecordToLines(fs, record) {
 	if (await isDirectoryRecord(fs, record)) return;
 	let lineNum = 1;
@@ -3689,9 +3923,8 @@ async function isDirectoryRecord(fs, record) {
 	}
 }
 function formatRecord(record) {
-	return formatRecord$1(record);
+	return formatStdoutRecord(record);
 }
-
 //#endregion
 //#region src/builtin/read/read.ts
 const VARIABLE_NAME_REGEX$1 = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -3727,7 +3960,6 @@ const read = (runtime, args) => {
 		yield* [];
 	})();
 };
-
 //#endregion
 //#region src/builtin/set/set.ts
 const VARIABLE_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -3742,7 +3974,6 @@ const set = (runtime, args) => {
 		yield* [];
 	})();
 };
-
 //#endregion
 //#region src/builtin/string/string.ts
 function replace(runtime, operands) {
@@ -3804,7 +4035,6 @@ const string = (runtime, args) => {
 		throw new Error(`string: unsupported subcommand: ${subcommand}`);
 	})();
 };
-
 //#endregion
 //#region src/builtin/test/test.ts
 function evaluateStatus(operands) {
@@ -3823,7 +4053,6 @@ const test = (runtime, args) => {
 		yield* [];
 	})();
 };
-
 //#endregion
 //#region src/operator/cat/cat.ts
 function isLineRecord(record) {
@@ -3935,7 +4164,6 @@ function cat(fs, options) {
 		}
 	};
 }
-
 //#endregion
 //#region src/operator/cp/cp.ts
 const TRAILING_SLASH_REGEX$1 = /\/+$/;
@@ -4029,29 +4257,28 @@ function cp(fs) {
 		}
 	};
 }
-
 //#endregion
 //#region src/operator/find/find.ts
 async function* find(fs, context, args) {
-	if (args.usageError) {
-		context.status = 1;
-		yield* diagnosticsToLines(args.diagnostics);
+	if (hasErrorDiagnostics(args.diagnostics)) {
+		context.status = exitCodeForDiagnostics(args.diagnostics);
+		writeDiagnosticsToStderr(context, args.diagnostics);
 		return;
 	}
-	let resolvedPredicates;
+	let resolvedPredicateBranches;
 	try {
-		resolvedPredicates = await resolvePredicates(args.predicates, fs, context);
+		resolvedPredicateBranches = await resolvePredicates(args.predicateBranches, fs, context);
 	} catch (error) {
-		context.status = 1;
-		yield toErrorLine(error);
+		context.status = diagnosticExitCode(error);
+		writeErrorToStderr(context, error);
 		return;
 	}
 	let startPaths;
 	try {
 		startPaths = await resolveStartPaths(fs, context, args.startPaths);
 	} catch (error) {
-		context.status = 1;
-		yield toErrorLine(error);
+		context.status = diagnosticExitCode(error);
+		writeErrorToStderr(context, error);
 		return;
 	}
 	const state = { hadError: false };
@@ -4061,22 +4288,19 @@ async function* find(fs, context, args) {
 			startStat = await fs.stat(startPath.absolutePath);
 		} catch {
 			state.hadError = true;
-			yield {
-				kind: "line",
-				text: `find: ${startPath.displayPath}: No such file or directory`
-			};
+			writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "missing-path", "No such file or directory", { path: startPath.displayPath })]);
 			continue;
 		}
-		yield* walkEntry(fs, {
+		yield* walkEntry(fs, context, {
 			...startPath,
 			depth: 0,
 			isDirectory: startStat.isDirectory
-		}, args, resolvedPredicates, state);
+		}, args, resolvedPredicateBranches, state);
 	}
 	context.status = state.hadError ? 1 : 0;
 }
-async function* walkEntry(fs, entry, args, predicates, state) {
-	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicates);
+async function* walkEntry(fs, context, entry, args, predicateBranches, state) {
+	const matches = entry.depth >= args.traversal.mindepth && matchesPredicates(entry, predicateBranches);
 	if (!args.traversal.depth && matches) yield toFileRecord(entry);
 	if (entry.isDirectory && (args.traversal.maxdepth === null || entry.depth < args.traversal.maxdepth)) {
 		let childPaths;
@@ -4084,10 +4308,7 @@ async function* walkEntry(fs, entry, args, predicates, state) {
 			childPaths = await readChildren(fs, entry.absolutePath);
 		} catch {
 			state.hadError = true;
-			yield {
-				kind: "line",
-				text: `find: ${entry.displayPath}: Unable to read directory`
-			};
+			writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "unreadable-directory", "Unable to read directory", { path: entry.displayPath })]);
 			childPaths = [];
 		}
 		for (const childAbsolutePath of childPaths) {
@@ -4096,57 +4317,58 @@ async function* walkEntry(fs, entry, args, predicates, state) {
 				childStat = await fs.stat(childAbsolutePath);
 			} catch {
 				state.hadError = true;
-				yield {
-					kind: "line",
-					text: `find: ${appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath))}: No such file or directory`
-				};
+				writeDiagnosticsToStderr(context, [createRuntimeDiagnostic("find", "missing-path", "No such file or directory", { path: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)) })]);
 				continue;
 			}
-			yield* walkEntry(fs, {
+			yield* walkEntry(fs, context, {
 				absolutePath: childAbsolutePath,
 				displayPath: appendDisplayPath(entry.displayPath, basename$2(childAbsolutePath)),
 				depth: entry.depth + 1,
 				isDirectory: childStat.isDirectory
-			}, args, predicates, state);
+			}, args, predicateBranches, state);
 		}
 	}
 	if (args.traversal.depth && matches) yield toFileRecord(entry);
 }
-async function resolvePredicates(predicates, fs, context) {
+async function resolvePredicates(predicateBranches, fs, context) {
 	const resolved = [];
-	for (const predicate of predicates) switch (predicate.kind) {
-		case "name": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "name",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "path": {
-			const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
-			resolved.push({
-				kind: "path",
-				matcher: picomatch(pattern, {
-					bash: true,
-					dot: true
-				})
-			});
-			break;
-		}
-		case "type":
-			resolved.push({
-				kind: "type",
-				types: new Set(predicate.types)
-			});
-			break;
-		default: {
-			const _exhaustive = predicate;
-			throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+	for (const branch of predicateBranches) {
+		const resolvedBranch = [];
+		for (const predicate of branch) switch (predicate.kind) {
+			case "name": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "name",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				break;
+			}
+			case "path": {
+				const pattern = await evaluateExpandedWord(predicate.pattern, fs, context);
+				resolvedBranch.push({
+					kind: "path",
+					matcher: picomatch(pattern, {
+						bash: true,
+						dot: true
+					})
+				});
+				break;
+			}
+			case "type":
+				resolvedBranch.push({
+					kind: "type",
+					types: new Set(predicate.types)
+				});
+				break;
+			default: {
+				const _exhaustive = predicate;
+				throw new Error(`Unsupported find predicate: ${JSON.stringify(_exhaustive)}`);
+			}
 		}
+		resolved.push(resolvedBranch);
 	}
 	return resolved;
 }
@@ -4164,21 +4386,21 @@ async function resolveStartPaths(fs, context, startPathWords) {
 	}
 	return startPaths;
 }
-function matchesPredicates(entry, predicates) {
-	for (const predicate of predicates) {
-		if (predicate.kind === "name") {
-			if (!predicate.matcher(basename$2(entry.displayPath))) return false;
-			continue;
-		}
-		if (predicate.kind === "path") {
-			if (!predicate.matcher(entry.displayPath)) return false;
-			continue;
-		}
-		const entryType = entry.isDirectory ? "d" : "f";
-		if (!predicate.types.has(entryType)) return false;
-	}
+function matchesPredicates(entry, predicateBranches) {
+	if (predicateBranches.length === 0) return true;
+	const entryType = entry.isDirectory ? "d" : "f";
+	for (const branch of predicateBranches) if (matchesBranch(entry, entryType, branch)) return true;
+	return false;
+}
+function matchesBranch(entry, entryType, branch) {
+	for (const predicate of branch) if (!matchesPredicate(entry, entryType, predicate)) return false;
 	return true;
 }
+function matchesPredicate(entry, entryType, predicate) {
+	if (predicate.kind === "name") return predicate.matcher(basename$2(entry.displayPath));
+	if (predicate.kind === "path") return predicate.matcher(entry.displayPath);
+	return predicate.types.has(entryType);
+}
 async function readChildren(fs, path) {
 	const children = [];
 	for await (const childPath of fs.readdir(path)) children.push(childPath);
@@ -4196,19 +4418,16 @@ function basename$2(path) {
 	if (slashIndex === -1) return normalized;
 	return normalized.slice(slashIndex + 1);
 }
-function diagnosticsToLines(diagnostics) {
-	return (async function* () {
-		for (const diagnostic of diagnostics) yield {
-			kind: "line",
-			text: diagnostic.message
-		};
-	})();
+function diagnosticExitCode(error) {
+	if (isShellDiagnosticError(error)) return error.exitCode;
+	return 1;
 }
-function toErrorLine(error) {
-	return {
-		kind: "line",
-		text: error instanceof Error ? error.message : String(error)
-	};
+function writeErrorToStderr(context, error) {
+	if (isShellDiagnosticError(error)) {
+		writeDiagnosticsToStderr(context, error.diagnostics);
+		return;
+	}
+	appendStderrLines(context, [error instanceof Error ? error.message : String(error)]);
 }
 function toFileRecord(entry) {
 	return {
@@ -4237,7 +4456,6 @@ function trimTrailingSlashes(path) {
 	if (path === "/") return path;
 	return path.replace(/\/+$/g, "");
 }
-
 //#endregion
 //#region src/execute/redirection.ts
 const textEncoder = new TextEncoder();
@@ -4285,7 +4503,6 @@ async function writeStreamToFile(stream, path, fs) {
 	for await (const record of stream) outputChunks.push(formatRecord(record));
 	await fs.writeFile(path, textEncoder.encode(outputChunks.join("\n")));
 }
-
 //#endregion
 //#region src/operator/grep/grep.ts
 const UTF8_DECODER = new TextDecoder();
@@ -4307,33 +4524,43 @@ async function runGrepCommand(options) {
 		return await runGrepCommandInner(options);
 	} catch {
 		return {
-			lines: [],
-			status: 2
+			stdout: [],
+			stderr: [],
+			exitCode: 2
 		};
 	}
 }
 async function runGrepCommandInner(options) {
 	const parsed = options.parsed;
 	if (parsed.options.help) return {
-		lines: ["Usage: grep [OPTION]... PATTERNS [FILE]...", "Search for PATTERNS in each FILE."],
-		status: 0
+		stdout: ["Usage: grep [OPTION]... PATTERNS [FILE]...", "Search for PATTERNS in each FILE."],
+		stderr: [],
+		exitCode: 0
 	};
 	if (parsed.options.version) return {
-		lines: ["grep (shfs) 0.1"],
-		status: 0
+		stdout: ["grep (shfs) 0.1"],
+		stderr: [],
+		exitCode: 0
+	};
+	if (parsed.diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+		stdout: [],
+		stderr: formatDiagnostics(parsed.diagnostics),
+		exitCode: exitCodeForDiagnostics(parsed.diagnostics)
 	};
-	let hadError = parsed.usageError;
+	let hadError = false;
 	const normalized = await normalizeInvocation(parsed, options.fs, options.context);
 	hadError ||= normalized.hadError;
 	if (normalized.patterns.length === 0) return {
-		lines: [],
-		status: hadError ? 2 : 1
+		stdout: [],
+		stderr: [],
+		exitCode: hadError ? 2 : 1
 	};
 	const inputRedirectPath = await resolveRedirectPath("grep", options.redirections, "input", options.fs, options.context);
 	const outputRedirectPath = options.resolvedOutputRedirectPath ?? await resolveRedirectPath("grep", options.redirections, "output", options.fs, options.context);
 	if (hasInputOutputConflict(normalized.fileOperands, normalized.readsFromStdin, options.context.cwd, inputRedirectPath, outputRedirectPath) && !allowsSameInputOutputPath(parsed.options)) return {
-		lines: [],
-		status: 2
+		stdout: [],
+		stderr: [],
+		exitCode: 2
 	};
 	const matcherBuild = buildMatchers(normalized.patterns, parsed.options);
 	hadError ||= matcherBuild.compileError;
@@ -4349,23 +4576,21 @@ async function runGrepCommandInner(options) {
 			lines: [],
 			selectedLineCount: 0
 		};
-		if (target.stdin) result = searchBuffer(stdinBytes ?? new Uint8Array(), target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
+		let binaryInput = false;
+		let targetBytes = null;
+		if (target.stdin) targetBytes = stdinBytes ?? new Uint8Array();
 		else {
 			if (target.absolutePath === null) continue;
-			let bytes;
 			try {
-				bytes = await options.fs.readFile(target.absolutePath);
+				targetBytes = await options.fs.readFile(target.absolutePath);
 			} catch {
 				hadError = true;
 				continue;
 			}
-			if (parsed.options.binaryWithoutMatch && !parsed.options.textMode && isBinaryBuffer(bytes)) result = {
-				hasSelectedLine: false,
-				lines: [],
-				selectedLineCount: 0
-			};
-			else result = searchBuffer(bytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		}
+		if (targetBytes === null) continue;
+		binaryInput = shouldTreatAsBinaryInput(targetBytes, parsed.options);
+		if (!(binaryInput && parsed.options.binaryWithoutMatch)) result = searchBuffer(targetBytes, target.displayPath, matcherBuild.patterns, parsed.options, displayFilename);
 		if (parsed.options.listFilesWithMatches) {
 			if (result.hasSelectedLine) {
 				lines.push(target.displayPath);
@@ -4391,25 +4616,30 @@ async function runGrepCommandInner(options) {
 			continue;
 		}
 		if (result.hasSelectedLine) anySelected = true;
-		if (!parsed.options.quiet) lines.push(...result.lines);
+		if (!parsed.options.quiet) if (shouldPrintBinaryMatchMessage(binaryInput, result.hasSelectedLine, parsed.options)) lines.push(`Binary file ${target.displayPath} matches`);
+		else lines.push(...result.lines);
 		if (parsed.options.quiet && anySelected) break;
 	}
 	const corpusOverride = await maybeOverrideWithCorpusStatus(parsed.options.mode, normalized.patterns, searchTargets.targets, options.fs);
 	if (corpusOverride !== null) return {
-		lines,
-		status: corpusOverride
+		stdout: lines,
+		stderr: [],
+		exitCode: corpusOverride
 	};
 	if (parsed.options.quiet && anySelected) return {
-		lines: [],
-		status: 0
+		stdout: [],
+		stderr: [],
+		exitCode: 0
 	};
 	if (hadError) return {
-		lines,
-		status: 2
+		stdout: lines,
+		stderr: [],
+		exitCode: 2
 	};
 	return {
-		lines,
-		status: anySelected ? 0 : 1
+		stdout: lines,
+		stderr: [],
+		exitCode: anySelected ? 0 : 1
 	};
 }
 async function normalizeInvocation(parseResult, fs, context) {
@@ -5146,6 +5376,15 @@ function isValidUtf8(bytes) {
 function isBinaryBuffer(bytes) {
 	return bytes.includes(0);
 }
+function shouldTreatAsBinaryInput(bytes, options) {
+	if (options.textMode || options.nullData) return false;
+	return isBinaryBuffer(bytes);
+}
+function shouldPrintBinaryMatchMessage(binaryInput, hasSelectedLine, options) {
+	if (!(binaryInput && hasSelectedLine)) return false;
+	if (options.binaryWithoutMatch || options.countOnly || options.listFilesWithMatches || options.listFilesWithoutMatch) return false;
+	return true;
+}
 function byteLengthOfPrefix(text, charIndex) {
 	return UTF8_ENCODER.encode(text.slice(0, charIndex)).byteLength;
 }
@@ -5198,7 +5437,6 @@ function getCorpusEntries() {
 	corpusEntries = entries;
 	return corpusEntries;
 }
-
 //#endregion
 //#region src/operator/head/head.ts
 function headLines(n) {
@@ -5228,7 +5466,6 @@ function headWithN(fs, n) {
 		}
 	};
 }
-
 //#endregion
 //#region src/operator/ls/ls.ts
 function basename(path) {
@@ -5254,7 +5491,6 @@ async function* ls(fs, path, options) {
 		};
 	}
 }
-
 //#endregion
 //#region src/operator/mkdir/mkdir.ts
 function mkdir(fs) {
@@ -5262,7 +5498,6 @@ function mkdir(fs) {
 		await fs.mkdir(path, recursive);
 	};
 }
-
 //#endregion
 //#region src/operator/mv/mv.ts
 const TRAILING_SLASH_REGEX = /\/+$/;
@@ -5304,7 +5539,6 @@ function mv(fs) {
 		}
 	};
 }
-
 //#endregion
 //#region src/operator/pwd/pwd.ts
 const ROOT_DIRECTORY$1 = "/";
@@ -5314,7 +5548,6 @@ async function* pwd(cwd = ROOT_DIRECTORY$1) {
 		text: cwd
 	};
 }
-
 //#endregion
 //#region src/operator/rm/rm.ts
 function rm(fs) {
@@ -5335,7 +5568,6 @@ function rm(fs) {
 		await fs.deleteDirectory(path, true);
 	};
 }
-
 //#endregion
 //#region src/operator/tail/tail.ts
 function tail(n) {
@@ -5348,7 +5580,6 @@ function tail(n) {
 		yield* buf;
 	};
 }
-
 //#endregion
 //#region src/operator/touch/touch.ts
 function touch(fs) {
@@ -5366,7 +5597,6 @@ function touch(fs) {
 		}
 	};
 }
-
 //#endregion
 //#region src/execute/producers.ts
 async function* files(...paths) {
@@ -5375,7 +5605,6 @@ async function* files(...paths) {
 		path
 	};
 }
-
 //#endregion
 //#region src/execute/execute.ts
 var execute_exports = /* @__PURE__ */ __exportAll({ execute: () => execute });
@@ -5564,8 +5793,9 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 				redirections: step.redirections,
 				resolvedOutputRedirectPath
 			});
-			context.status = result.status;
-			for (const text of result.lines) yield {
+			context.status = result.exitCode;
+			context.stderr.push(...result.stderr);
+			for (const text of result.stdout) yield {
 				kind: "line",
 				text
 			};
@@ -5579,7 +5809,7 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 				context.status = 0;
 				return;
 			}
-			if (input) yield* headLines(step.args.n)(toLineStream(fs, input));
+			if (input) yield* headLines(step.args.n)(toFormattedLineStream(input));
 			context.status = 0;
 		})();
 		case "ls": return (async function* () {
@@ -5608,7 +5838,7 @@ function executeStreamStep(step, fs, input, context, resolvedOutputRedirectPath)
 				context.status = 0;
 				return;
 			}
-			if (input) yield* tail(step.args.n)(toLineStream(fs, input));
+			if (input) yield* tail(step.args.n)(toFormattedLineStream(input));
 			context.status = 0;
 		})();
 		case "pwd": return (async function* () {
@@ -5717,11 +5947,12 @@ function resolveLsPath(path, cwd) {
 function normalizeContext(context) {
 	context.cwd = normalizeCwd(context.cwd);
 	context.status ??= 0;
+	context.stderr ??= [];
 	context.globalVars ??= /* @__PURE__ */ new Map();
 	context.localVars ??= /* @__PURE__ */ new Map();
 	return context;
 }
-
 //#endregion
-export { parse as a, compile as i, execute_exports as n, formatRecord$1 as r, execute as t };
-//# sourceMappingURL=execute-CsIHQwCC.mjs.map
+export { formatStderr as a, compile as c, writeDiagnosticsToStderr as i, parse as l, execute_exports as n, formatStdoutRecord as o, isShellDiagnosticError as r, ParseSyntaxError as s, execute as t };
+
+//# sourceMappingURL=execute-1PmTy1KA.mjs.map