@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/FileSystem-4pPcEb_i.mjs

@@ -0,0 +1,1366 @@
+import { F as of, z as sort } from "./Array-B4kuTQeW.mjs";
+import { $t as suspend, A as ensuring, B as flatMap, Br as done, Cn as zipWith, Fn as catchDone, J as forkChild, K as forEach$1, M as fail, N as failCause, Nt as raceFirst, W as fnUntraced, Xt as succeed, a as all, aa as Service, at as isEffect, b as catchReason, dt as map, en as sync, gr as makeUnsafe, l as as, ln as try_, lr as doneUnsafe, q as forever, sr as _await, x as catchTag, xt as onError, y as catchIf } from "./Effect-CKFpqbmw.mjs";
+import { On as pipeArguments, Sn as identity, Tn as pipe, nn as isNotUndefined, qt as hasProperty, x as match } from "./Option-DkxSnBhp.mjs";
+import { b as fromPull, ct as toTransform, it as fromTransform$1, lt as unwrap$1, nt as unwrap$2, yt as join$1 } from "./Stream-bK9QIETN.mjs";
+import { a as String$1, f as mapInput } from "./Order-C1JC991I.mjs";
+import { i as TaggedError, n as Error$1 } from "./Data-CeCULr0-.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/ByteSize.js
+const bigint0 = /*#__PURE__*/ BigInt(0);
+const bigint1 = /*#__PURE__*/ BigInt(1);
+const decimalBase = /*#__PURE__*/ BigInt(1e3);
+const binaryBase = /*#__PURE__*/ BigInt(1024);
+const decimalUnits = [
+	{
+		symbol: "B",
+		factor: bigint1,
+		names: [
+			"B",
+			"byte",
+			"bytes"
+		]
+	},
+	{
+		symbol: "kB",
+		factor: decimalBase,
+		names: [
+			"kB",
+			"kilobyte",
+			"kilobytes"
+		]
+	},
+	{
+		symbol: "MB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(2),
+		names: [
+			"MB",
+			"megabyte",
+			"megabytes"
+		]
+	},
+	{
+		symbol: "GB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(3),
+		names: [
+			"GB",
+			"gigabyte",
+			"gigabytes"
+		]
+	},
+	{
+		symbol: "TB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(4),
+		names: [
+			"TB",
+			"terabyte",
+			"terabytes"
+		]
+	},
+	{
+		symbol: "PB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(5),
+		names: [
+			"PB",
+			"petabyte",
+			"petabytes"
+		]
+	},
+	{
+		symbol: "EB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(6),
+		names: [
+			"EB",
+			"exabyte",
+			"exabytes"
+		]
+	},
+	{
+		symbol: "ZB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(7),
+		names: [
+			"ZB",
+			"zettabyte",
+			"zettabytes"
+		]
+	},
+	{
+		symbol: "YB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(8),
+		names: [
+			"YB",
+			"yottabyte",
+			"yottabytes"
+		]
+	},
+	{
+		symbol: "RB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(9),
+		names: [
+			"RB",
+			"ronnabyte",
+			"ronnabytes"
+		]
+	},
+	{
+		symbol: "QB",
+		factor: decimalBase ** /*#__PURE__*/ BigInt(10),
+		names: [
+			"QB",
+			"quettabyte",
+			"quettabytes"
+		]
+	}
+];
+const binaryUnits = [
+	decimalUnits[0],
+	{
+		symbol: "KiB",
+		factor: binaryBase,
+		names: [
+			"KiB",
+			"kibibyte",
+			"kibibytes"
+		]
+	},
+	{
+		symbol: "MiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(2),
+		names: [
+			"MiB",
+			"mebibyte",
+			"mebibytes"
+		]
+	},
+	{
+		symbol: "GiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(3),
+		names: [
+			"GiB",
+			"gibibyte",
+			"gibibytes"
+		]
+	},
+	{
+		symbol: "TiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(4),
+		names: [
+			"TiB",
+			"tebibyte",
+			"tebibytes"
+		]
+	},
+	{
+		symbol: "PiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(5),
+		names: [
+			"PiB",
+			"pebibyte",
+			"pebibytes"
+		]
+	},
+	{
+		symbol: "EiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(6),
+		names: [
+			"EiB",
+			"exbibyte",
+			"exbibytes"
+		]
+	},
+	{
+		symbol: "ZiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(7),
+		names: [
+			"ZiB",
+			"zebibyte",
+			"zebibytes"
+		]
+	},
+	{
+		symbol: "YiB",
+		factor: binaryBase ** /*#__PURE__*/ BigInt(8),
+		names: [
+			"YiB",
+			"yobibyte",
+			"yobibytes"
+		]
+	}
+];
+const allUnits = [...decimalUnits, .../*#__PURE__*/ binaryUnits.slice(1)];
+const unitsByName = /*#__PURE__*/ new Map(/*#__PURE__*/ allUnits.flatMap((unit) => unit.names.map((name) => [name, unit])));
+const unitsBySymbol = /*#__PURE__*/ new Map(/*#__PURE__*/ allUnits.map((unit) => [unit.symbol, unit]));
+const make$2 = (value) => value;
+const invalid = (message) => {
+	throw new Error(`Invalid ByteSize: ${message}`);
+};
+const fromNumber = (input) => {
+	if (!Number.isSafeInteger(input) || input < 0) return invalid(`expected a non-negative safe integer, received ${input}`);
+	return make$2(BigInt(input));
+};
+const maxSafeInteger = /*#__PURE__*/ BigInt(Number.MAX_SAFE_INTEGER);
+const scaleDecimal = (quantity, factor) => {
+	const match = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(quantity);
+	if (match === null) return void 0;
+	const fraction = match[2] ?? "";
+	const numerator = BigInt(match[1] + fraction) * factor;
+	const shift = Number(match[3] ?? 0) - fraction.length;
+	if (shift >= 0) return numerator * BigInt(10) ** BigInt(shift);
+	const scale = BigInt(10) ** BigInt(-shift);
+	return numerator % scale === bigint0 ? numerator / scale : void 0;
+};
+const fromQuantity = (quantity, unit) => {
+	if (typeof quantity === "bigint") {
+		if (quantity < bigint0) return invalid(`expected a non-negative quantity, received ${quantity}`);
+		return make$2(quantity * unit.factor);
+	}
+	if (binaryUnits.includes(unit)) {
+		const value = quantity * Number(unit.factor);
+		if (Number.isSafeInteger(value) && value >= 0) return make$2(BigInt(value));
+	} else {
+		const value = scaleDecimal(String(quantity), unit.factor);
+		if (value !== void 0 && value <= maxSafeInteger) return make$2(value);
+	}
+	return invalid(`expected an exact non-negative safe-integer byte result, received ${quantity} ${unit.symbol}`);
+};
+/**
+* Parses a byte-size string and throws for invalid syntax, unsupported units,
+* or quantities that do not represent non-negative integral bytes.
+*
+* **Details**
+*
+* Accepts decimal fractions, canonical SI and IEC symbols, lowercase unit
+* names, and whitespace around the quantity and unit. Parsing uses exact
+* bigint arithmetic, including above the safe integer range.
+*
+* @see {@link fromString} for non-throwing validation
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromStringUnsafe = (input) => {
+	const match = /^\s*(\d+(?:\.\d+)?)\s*([A-Za-z]+)\s*$/.exec(input);
+	if (match === null) return invalid(`unsupported syntax ${JSON.stringify(input)}`);
+	const unit = unitsByName.get(match[2]);
+	if (unit === void 0) return invalid(`unsupported unit ${JSON.stringify(match[2])}`);
+	const value = scaleDecimal(match[1], unit.factor);
+	if (value === void 0) return invalid(`${JSON.stringify(input)} does not represent an integral number of bytes`);
+	return make$2(value);
+};
+/**
+* Decodes a trusted input into a byte size and throws for invalid input.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromInputUnsafe = (input) => {
+	switch (typeof input) {
+		case "bigint":
+			if (input < bigint0) return invalid(`expected a non-negative bigint, received ${input}`);
+			return make$2(input);
+		case "number": return fromNumber(input);
+		case "string": return fromStringUnsafe(input);
+	}
+	return invalid(`unsupported input ${input}`);
+};
+/**
+* Creates a byte size from a non-negative byte count.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const bytes = (value) => typeof value === "bigint" ? fromInputUnsafe(value) : fromNumber(value);
+const unitConstructor = (symbol) => (value) => fromQuantity(value, unitsBySymbol.get(symbol));
+/**
+* Creates a binary mebibyte value.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const mebibytes = /*#__PURE__*/ unitConstructor("MiB");
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/glob.js
+const maxExpansions = 1e4;
+const maxExpandedLength = 2 ** 22;
+const maxBraceDepth = 64;
+/** @internal */
+const compile = (patterns, dot) => {
+	const nodes = [];
+	const starts = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) for (const expanded of expandBraces(pattern)) {
+		const start = nodes.length;
+		if (compilePattern(expanded, nodes)) starts.add(start);
+	}
+	const initial = closure(nodes, starts);
+	return {
+		nodes,
+		initial,
+		dot,
+		masks: nodes.length <= 32 ? compileMasks(nodes, initial) : void 0
+	};
+};
+const compileMasks = (nodes, initial) => {
+	let start = 0;
+	for (const state of initial) start |= 1 << state;
+	let globstar = 0;
+	let end = 0;
+	let endFile = 0;
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const bit = 1 << i;
+		if (node._tag === "Globstar") globstar |= bit;
+		else if (node._tag === "End") {
+			end |= bit;
+			if (!node.directoryOnly) endFile |= bit;
+		}
+	}
+	return {
+		initial: start,
+		globstar,
+		end,
+		endFile
+	};
+};
+const isUnc = (path) => path.startsWith("//") && path[2] !== void 0 && path[2] !== "/";
+const compilePattern = (pattern, nodes) => {
+	if (pattern === "" || isUnc(pattern)) return false;
+	const raw = splitSegments(pattern);
+	const globstar = raw.indexOf("**");
+	if (globstar !== -1 && raw.some((segment, i) => i > globstar && (segment === "." || segment === ".."))) return false;
+	const { directory, segments } = normalize(raw);
+	if (segments.length === 0) return false;
+	for (const segment of segments) if (segment !== "**") nodes.push(compileSegment(Array.from(segment)));
+	else if (nodes[nodes.length - 1] !== globstarNode) nodes.push(globstarNode);
+	nodes.push({
+		_tag: "End",
+		directoryOnly: directory
+	});
+	return true;
+};
+const globstarNode = { _tag: "Globstar" };
+const splitSegments = (pattern) => {
+	const segments = [];
+	let start = 0;
+	for (let i = 0; i < pattern.length; i++) if (pattern[i] === "\\") i++;
+	else if (pattern[i] === "/") {
+		segments.push(pattern.slice(start, i));
+		start = i + 1;
+	}
+	segments.push(pattern.slice(start));
+	return segments;
+};
+const drive = /^[A-Za-z]:/;
+const isDrive = (segment) => segment.length === 2 && drive.test(segment);
+const isRoot = (name) => name === "" || name.length === 3 && name[2] === "/" && drive.test(name);
+const isAbsolute = (path) => path.startsWith("/") || path[2] === "/" && drive.test(path);
+const normalize = (raw) => {
+	const segments = [];
+	let i = 0;
+	if (raw.length > 1 && (raw[0] === "" || isDrive(raw[0]))) {
+		segments.push(raw[0] === "" ? "" : `${raw[0]}/`);
+		i = 1;
+	}
+	let directory = false;
+	for (; i < raw.length; i++) {
+		const segment = raw[i];
+		if (segment === "" || segment === ".") directory = i === raw.length - 1 && segments.length > 0;
+		else {
+			segments.push(segment);
+			directory = false;
+		}
+	}
+	if (segments.length === 0 && raw.includes(".")) segments.push(".");
+	return {
+		segments,
+		directory
+	};
+};
+const compileSegment = (chars) => {
+	const tokens = [];
+	let literal = "";
+	let magic = false;
+	let classes = true;
+	for (let i = 0; i < chars.length; i++) {
+		const char = chars[i];
+		if (char === "\\" && i + 1 < chars.length) {
+			literal += chars[++i];
+			tokens.push({
+				_tag: "Char",
+				code: chars[i].codePointAt(0)
+			});
+		} else if (char === "*") {
+			magic = true;
+			if (tokens[tokens.length - 1]?._tag !== "Star") tokens.push({ _tag: "Star" });
+		} else if (char === "?") {
+			magic = true;
+			tokens.push({ _tag: "Any" });
+		} else if (char === "[" && classes) {
+			const parsed = parseClass(chars, i);
+			if (parsed === void 0) {
+				classes = false;
+				literal += char;
+				tokens.push({
+					_tag: "Char",
+					code: char.codePointAt(0)
+				});
+			} else {
+				magic = true;
+				tokens.push(parsed.token);
+				i = parsed.end;
+			}
+		} else {
+			literal += char;
+			tokens.push({
+				_tag: "Char",
+				code: char.codePointAt(0)
+			});
+		}
+	}
+	if (!magic) return {
+		_tag: "Literal",
+		value: literal
+	};
+	const first = tokens[0];
+	return {
+		_tag: "Wildcard",
+		tokens,
+		leadingDot: first._tag === "Char" && first.code === 46,
+		affixes: compileAffixes(tokens)
+	};
+};
+const compileAffixes = (tokens) => {
+	let prefix = "";
+	let suffix;
+	for (const token of tokens) if (token._tag === "Star" && suffix === void 0) suffix = "";
+	else if (token._tag === "Char" && (token.code < 55296 || token.code > 57343)) {
+		const char = String.fromCodePoint(token.code);
+		if (suffix === void 0) prefix += char;
+		else suffix += char;
+	} else return;
+	return suffix === void 0 ? void 0 : {
+		prefix,
+		suffix
+	};
+};
+const range = (from, to) => [from.codePointAt(0), to.codePointAt(0)];
+const posixClasses = {
+	alnum: [
+		.../*#__PURE__*/ range("0", "9"),
+		.../*#__PURE__*/ range("A", "Z"),
+		.../*#__PURE__*/ range("a", "z")
+	],
+	alpha: [.../*#__PURE__*/ range("A", "Z"), .../*#__PURE__*/ range("a", "z")],
+	blank: [
+		9,
+		9,
+		32,
+		32
+	],
+	cntrl: [
+		0,
+		31,
+		127,
+		127
+	],
+	digit: /*#__PURE__*/ range("0", "9"),
+	graph: [33, 126],
+	lower: /*#__PURE__*/ range("a", "z"),
+	print: [32, 126],
+	punct: [
+		33,
+		47,
+		58,
+		64,
+		91,
+		96,
+		123,
+		126
+	],
+	space: [
+		9,
+		13,
+		32,
+		32
+	],
+	upper: /*#__PURE__*/ range("A", "Z"),
+	word: [
+		.../*#__PURE__*/ range("0", "9"),
+		.../*#__PURE__*/ range("A", "Z"),
+		95,
+		95,
+		.../*#__PURE__*/ range("a", "z")
+	],
+	xdigit: [
+		.../*#__PURE__*/ range("0", "9"),
+		.../*#__PURE__*/ range("A", "F"),
+		.../*#__PURE__*/ range("a", "f")
+	]
+};
+const parsePosixClass = (chars, open) => {
+	for (let i = open + 2; i < chars.length && i <= open + 8; i++) if (chars[i] === ":" && chars[i + 1] === "]") {
+		const ranges = posixClasses[chars.slice(open + 2, i).join("")];
+		return ranges === void 0 ? void 0 : {
+			ranges,
+			end: i + 1
+		};
+	}
+};
+const parseClass = (chars, open) => {
+	let i = open + 1;
+	const negated = chars[i] === "!" || chars[i] === "^";
+	if (negated) i++;
+	const ranges = [];
+	for (let first = true; i < chars.length; i++, first = false) {
+		let char = chars[i];
+		if (char === "/") return;
+		if (char === "]" && !first) return {
+			token: {
+				_tag: "Class",
+				ranges,
+				negated
+			},
+			end: i
+		};
+		if (char === "[" && chars[i + 1] === ":") {
+			const posix = parsePosixClass(chars, i);
+			if (posix !== void 0) {
+				ranges.push(...posix.ranges);
+				i = posix.end;
+				continue;
+			}
+		}
+		if (char === "\\" && i + 1 < chars.length) char = chars[++i];
+		if (chars[i + 1] === "-" && i + 2 < chars.length && chars[i + 2] !== "]") {
+			let next = i + 2;
+			if (chars[next] === "/") return;
+			if (chars[next] === "\\" && next + 1 < chars.length) next++;
+			ranges.push(...range(char, chars[next]));
+			i = next;
+			continue;
+		}
+		ranges.push(...range(char, char));
+	}
+};
+const expandBraces = (pattern) => {
+	const chars = Array.from(pattern);
+	const groups = matchBraceGroups(chars);
+	if (groups.size === 0) return [pattern];
+	const sequence = parseBraceSequence(chars, 0, chars.length, groups, 0);
+	if (sequence === void 0) return [pattern];
+	const count = countExpansions(sequence);
+	return count > maxExpansions || count * pattern.length > maxExpandedLength ? [pattern] : expandSequence(sequence);
+};
+const matchBraceGroups = (chars) => {
+	const groups = /* @__PURE__ */ new Map();
+	const stack = [];
+	let classes = true;
+	for (let i = 0; i < chars.length; i++) {
+		const char = chars[i];
+		if (char === "\\") i++;
+		else if (char === "/") classes = true;
+		else if (char === "[" && classes) {
+			const parsed = parseClass(chars, i);
+			if (parsed === void 0) classes = false;
+			else i = parsed.end;
+		} else if (char === "{") stack.push({
+			open: i,
+			commas: []
+		});
+		else if (char === ",") stack[stack.length - 1]?.commas.push(i);
+		else if (char === "}") {
+			const group = stack.pop();
+			if (group !== void 0 && group.commas.length > 0) groups.set(group.open, {
+				commas: group.commas,
+				close: i
+			});
+		}
+	}
+	return groups;
+};
+const parseBraceSequence = (chars, start, end, groups, depth) => {
+	if (depth > maxBraceDepth) return;
+	const parts = [];
+	let text = "";
+	for (let i = start; i < end; i++) {
+		const group = groups.get(i);
+		if (group === void 0) {
+			if (chars[i] === "\\" && i + 1 < end) text += chars[i++];
+			text += chars[i];
+			continue;
+		}
+		const alternatives = [];
+		let from = i + 1;
+		for (const to of [...group.commas, group.close]) {
+			const alternative = parseBraceSequence(chars, from, to, groups, depth + 1);
+			if (alternative === void 0) return;
+			alternatives.push(alternative);
+			from = to + 1;
+		}
+		if (text !== "") {
+			parts.push(text);
+			text = "";
+		}
+		parts.push(alternatives);
+		i = group.close;
+	}
+	if (text !== "") parts.push(text);
+	return parts;
+};
+const countExpansions = (sequence) => {
+	let count = 1;
+	for (const part of sequence) if (typeof part !== "string") {
+		let sum = 0;
+		for (const alternative of part) sum += countExpansions(alternative);
+		count *= sum;
+		if (count > maxExpansions) return Infinity;
+	}
+	return count;
+};
+const expandSequence = (sequence) => {
+	let out = [""];
+	for (const part of sequence) if (typeof part === "string") out = out.map((prefix) => prefix + part);
+	else {
+		const alternatives = part.flatMap(expandSequence);
+		out = out.flatMap((prefix) => alternatives.map((alternative) => prefix + alternative));
+	}
+	return out;
+};
+const matchToken = (token, code) => {
+	switch (token._tag) {
+		case "Char": return token.code === code;
+		case "Any": return true;
+		case "Star": return false;
+		case "Class": {
+			let found = false;
+			for (let i = 0; i < token.ranges.length && !found; i += 2) found = code >= token.ranges[i] && code <= token.ranges[i + 1];
+			return found !== token.negated;
+		}
+	}
+};
+const width = (code) => code > 65535 ? 2 : 1;
+const matchWildcard = (node, name, dot) => {
+	if (name === "." || name === ".." || name.startsWith(".") && !dot && !node.leadingDot) return false;
+	if (node.affixes !== void 0) {
+		const { prefix, suffix } = node.affixes;
+		return name.length >= prefix.length + suffix.length && name.startsWith(prefix) && name.endsWith(suffix);
+	}
+	const { tokens } = node;
+	let t = 0;
+	let c = 0;
+	let star = -1;
+	let resume = 0;
+	while (c < name.length) {
+		if (tokens[t]?._tag === "Star") {
+			star = t++;
+			resume = c;
+			continue;
+		}
+		const code = name.codePointAt(c);
+		if (t < tokens.length && matchToken(tokens[t], code)) {
+			t++;
+			c += width(code);
+		} else if (star !== -1) {
+			t = star + 1;
+			resume += width(name.codePointAt(resume));
+			c = resume;
+		} else return false;
+	}
+	while (tokens[t]?._tag === "Star") t++;
+	return t === tokens.length;
+};
+const closure = (nodes, states) => {
+	for (const state of states) if (nodes[state]._tag === "Globstar") states.add(state + 1);
+	return states;
+};
+const step = (compiled, states, name) => {
+	const explicit = /* @__PURE__ */ new Set();
+	const viaGlobstar = /* @__PURE__ */ new Set();
+	const root = isRoot(name);
+	for (const state of states) {
+		const node = compiled.nodes[state];
+		switch (node._tag) {
+			case "Globstar":
+				if (!root && name !== "." && name !== ".." && (compiled.dot || !name.startsWith("."))) viaGlobstar.add(state);
+				break;
+			case "Literal":
+				if (node.value === name) explicit.add(state + 1);
+				break;
+			case "Wildcard": if (!root && matchWildcard(node, name, compiled.dot)) explicit.add(state + 1);
+		}
+	}
+	return {
+		explicit: closure(compiled.nodes, explicit),
+		globstar: closure(compiled.nodes, viaGlobstar)
+	};
+};
+const union = (step) => {
+	if (step.globstar.size === 0) return step.explicit;
+	const states = new Set(step.explicit);
+	for (const state of step.globstar) states.add(state);
+	return states;
+};
+const accepts = (compiled, states, isDirectory) => {
+	for (const state of states) {
+		const node = compiled.nodes[state];
+		if (node._tag === "End" && (isDirectory || !node.directoryOnly)) return true;
+	}
+	return false;
+};
+const canDescend = (compiled, states) => {
+	for (const state of states) if (compiled.nodes[state]._tag !== "End") return true;
+	return false;
+};
+const needsDirectory = (compiled, states) => {
+	for (const state of states) {
+		const node = compiled.nodes[state];
+		if (node._tag === "End" && node.directoryOnly) return true;
+	}
+	return false;
+};
+const join = (parent, name) => {
+	if (parent === "") return name === "" ? "/" : name;
+	return parent.endsWith("/") ? parent + name : `${parent}/${name}`;
+};
+const isMissing = (error) => error.reason._tag === "NotFound" || error.reason._tag === "BadResource";
+const isIgnorable = (error) => isMissing(error) || error.reason._tag === "PermissionDenied";
+const isNotLink = (error) => isIgnorable(error) || error.reason._tag === "Unknown";
+const DIRECTORY_CONCURRENCY = 16;
+const byName = /*#__PURE__*/ mapInput(String$1, (entry) => entry.name);
+/** @internal */
+const make$1 = (fs) => (pattern, options) => walk(fs, compile([pattern], options?.dot ?? false), options);
+const walk = /*#__PURE__*/ fnUntraced(function* (fs, compiled, options) {
+	if (compiled.initial.size === 0) return [];
+	const root = options?.root ?? "";
+	const excludes = compile(options?.exclude ?? [], true);
+	const excludeNeedsDirectory = excludes.nodes.some((node) => node._tag === "End" && node.directoryOnly);
+	const toFsPath = (relative) => isAbsolute(relative) ? relative : relative === "" ? root === "" ? "." : root : join(root, relative);
+	const isUnlisted = (value) => value === "." || value === ".." || isRoot(value);
+	const probe = (parent, name, named) => {
+		const path = toFsPath(join(parent, name));
+		return fs.stat(path).pipe(map((info) => info.type), catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(as("SymbolicLink"), catchIf(isNotLink, () => succeed(void 0)))), catchIf(named ? isMissing : isIgnorable, () => succeed(void 0)), map((type) => type === void 0 ? void 0 : {
+			name,
+			type
+		}));
+	};
+	const entries = (relative, states, named) => {
+		const literals = /* @__PURE__ */ new Set();
+		let listed = !named;
+		for (const state of states) {
+			const node = compiled.nodes[state];
+			if (node._tag === "Literal") literals.add(node.value);
+			else if (node._tag !== "End") listed = true;
+		}
+		const probed = listed ? [...literals].filter(isUnlisted) : [...literals];
+		return zipWith(listed ? catchIf(fs.readDirectoryEntries(toFsPath(relative)), named ? isMissing : isIgnorable, () => succeed([])) : succeed([]), forEach$1(probed, (name) => probe(relative, name, named), { concurrency: 16 }), (listing, found) => ({
+			entries: sort([...listing, ...found.filter(isNotUndefined)], byName),
+			named: named && !listed
+		}));
+	};
+	const visit = ({ name, type }, parent, states, excluded) => {
+		const result = step(compiled, states, name);
+		const next = union(result);
+		if (next.size === 0) return;
+		const relative = join(parent, name);
+		const nextExcluded = union(step(excludes, excluded, name));
+		const descend = canDescend(compiled, next);
+		const child = (isDirectory, link) => {
+			const accepted = accepts(compiled, next, isDirectory);
+			if (!accepted && (!isDirectory || !descend) || accepts(excludes, nextExcluded, isDirectory)) return;
+			return {
+				relative,
+				accepted,
+				excluded: nextExcluded,
+				next: !isDirectory || !descend ? void 0 : !link || result.globstar.size === 0 ? next : canDescend(compiled, result.explicit) ? result.explicit : void 0
+			};
+		};
+		if (!descend && !needsDirectory(compiled, next) && !excludeNeedsDirectory) return child(false, false);
+		if (type !== "Unknown" && type !== "SymbolicLink") return child(type === "Directory", false);
+		const path = toFsPath(relative);
+		return fs.stat(path).pipe(map((info) => info.type === "Directory"), catchIf(isIgnorable, () => succeed(false)), flatMap((isDirectory) => {
+			const resolved = child(isDirectory, type === "SymbolicLink");
+			if (type === "SymbolicLink" || resolved?.next === void 0 || result.globstar.size === 0) return succeed(resolved);
+			return fs.readLink(path).pipe(as(child(isDirectory, true)), catchIf(isNotLink, () => succeed(resolved)));
+		}));
+	};
+	let slots = DIRECTORY_CONCURRENCY;
+	let finishing = false;
+	const failed = makeUnsafe();
+	const fork = (walk) => walk.pipe(onError((cause) => sync(() => {
+		if (!finishing) doneUnsafe(failed, failCause(cause));
+	})), ensuring(sync(() => {
+		slots++;
+	})), forkChild);
+	const directory = fnUntraced(function* (relative, states, excluded, named) {
+		const listing = yield* entries(relative, states, named);
+		const children = [];
+		const pending = [];
+		for (const entry of listing.entries) {
+			const child = visit(entry, relative, states, excluded);
+			if (isEffect(child)) {
+				const index = children.push(void 0) - 1;
+				pending.push(map(child, (child) => {
+					children[index] = child;
+				}));
+			} else children.push(child);
+		}
+		if (pending.length > 0) yield* all(pending, {
+			concurrency: 16,
+			discard: true
+		});
+		const subtrees = [];
+		for (const child of children) if (child?.next !== void 0) {
+			const walk = directory(child.relative, child.next, child.excluded, listing.named);
+			if (slots > 0) {
+				slots--;
+				subtrees.push(join$1(yield* fork(walk)));
+			} else subtrees.push(succeed(yield* walk));
+		}
+		const out = [];
+		let index = 0;
+		for (const child of children) {
+			if (child === void 0) continue;
+			if (child.accepted) out.push(child.relative);
+			if (child.next !== void 0) for (const path of yield* subtrees[index++]) out.push(path);
+		}
+		return out;
+	});
+	return yield* raceFirst(ensuring(directory("", compiled.initial, excludes.initial, true), sync(() => {
+		finishing = true;
+	})), _await(failed));
+});
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/PlatformError.js
+/**
+* Normalized errors for platform APIs.
+*
+* Platform services such as file systems, terminals, and sockets use
+* `PlatformError` to report host-level failures in a consistent shape. The
+* wrapper records whether the problem came from an invalid argument or from the
+* operating system, while preserving useful details such as the module, method,
+* path, descriptor, description, and original cause when available.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId$2 = "~effect/PlatformError";
+/**
+* Error data for an invalid argument passed to a platform API.
+*
+* **When to use**
+*
+* Use when you need to model caller input rejected before a platform operation
+* runs, including invalid-argument reason data.
+*
+* **Details**
+*
+* The error records the module and method that rejected the argument, with an
+* optional description and cause. It is usually wrapped in `PlatformError`.
+*
+* @see {@link badArgument} for creating a wrapped `PlatformError` whose reason is `BadArgument`
+* @see {@link SystemError} for failures reported by the host platform or operating system
+* @see {@link PlatformError} for the wrapper used by most platform APIs
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var BadArgument = class extends (/*#__PURE__*/ TaggedError("BadArgument")) {
+	/**
+	* Formats the module, method, and optional description that rejected the argument.
+	*
+	* **When to use**
+	*
+	* Use to read the formatted error message for a rejected platform argument.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+	}
+};
+/**
+* Error data for a platform or system operation failure.
+*
+* **When to use**
+*
+* Use when you need normalized reason data for a platform or system operation
+* failure, including the operation details.
+*
+* **Details**
+*
+* The error records a normalized `_tag`, the module and method that failed,
+* and optional details such as the syscall, path or descriptor, description,
+* and original cause. It is usually wrapped in `PlatformError`.
+*
+* @see {@link systemError} for creating the usual `PlatformError` wrapper from this reason data
+* @see {@link BadArgument} for platform API failures caused by rejected caller input before an operation runs
+* @see {@link SystemErrorTag} for the normalized tag values stored in `_tag`
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var SystemError = class extends Error$1 {
+	/**
+	* Formats the normalized system error tag with operation and path details.
+	*
+	* **When to use**
+	*
+	* Use to read the formatted error message for a normalized system failure.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return `${this._tag}: ${this.module}.${this.method}${this.pathOrDescriptor !== void 0 ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+	}
+};
+/**
+* Tagged error used by platform APIs to report either invalid arguments or
+* system-level failures.
+*
+* **When to use**
+*
+* Use as the shared error type for platform APIs that expose invalid arguments
+* and host or operating-system failures through a single `Effect` error
+* channel.
+*
+* **Details**
+*
+* The `reason` field contains the underlying `BadArgument` or `SystemError`.
+* When that reason has a cause, the cause is preserved on the wrapper.
+*
+* @see {@link BadArgument} for invalid inputs rejected before an operation runs
+* @see {@link SystemError} for failures reported by the host platform or operating system
+* @see {@link badArgument} for creating this wrapper from rejected caller input
+* @see {@link systemError} for creating this wrapper from a host or operating-system failure
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var PlatformError = class extends (/*#__PURE__*/ TaggedError("PlatformError")) {
+	constructor(reason) {
+		if ("cause" in reason) super({
+			reason,
+			cause: reason.cause
+		});
+		else super({ reason });
+	}
+	/**
+	* Marks this value as a platform error wrapper for runtime guards.
+	*
+	* **When to use**
+	*
+	* Use to identify `PlatformError` values through their runtime type marker.
+	*
+	* @since 4.0.0
+	*/
+	[TypeId$2] = TypeId$2;
+	get message() {
+		return this.reason.message;
+	}
+};
+/**
+* Creates a `PlatformError` whose reason is a `SystemError`.
+*
+* **When to use**
+*
+* Use to adapt an operating-system or platform failure into the normalized
+* platform error model.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const systemError = (options) => new PlatformError(new SystemError(options));
+/**
+* Creates a `PlatformError` whose reason is a `BadArgument`.
+*
+* **When to use**
+*
+* Use to report a platform API rejecting caller input before performing the
+* underlying operation.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const badArgument = (options) => new PlatformError(new BadArgument(options));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Sink.js
+const TypeId$1 = "~effect/Sink";
+const endVoid = /*#__PURE__*/ succeed([void 0]);
+const sinkVariance = {
+	_A: identity,
+	_In: identity,
+	_L: identity,
+	_E: identity,
+	_R: identity
+};
+const SinkProto = {
+	[TypeId$1]: sinkVariance,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Checks whether a value is a Sink.
+*
+* **Example** (Checking for a sink)
+*
+* ```ts import.meta.vitest
+* import { Sink } from "effect"
+*
+* const sink = Sink.never
+* const notStream = { data: [1, 2, 3] }
+*
+* Sink.isSink(sink) // => true
+* Sink.isSink(notStream) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 4.0.0
+*/
+const isSink = (u) => hasProperty(u, TypeId$1);
+/**
+* Creates a sink from a `Channel`.
+*
+* **When to use**
+*
+* Use to create a `Sink` from a `Channel` that processes non-empty arrays of
+* input values.
+*
+* **Example** (Using channel completion as the sink result)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Sink, Stream } from "effect"
+*
+* const channel = Channel.identity<readonly [number, ...Array<number>], never, void>().pipe(
+*   Channel.drain,
+*   Channel.mapDone(() => ["consumed"] as const)
+* )
+* const sink = Sink.fromChannel(channel)
+*
+* await Effect.runPromise(Stream.run(Stream.make(1, 2, 3), sink)) // => "consumed"
+* ```
+*
+* @see {@link toChannel} for converting a `Sink` back to a `Channel`
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromChannel = (channel) => fromTransform((upstream, scope) => toTransform(channel)(upstream, scope).pipe(flatMap(forever({ disableYield: true })), catchDone(succeed)));
+/**
+* Creates a `Sink` from a low-level transform function.
+*
+* **Details**
+*
+* The transform receives the upstream pull of non-empty input arrays and the
+* active scope, and returns an effect that completes with the sink's `End`
+* value.
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromTransform = (transform) => {
+	const self = Object.create(SinkProto);
+	self.transform = transform;
+	return self;
+};
+/**
+* Creates a `Channel` from a Sink.
+*
+* **Example** (Running a sink as a channel)
+*
+* ```ts import.meta.vitest
+* import { Channel, Effect, Sink, Stream } from "effect"
+*
+* const channel = Stream.toChannel(Stream.make(1, 2, 3)).pipe(
+*   Channel.pipeTo(Sink.toChannel(Sink.sum))
+* )
+*
+* await Effect.runPromise(Channel.runDrain(channel)) // => [6]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const toChannel = (self) => fromTransform$1((upstream, scope) => succeed(flatMap(self.transform(upstream, scope), done)));
+/**
+* Consumes and ignores all stream inputs.
+*
+* **When to use**
+*
+* Use to consume all upstream input and complete with void when the input
+* values and any aggregate result are not needed.
+*
+* @see {@link count} for consuming all input while returning the number of elements
+* @see {@link forEach} for consuming all input while running an effect for each element
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const drain = /*#__PURE__*/ fromTransform((upstream) => catchDone(forever(upstream, { disableYield: true }), () => endVoid));
+/**
+* A sink that executes the provided effectful function for every item fed
+* to it.
+*
+* **Example** (Running effects for each item)
+*
+* ```ts import.meta.vitest
+* import { Effect, Sink, Stream } from "effect"
+*
+* const processed: Array<number> = []
+* const sink = Sink.forEach((item: number) => Effect.sync(() => processed.push(item)))
+*
+* // Use it with a stream
+* const stream = Stream.make(1, 2, 3)
+* await Effect.runPromise(Stream.run(stream, sink))
+* processed // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const forEach = (f) => forEachArray(forEach$1((_) => f(_), { discard: true }));
+/**
+* A sink that executes the provided effectful function for every Chunk fed
+* to it.
+*
+* **Example** (Running effects for each chunk)
+*
+* ```ts import.meta.vitest
+* import { Effect, Sink, Stream } from "effect"
+*
+* const processed: Array<Array<number>> = []
+* const sink = Sink.forEachArray((chunk: ReadonlyArray<number>) => Effect.sync(() => processed.push([...chunk])))
+*
+* // Use it with a stream
+* const stream = Stream.make(1, 2, 3, 4, 5)
+* await Effect.runPromise(Stream.run(stream, sink))
+* processed // => [[1, 2, 3, 4, 5]]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const forEachArray = (f) => fromTransform((upstream) => upstream.pipe(flatMap(f), forever({ disableYield: true }), catchDone(() => endVoid)));
+/**
+* Creates a sink produced from a scoped effect.
+*
+* **Example** (Unwrapping a sink effect)
+*
+* ```ts import.meta.vitest
+* import { Effect, Sink, Stream } from "effect"
+*
+* // Create a sink from an effect that produces a sink
+* const processed: Array<number> = []
+* const sinkEffect = Effect.succeed(
+*   Sink.forEach((item: number) => Effect.sync(() => processed.push(item)))
+* )
+* const sink = Sink.unwrap(sinkEffect)
+*
+* // Use it with a stream
+* const stream = Stream.make(1, 2, 3)
+* await Effect.runPromise(Stream.run(stream, sink))
+* processed // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unwrap = (effect) => fromChannel(unwrap$1(map(effect, toChannel)));
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/FileSystem.js
+/**
+* Defines the portable file system service for Effect programs.
+*
+* `FileSystem` is the boundary between Effect code and the host file system.
+* Platform packages provide concrete layers, while this module defines the
+* operations for reading, writing, inspecting, streaming, and watching files.
+* Operations return `Effect`, `Stream`, or `Sink` values and fail with
+* `PlatformError`. The module also includes file handles, open flags, watch
+* events, and the watch backend service.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId = "~effect/FileSystem";
+/**
+* Service tag for platform file-system operations.
+*
+* **When to use**
+*
+* Use to access or provide operations for files, directories, permissions,
+* streams, and sinks through the Effect context.
+*
+* **Details**
+*
+* This key is used to provide and access the FileSystem service in the Effect context.
+*
+* **Example** (Accessing and providing FileSystem)
+*
+* ```ts import.meta.vitest
+* import { Effect, FileSystem } from "effect"
+*
+* const customFs = FileSystem.makeNoop({
+*   exists: () => Effect.succeed(true),
+*   readFileString: () => Effect.succeed("contents")
+* })
+*
+* // Access the FileSystem service
+* const program = Effect.gen(function*() {
+*   const fs = yield* FileSystem.FileSystem
+*
+*   const exists = yield* fs.exists("./data.txt")
+*   return exists ? yield* fs.readFileString("./data.txt") : undefined
+* })
+*
+* const withCustomFs = Effect.provideService(
+*   program,
+*   FileSystem.FileSystem,
+*   customFs
+* )
+* Effect.runSync(withCustomFs) // => "contents"
+* ```
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const FileSystem = /*#__PURE__*/ Service("effect/FileSystem");
+/**
+* Creates a FileSystem implementation from a partial implementation.
+*
+* **When to use**
+*
+* Use to build a concrete `FileSystem` service from platform-specific core
+* operations while deriving the convenience methods that can be implemented
+* from them.
+*
+* **Details**
+*
+* This function takes a partial FileSystem implementation and automatically provides
+* default implementations for `exists`, `glob`, `readFileString`, `stream`, `sink`,
+* and `writeFileString` methods based on the provided core methods. `glob` walks
+* the tree with `readDirectoryEntries`, using `stat` and `readLink` for entries
+* whose type is `"Unknown"`.
+*
+* @see {@link makeNoop} for a testing stub that accepts method overrides without requiring a complete implementation
+* @see {@link layerNoop} for providing a no-op `FileSystem` as a `Layer` in tests
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (impl) => FileSystem.of({
+	...impl,
+	[TypeId]: TypeId,
+	glob: make$1(impl),
+	exists: (path) => pipe(impl.access(path), as(true), catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed(false) : fail(e))),
+	readFileString: (path, encoding) => flatMap(impl.readFile(path), (_) => try_({
+		try: () => new TextDecoder(encoding).decode(_),
+		catch: (cause) => badArgument({
+			module: "FileSystem",
+			method: "readFileString",
+			description: "invalid encoding",
+			cause
+		})
+	})),
+	stream: fnUntraced(function* (path, options) {
+		const file = yield* impl.open(path, { flag: "r" });
+		const offset = options?.offset === void 0 ? void 0 : fromInputUnsafe(options.offset);
+		if (offset) yield* file.seek(offset, "start");
+		const bytesToRead = options?.bytesToRead === void 0 ? void 0 : fromInputUnsafe(options.bytesToRead);
+		let totalBytesRead = BigInt(0);
+		const chunkSize = Number(BigInt(options?.chunkSize ?? 65536));
+		const readChunk = file.readAlloc(chunkSize);
+		return fromPull(succeed(flatMap(suspend(() => {
+			if (bytesToRead !== void 0 && bytesToRead <= totalBytesRead) return done();
+			return bytesToRead !== void 0 && bytesToRead - totalBytesRead < chunkSize ? file.readAlloc(Number(bytesToRead - totalBytesRead)) : readChunk;
+		}), match({
+			onNone: () => done(),
+			onSome: (buf) => {
+				totalBytesRead += BigInt(buf.length);
+				return succeed(of(buf));
+			}
+		}))));
+	}, unwrap$2),
+	sink: (path, options) => pipe(impl.open(path, {
+		...options,
+		flag: options?.flag ?? "w"
+	}), map((file) => forEach((_) => file.writeAll(_))), unwrap),
+	writeFileString: (path, data, options) => flatMap(try_({
+		try: () => new TextEncoder().encode(data),
+		catch: (cause) => badArgument({
+			module: "FileSystem",
+			method: "writeFileString",
+			description: "could not encode string",
+			cause
+		})
+	}), (_) => impl.writeFile(path, _, options))
+});
+/**
+* Runtime type identifier attached to `FileSystem.File` handles and used by
+* `isFile` to recognize them.
+*
+* **Details**
+*
+* This marker is part of the runtime representation of file handles. Prefer
+* `isFile` when narrowing unknown values.
+*
+* @see {@link File} for the open file handle shape that carries this marker
+* @see {@link isFile} for the public guard that checks this marker
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const FileTypeId = "~effect/FileSystem/File";
+/**
+* Service key for file system watch backend implementations.
+*
+* **Details**
+*
+* This service provides the low-level file watching capabilities that can be
+* implemented differently on various platforms (e.g., inotify on Linux,
+* FSEvents on macOS, etc.).
+*
+* **Example** (Providing a custom watch backend)
+*
+* ```ts import.meta.vitest
+* import { Effect, FileSystem, Option, Stream } from "effect"
+*
+* // Custom watch backend implementation
+* const customWatchBackend = {
+*   register: (path: string, stat: FileSystem.File.Info) => {
+*     // Implementation would depend on platform
+*     return Option.some(Stream.empty) // Placeholder implementation
+*   }
+* }
+*
+* const program = Effect.gen(function*() {
+*   const backend = yield* FileSystem.WatchBackend
+*   return Option.isSome(
+*     backend.register("./directory", { type: "Directory" } as FileSystem.File.Info)
+*   )
+* })
+*
+* const withCustomBackend = Effect.provideService(
+*   program,
+*   FileSystem.WatchBackend,
+*   customWatchBackend
+* )
+* Effect.runSync(withCustomBackend) // => true
+* ```
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var WatchBackend = class extends (/*#__PURE__*/ Service()("effect/FileSystem/WatchBackend")) {};
+export { drain as a, BadArgument as c, bytes as d, fromInputUnsafe as f, make as i, badArgument as l, FileTypeId as n, fromChannel as o, mebibytes as p, WatchBackend as r, isSink as s, FileSystem as t, systemError as u };