@athrio/loom 0.0.8 → 0.0.10

package/dist/NodeServices-CtEw3D6F.js

@@ -0,0 +1,1564 @@
+#!/usr/bin/env node
+import { Af as Prototype, Ah as identity, Bs as gen, C as WatchBackend, Cf as getUnsafe, Cs as effectify, Dt as systemError, E as callback$1, Ec as runFork, Em as BaseProto, Es as fail, Et as badArgument, F as fromChannel$1, Fa as offer, Fu as fail$2, Gp as fromNullishOr, Il as effect, Io as nominal, Ja as make$5, Kp as fromUndefinedOr, La as offerUnsafe, Lc as scoped, Ls as forkScoped, Ms as forEach, Na as failCauseUnsafe, Ns as forever, Os as flatMap, Ou as Done, Pa as make$8, Pu as done, Qa as makeUnsafe, Qs as map, S as Size, St as isSink, Tu as succeed$1, U as isStream, Uc as suspend, Ul as provideMerge, Up as flatMap$1, Vc as succeed, Vl as mergeAll, Vs as ignore, Wc as sync, Wl as succeed$2, X as mkString, Xc as tryPromise, Y as merge, Yc as timeoutOrElse, Yl as addFinalizer, Zc as try_, _ as TypeId$1, _f as Service, _h as isUndefined, _l as catchDone, _s as catch_, _u as makeUnsafe$1, ac as matchEffect, al as void_, ba as mapDone, bc as raceFirst, bt as drain, bu as fail$1, cp as of, ds as callback, dt as unwrap, du as _await, fc as orDie, fh as isNullish, gu as isDone, h as Path$1, is as andThen, j as empty, ja as endUnsafe, jh as pipe, js as fnUntraced, ju as UnknownError, k as decodeText, lh as isNotNull, ls as asVoid, lt as transduce, mt as make$7, nt as run, ot as splitLines, pt as get, pu as doneUnsafe, qp as getOrElse, rm as some, rs as addFinalizer$1, rt as runCollect, ss as as, tl as uninterruptible, tm as none, ts as acquireRelease, uh as isNotUndefined, v as FileDescriptor, w as make$6, wt as BadArgument, x as FileTypeId, xt as fromChannel, y as FileSystem, ya as fromTransform, zc as serviceOption } from "./SqlClient-BHo_uVyk.js";
+import { M as make$9, a as make$11, j as Crypto$1, o as Stdio, r as Terminal, s as make$10 } from "./dist-CKhPOkpR.js";
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
+import * as Crypto from "node:crypto";
+import * as NFS from "node:fs";
+import * as OS from "node:os";
+import * as Path from "node:path";
+import * as NodeUrl from "node:url";
+import * as readline from "node:readline";
+//#region ../../node_modules/effect/dist/unstable/process/ChildProcessSpawner.js
+/**
+* Service boundary for starting and controlling child processes.
+*
+* `ChildProcessSpawner` is the service used by `ChildProcess` commands to start
+* operating-system processes. A spawner turns a command description into a
+* handle that can write to stdin, read stdout and stderr, wait for exit, kill
+* the process, and manage whether the process keeps its parent alive. Platform
+* backends implement this service, while most application code uses the higher
+* level `ChildProcess` module.
+*
+* @since 4.0.0
+*/
+/**
+* Constructs branded child process `ExitCode` values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var ExitCode = /*#__PURE__*/ nominal();
+/**
+* Constructs branded child process `ProcessId` values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var ProcessId = /*#__PURE__*/ nominal();
+var HandleTypeId = "~effect/ChildProcessSpawner/ChildProcessHandle";
+var HandleProto = {
+	[HandleTypeId]: HandleTypeId,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "ChildProcessHandle",
+			pid: this.pid
+		};
+	}
+};
+/**
+* Constructs a new `ChildProcessHandle`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var makeHandle = (params) => Object.assign(Object.create(HandleProto), params);
+/**
+* Creates a `ChildProcessSpawner` service from a `spawn` function, deriving
+* helpers for exit codes and output collection from that implementation.
+*
+* @category models
+* @since 4.0.0
+*/
+var make$4 = (spawn) => {
+	const streamString = (command, options) => spawn(command).pipe(map((handle) => decodeText(options?.includeStderr === true ? handle.all : handle.stdout)), unwrap);
+	const streamLines = (command, options) => splitLines(streamString(command, options));
+	return ChildProcessSpawner.of({
+		spawn,
+		exitCode: (command) => scoped(flatMap(spawn(command), (handle) => handle.exitCode)),
+		streamString,
+		streamLines,
+		lines: (command, options) => runCollect(streamLines(command, options)),
+		string: (command, options) => mkString(streamString(command, options))
+	});
+};
+/**
+* Service tag for child process spawning.
+*
+* @category services
+* @since 4.0.0
+*/
+var ChildProcessSpawner = class extends Service()("effect/process/ChildProcessSpawner") {};
+//#endregion
+//#region ../../node_modules/effect/dist/unstable/process/ChildProcess.js
+/**
+* Describes child processes before they are started.
+*
+* A `Command` stores the executable, arguments, environment, standard streams,
+* working directory, and other process options. Commands can also be piped
+* together. A command is an `Effect`; running it asks the
+* `ChildProcessSpawner` service to start the process and returns a
+* `ChildProcessHandle`.
+*
+* @since 4.0.0
+*/
+var TypeId = "~effect/unstable/process/ChildProcess";
+var Proto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Command",
+		evaluate(fiber) {
+			return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
+		}
+	}),
+	[TypeId]: TypeId
+};
+var makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto), {
+	_tag: "StandardCommand",
+	command,
+	args,
+	options
+});
+/**
+* Create a command from a template literal, options + template, or array form.
+*
+* **Details**
+*
+* This function supports three calling conventions:
+* 1. Template literal: `make\`npm run build\``
+* 2. Options + template literal: `make({ cwd: "/app" })\`npm run build\``
+* 3. Array form: `make("npm", ["run", "build"], options?)`
+*
+* Template literals are not parsed until execution time, allowing parsing
+* errors to flow through Effect's error channel.
+*
+* **Example** (Creating commands)
+*
+* ```ts
+* import { ChildProcess } from "effect/unstable/process"
+*
+* // Template literal form
+* const cmd1 = ChildProcess.make`echo "hello"`
+*
+* // With options
+* const cmd2 = ChildProcess.make({ cwd: "/tmp" })`ls -la`
+*
+* // Array form
+* const cmd3 = ChildProcess.make("git", ["status"])
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+var make$3 = function make(...args) {
+	if (isTemplateString(args[0])) {
+		const [templates, ...expressions] = args;
+		const tokens = parseTemplates(templates, expressions);
+		return makeStandardCommand(tokens[0] ?? "", tokens.slice(1), {});
+	}
+	if (typeof args[0] === "object" && !Array.isArray(args[0]) && !isTemplateString(args[0])) {
+		const options = args[0];
+		return function(templates, ...expressions) {
+			const tokens = parseTemplates(templates, expressions);
+			return makeStandardCommand(tokens[0] ?? "", tokens.slice(1), options);
+		};
+	}
+	if (typeof args[0] === "string" && !Array.isArray(args[1])) {
+		const [command, options = {}] = args;
+		return makeStandardCommand(command, [], options);
+	}
+	const [command, cmdArgs = [], options = {}] = args;
+	return makeStandardCommand(command, cmdArgs, options);
+};
+var isTemplateString = (u) => Array.isArray(u) && "raw" in u && Array.isArray(u.raw);
+/**
+* Parses an fd name like "fd3" to its numeric index.
+* Returns undefined if the name is invalid.
+*
+* @category converting
+* @since 4.0.0
+*/
+var parseFdName = (name) => {
+	const match = /^fd(\d+)$/.exec(name);
+	if (match === null) return void 0;
+	const fd = parseInt(match[1], 10);
+	return fd >= 3 ? fd : void 0;
+};
+/**
+* Create an fd name from its numeric index.
+*
+* @category converting
+* @since 4.0.0
+*/
+var fdName = (fd) => `fd${fd}`;
+var parseTemplates = (templates, expressions) => {
+	let tokens = [];
+	for (const [index, template] of templates.entries()) tokens = parseTemplate(templates, expressions, tokens, template, index);
+	return tokens;
+};
+var parseTemplate = (templates, expressions, prevTokens, template, index) => {
+	const rawTemplate = templates.raw[index];
+	if (rawTemplate === void 0) throw new Error(`Invalid backslash sequence: ${templates.raw[index]}`);
+	const { hasLeadingWhitespace, hasTrailingWhitespace, tokens } = splitByWhitespaces(template, rawTemplate);
+	const nextTokens = concatTokens(prevTokens, tokens, hasLeadingWhitespace);
+	if (index === expressions.length) return nextTokens;
+	const expression = expressions[index];
+	return concatTokens(nextTokens, Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)], hasTrailingWhitespace);
+};
+/**
+* Convert valid expressions defined in a template string command (i.e. using
+* `${expression}` into strings.
+*/
+var parseExpression = (expression) => {
+	if (typeof expression === "string") return expression;
+	return String(expression);
+};
+var DELIMITERS = /*#__PURE__*/ new Set([
+	" ",
+	"	",
+	"\r",
+	"\n"
+]);
+/**
+* Number of characters in backslash escape sequences: \0 \xXX or \uXXXX
+* \cX is allowed in RegExps but not in strings
+* Octal sequences are not allowed in strict mode
+*/
+var ESCAPE_LENGTH = {
+	x: 3,
+	u: 5
+};
+/**
+* Splits a template string by whitespace while also properly handling escape
+* sequences.
+*
+* As an example, let's review the following valid commands:
+*
+* ```ts
+* ChildProcess.exec`echo foo\n bar`
+* // We should run `["echo", "foo\n", "bar"]`
+*
+* ChildProcess.exec`echo foo
+*  bar`
+* // We should run `["echo", "foo", "bar]`
+* ```
+*
+* The problem is that when we evaluate the template string for both of the above
+* commands, we will end up with the same string "echo foo\n bar".
+*
+* What we really want is to include the escaped character in the arguments for
+* the first command, since it was written explicitly by the user.
+*
+* This is why also having access to the raw template string is useful - in a
+* template string, there are two representations of the same string:
+* 1. `template`     - The processed string (escape sequences are evaluated).
+* 2. `template.raw` - The raw string (escape sequences are literal).
+*/
+var splitByWhitespaces = (template, rawTemplate) => {
+	if (rawTemplate.length === 0) return {
+		tokens: [],
+		hasLeadingWhitespace: false,
+		hasTrailingWhitespace: false
+	};
+	const hasLeadingWhitespace = DELIMITERS.has(rawTemplate[0]);
+	const tokens = [];
+	let templateCursor = 0;
+	for (let templateIndex = 0, rawIndex = 0; templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
+		const rawCharacter = rawTemplate[rawIndex];
+		if (DELIMITERS.has(rawCharacter)) {
+			if (templateCursor !== templateIndex) tokens.push(template.slice(templateCursor, templateIndex));
+			templateCursor = templateIndex + 1;
+		} else if (rawCharacter === "\\") {
+			const nextRawCharacter = rawTemplate[rawIndex + 1];
+			if (nextRawCharacter === "\n") {
+				templateIndex -= 1;
+				rawIndex += 1;
+			} else if (nextRawCharacter === "u" && rawTemplate[rawIndex + 2] === "{") rawIndex = rawTemplate.indexOf("}", rawIndex + 3);
+			else rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
+		}
+	}
+	const hasTrailingWhitespace = templateCursor === template.length;
+	if (!hasTrailingWhitespace) tokens.push(template.slice(templateCursor));
+	return {
+		tokens,
+		hasLeadingWhitespace,
+		hasTrailingWhitespace
+	};
+};
+/**
+* Concatenates two separate sets of string tokens together.
+*
+* If either set is empty or `isSeparated=false`, the last element of `prevTokens`
+* and the first element of `nextTokens` will be joined into a single token.
+*/
+var concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || prevTokens.length === 0 || nextTokens.length === 0 ? [...prevTokens, ...nextTokens] : [
+	...prevTokens.slice(0, -1),
+	`${prevTokens.at(-1)}${nextTokens.at(0)}`,
+	...nextTokens.slice(1)
+];
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/internal/utils.js
+/** @internal */
+var handleErrnoException = (module, method) => (err, [path]) => {
+	let reason = "Unknown";
+	switch (err.code) {
+		case "ENOENT":
+			reason = "NotFound";
+			break;
+		case "EACCES":
+			reason = "PermissionDenied";
+			break;
+		case "EEXIST":
+			reason = "AlreadyExists";
+			break;
+		case "EISDIR":
+			reason = "BadResource";
+			break;
+		case "ENOTDIR":
+			reason = "BadResource";
+			break;
+		case "EBUSY":
+			reason = "Busy";
+			break;
+		case "ELOOP":
+			reason = "BadResource";
+			break;
+	}
+	return systemError({
+		_tag: reason,
+		module,
+		method,
+		pathOrDescriptor: path,
+		syscall: err.syscall,
+		cause: err
+	});
+};
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodeSink.js
+/**
+* Creates a `Sink` that writes chunks to a Node writable stream, respecting
+* backpressure, mapping writable errors with `onError`, and ending the stream
+* on completion unless `endOnDone` is `false`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromWritable = (options) => fromChannel(mapDone(fromWritableChannel(options), (_) => [_]));
+/**
+* Creates a `Channel` that pulls chunks from upstream and writes them to a
+* Node writable stream, respecting backpressure and optionally ending the
+* writable when upstream is done.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromWritableChannel = (options) => fromTransform((pull) => {
+	const writable = options.evaluate();
+	return succeed(pullIntoWritable({
+		...options,
+		writable,
+		pull
+	}));
+});
+/**
+* Writes Effect chunks into a Node writable stream.
+*
+* **When to use**
+*
+* Use to implement custom Node stream adapters that already have an upstream
+* pull and need direct control over a writable stream.
+*
+* **Details**
+*
+* The loop waits for `drain` when needed, fails on writable errors, and ends
+* the writable on upstream completion unless `endOnDone` is `false`.
+*
+* @category converting
+* @since 4.0.0
+*/
+var pullIntoWritable = (options) => options.pull.pipe(flatMap((chunk) => {
+	let i = 0;
+	return callback(function loop(resume) {
+		for (; i < chunk.length;) if (!options.writable.write(chunk[i++], options.encoding)) {
+			options.writable.once("drain", () => loop(resume));
+			return;
+		}
+		resume(void_);
+	});
+}), forever({ disableYield: true }), raceFirst(callback((resume) => {
+	const onError = (error) => resume(fail(options.onError(error)));
+	options.writable.once("error", onError);
+	return sync(() => {
+		options.writable.off("error", onError);
+	});
+})), options.endOnDone !== false ? catchDone((_) => {
+	if ("closed" in options.writable && options.writable.closed) return done(_);
+	return callback((resume) => {
+		options.writable.once("finish", () => resume(done(_)));
+		options.writable.end();
+	});
+}) : identity);
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodeStream.js
+/**
+* Adapters between Node streams and Effect streams, channels, and readables.
+*
+* This module is the stream boundary for Node APIs. It wraps `Readable` and
+* `Duplex` values as Effect `Stream`s and `Channel`s, pipes Effect streams
+* through Node duplex streams, exposes an Effect `Stream` back to Node as a
+* `Readable`, and collects readable payloads into strings, array buffers, or
+* `Uint8Array`s with optional byte limits.
+*
+* @since 4.0.0
+*/
+/**
+* Converts a Node readable stream into an Effect `Stream`, reading chunks with
+* an optional chunk size, mapping stream errors with `onError`, and destroying
+* the readable on completion unless `closeOnDone` is `false`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromReadable = (options) => fromChannel$1(fromReadableChannel(options));
+/**
+* Creates a `Channel` that pulls chunks from a Node readable stream, mapping
+* errors with `onError` and destroying the readable on completion unless
+* `closeOnDone` is `false`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+var fromReadableChannel = (options) => fromTransform((_, scope) => readableToPullUnsafe({
+	scope,
+	readable: options.evaluate(),
+	onError: options.onError ?? defaultOnError,
+	chunkSize: options.chunkSize,
+	closeOnDone: options.closeOnDone
+}));
+/**
+* Consumes a Node readable stream into a string using the selected encoding,
+* failing through `onError` on stream errors or when `maxBytes` is exceeded
+* and destroying the stream on interruption or failure.
+*
+* @category converting
+* @since 4.0.0
+*/
+var toString = (readable, options) => {
+	const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : void 0;
+	const onError = options?.onError ?? defaultOnError;
+	const encoding = options?.encoding ?? "utf8";
+	return callback((resume) => {
+		const stream = readable();
+		stream.setEncoding(encoding);
+		stream.once("error", (err) => {
+			if ("closed" in stream && !stream.closed) stream.destroy();
+			resume(fail(onError(err)));
+		});
+		stream.once("error", (err) => {
+			resume(fail(onError(err)));
+		});
+		let string = "";
+		let bytes = 0;
+		stream.once("end", () => {
+			resume(succeed(string));
+		});
+		stream.on("data", (chunk) => {
+			string += chunk;
+			bytes += Buffer.byteLength(chunk);
+			if (maxBytesNumber && bytes > maxBytesNumber) resume(fail(onError(/* @__PURE__ */ new Error("maxBytes exceeded"))));
+		});
+		return sync(() => {
+			if ("closed" in stream && !stream.closed) stream.destroy();
+		});
+	});
+};
+/**
+* Consumes a Node readable stream into an `ArrayBuffer`, failing through
+* `onError` on stream errors or when `maxBytes` is exceeded and destroying the
+* stream on interruption or failure.
+*
+* @category converting
+* @since 4.0.0
+*/
+var toArrayBuffer = (readable, options) => {
+	const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : void 0;
+	const onError = options?.onError ?? defaultOnError;
+	return callback((resume) => {
+		const stream = readable();
+		const buffers = [];
+		let bytes = 0;
+		stream.once("error", (err) => {
+			if ("closed" in stream && !stream.closed) stream.destroy();
+			resume(fail(onError(err)));
+		});
+		stream.once("end", () => {
+			const buffer = buffers.length === 1 ? buffers[0] : Buffer.concat(buffers);
+			if (buffer.byteOffset === 0 && buffer.buffer.byteLength === buffer.byteLength) return resume(succeed(buffer.buffer));
+			resume(succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)));
+		});
+		stream.on("data", (chunk) => {
+			buffers.push(chunk);
+			bytes += chunk.length;
+			if (maxBytesNumber && bytes > maxBytesNumber) resume(fail(onError(/* @__PURE__ */ new Error("maxBytes exceeded"))));
+		});
+		return sync(() => {
+			if ("closed" in stream && !stream.closed) stream.destroy();
+		});
+	});
+};
+/**
+* Consumes a Node readable stream into a `Uint8Array`, using the same error
+* mapping and `maxBytes` handling as `toArrayBuffer`.
+*
+* @category converting
+* @since 4.0.0
+*/
+var toUint8Array = (readable, options) => map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer));
+var readableToPullUnsafe = (options) => {
+	const readable = options.readable;
+	const closeOnDone = options.closeOnDone ?? true;
+	const exit = options.exit ?? make$5(void 0);
+	const latch = makeUnsafe(false);
+	function onReadable() {
+		latch.openUnsafe();
+	}
+	function onError(error) {
+		exit.current = fail$1(options.onError(error));
+		latch.openUnsafe();
+	}
+	function onEnd() {
+		exit.current = fail$1(Done());
+		latch.openUnsafe();
+	}
+	readable.on("readable", onReadable);
+	readable.once("error", onError);
+	readable.once("end", onEnd);
+	const pull = suspend(function loop() {
+		let item = options.readable.read(options.chunkSize);
+		if (item === null) {
+			if (exit.current) return exit.current;
+			if (readable.readableEnded) return fail(Done());
+			latch.closeUnsafe();
+			return flatMap(latch.await, loop);
+		}
+		const chunk = of(item);
+		while (true) {
+			item = options.readable.read(options.chunkSize);
+			if (item === null) break;
+			chunk.push(item);
+		}
+		return succeed(chunk);
+	});
+	return as(addFinalizer(options.scope, sync(() => {
+		readable.off("readable", onReadable);
+		readable.off("error", onError);
+		readable.off("end", onEnd);
+		if (closeOnDone && "closed" in options.readable && !options.readable.closed) options.readable.destroy();
+	})), pull);
+};
+var defaultOnError = (error) => new UnknownError(error);
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+var toError = (error) => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));
+var toPlatformError = (method, error, command) => {
+	const { commands } = flattenCommand(command);
+	const commandStr = commands.reduce((acc, curr) => {
+		const cmd = `${curr.command} ${curr.args.join(" ")}`;
+		return acc.length === 0 ? cmd : `${acc} | ${cmd}`;
+	}, "");
+	return handleErrnoException("ChildProcess", method)(error, [commandStr]);
+};
+/**
+* Layer that provides the `NodeChildProcessSpawner` implementation.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(function* () {
+	const fs = yield* FileSystem;
+	const path = yield* Path$1;
+	const resolveWorkingDirectory = fnUntraced(function* (options) {
+		if (isUndefined(options.cwd)) return void 0;
+		yield* fs.access(options.cwd);
+		return path.resolve(options.cwd);
+	});
+	const resolveEnvironment = (options) => {
+		return options.extendEnv ? {
+			...globalThis.process.env,
+			...options.env
+		} : options.env;
+	};
+	const inputToStdioOption = (input) => isStream(input) ? "pipe" : input;
+	const outputToStdioOption = (input) => isSink(input) ? "pipe" : input;
+	const resolveStdinOption = (options) => {
+		const defaultConfig = {
+			stream: "pipe",
+			encoding: "utf-8",
+			endOnDone: true
+		};
+		if (isUndefined(options.stdin)) return defaultConfig;
+		if (typeof options.stdin === "string") return {
+			...defaultConfig,
+			stream: options.stdin
+		};
+		if (isStream(options.stdin)) return {
+			...defaultConfig,
+			stream: options.stdin
+		};
+		return {
+			stream: options.stdin.stream,
+			encoding: options.stdin.encoding ?? defaultConfig.encoding,
+			endOnDone: options.stdin.endOnDone ?? defaultConfig.endOnDone
+		};
+	};
+	const resolveOutputOption = (options, streamName) => {
+		const option = options[streamName];
+		if (isUndefined(option)) return { stream: "pipe" };
+		if (typeof option === "string") return { stream: option };
+		if (isSink(option)) return { stream: option };
+		return { stream: option.stream };
+	};
+	const resolveAdditionalFds = (options) => {
+		if (isUndefined(options.additionalFds)) return [];
+		const result = [];
+		for (const [name, config] of Object.entries(options.additionalFds)) {
+			const fd = parseFdName(name);
+			if (isNotUndefined(fd)) result.push({
+				fd,
+				config
+			});
+		}
+		return result.sort((a, b) => a.fd - b.fd);
+	};
+	const buildStdioArray = (stdinConfig, stdoutConfig, stderrConfig, additionalFds) => {
+		const stdio = [
+			inputToStdioOption(stdinConfig.stream),
+			outputToStdioOption(stdoutConfig.stream),
+			outputToStdioOption(stderrConfig.stream)
+		];
+		if (additionalFds.length === 0) return stdio;
+		const maxFd = additionalFds.reduce((max, { fd }) => Math.max(max, fd), 2);
+		for (let i = 3; i <= maxFd; i++) stdio[i] = "ignore";
+		for (const { fd } of additionalFds) stdio[fd] = "pipe";
+		return stdio;
+	};
+	const setupAdditionalFds = fnUntraced(function* (command, childProcess, additionalFds) {
+		if (additionalFds.length === 0) return {
+			getInputFd: () => drain,
+			getOutputFd: () => empty
+		};
+		const inputSinks = /* @__PURE__ */ new Map();
+		const outputStreams = /* @__PURE__ */ new Map();
+		for (const { config, fd } of additionalFds) {
+			const nodeStream = childProcess.stdio[fd];
+			switch (config.type) {
+				case "input": {
+					let sink = drain;
+					if (nodeStream && "write" in nodeStream) sink = fromWritable({
+						evaluate: () => nodeStream,
+						onError: (error) => toPlatformError(`fromWritable(fd${fd})`, toError(error), command)
+					});
+					if (config.stream) yield* forkScoped(run(config.stream, sink));
+					inputSinks.set(fd, sink);
+					break;
+				}
+				case "output": {
+					let stream = empty;
+					if (nodeStream && "read" in nodeStream) {
+						const passThrough = new PassThrough();
+						nodeStream.on("error", (error) => passThrough.destroy(error));
+						nodeStream.pipe(passThrough);
+						stream = fromReadable({
+							evaluate: () => passThrough,
+							onError: (error) => toPlatformError(`fromReadable(fd${fd})`, toError(error), command)
+						});
+					}
+					if (config.sink) stream = transduce(stream, config.sink);
+					outputStreams.set(fd, stream);
+					break;
+				}
+			}
+		}
+		return {
+			getInputFd: (fd) => inputSinks.get(fd) ?? drain,
+			getOutputFd: (fd) => outputStreams.get(fd) ?? empty
+		};
+	});
+	const setupChildStdin = (command, childProcess, config) => suspend(() => {
+		let sink = drain;
+		if (isNotNull(childProcess.stdin)) sink = fromWritable({
+			evaluate: () => childProcess.stdin,
+			onError: (error) => toPlatformError("fromWritable(stdin)", toError(error), command),
+			endOnDone: config.endOnDone,
+			encoding: config.encoding
+		});
+		if (isStream(config.stream)) return as(forkScoped(run(config.stream, sink)), sink);
+		return succeed(sink);
+	});
+	const setupChildOutputStreams = (command, childProcess, stdoutConfig, stderrConfig) => {
+		let stdout = childProcess.stdout ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stdout.on("error", (error) => passThrough.destroy(error));
+			childProcess.stdout.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
+			});
+		})() : empty;
+		let stderr = childProcess.stderr ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stderr.on("error", (error) => passThrough.destroy(error));
+			childProcess.stderr.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
+			});
+		})() : empty;
+		if (isSink(stdoutConfig.stream)) stdout = transduce(stdout, stdoutConfig.stream);
+		if (isSink(stderrConfig.stream)) stderr = transduce(stderr, stderrConfig.stream);
+		const all = merge(stdout, stderr);
+		return {
+			stdout,
+			stderr,
+			all
+		};
+	};
+	const spawn = (command, spawnOptions) => callback((resume) => {
+		const deferred = makeUnsafe$1();
+		const handle = NodeChildProcess.spawn(command.command, command.args, spawnOptions);
+		handle.on("error", (error) => {
+			resume(fail(toPlatformError("spawn", error, command)));
+		});
+		handle.on("exit", (...args) => {
+			doneUnsafe(deferred, succeed$1(args));
+		});
+		handle.on("spawn", () => {
+			resume(succeed([handle, deferred]));
+		});
+		return sync(() => {
+			handle.kill("SIGTERM");
+		});
+	});
+	const killProcessGroup = (command, childProcess, signal) => {
+		if (globalThis.process.platform === "win32") return callback((resume) => {
+			NodeChildProcess.exec(`taskkill /pid ${childProcess.pid} /T /F`, (error) => {
+				if (error) resume(fail(toPlatformError("kill", toError(error), command)));
+				else resume(void_);
+			});
+		});
+		return try_({
+			try: () => {
+				globalThis.process.kill(-childProcess.pid, signal);
+			},
+			catch: (error) => toPlatformError("kill", toError(error), command)
+		});
+	};
+	const killProcessGroupOnExit = (childProcess, signal) => {
+		if (globalThis.process.platform === "win32") {
+			NodeChildProcess.exec(`taskkill /pid ${childProcess.pid} /T /F`, () => {});
+			return;
+		}
+		try {
+			globalThis.process.kill(-childProcess.pid, signal);
+		} catch {}
+	};
+	const killProcess = (command, childProcess, signal) => suspend(() => {
+		if (!childProcess.kill(signal)) return fail(toPlatformError("kill", new globalThis.Error("Failed to kill child process"), command));
+		return void_;
+	});
+	const withTimeout = (childProcess, command, options) => (kill) => {
+		const killSignal = options?.killSignal ?? "SIGTERM";
+		return isUndefined(options?.forceKillAfter) ? kill(command, childProcess, killSignal) : timeoutOrElse(kill(command, childProcess, killSignal), {
+			duration: options.forceKillAfter,
+			orElse: () => kill(command, childProcess, "SIGKILL")
+		});
+	};
+	/**
+	* Get the appropriate source stream from a process handle based on the
+	* `from` pipe option.
+	*/
+	const getSourceStream = (handle, from) => {
+		const fromOption = from ?? "stdout";
+		switch (fromOption) {
+			case "stdout": return handle.stdout;
+			case "stderr": return handle.stderr;
+			case "all": return handle.all;
+			default: {
+				const fd = parseFdName(fromOption);
+				if (isNotUndefined(fd)) return handle.getOutputFd(fd);
+				return handle.stdout;
+			}
+		}
+	};
+	const spawnCommand = fnUntraced(function* (cmd) {
+		switch (cmd._tag) {
+			case "StandardCommand": {
+				const stdinConfig = resolveStdinOption(cmd.options);
+				const stdoutConfig = resolveOutputOption(cmd.options, "stdout");
+				const stderrConfig = resolveOutputOption(cmd.options, "stderr");
+				const resolvedAdditionalFds = resolveAdditionalFds(cmd.options);
+				let isReferenced = true;
+				const cwd = yield* resolveWorkingDirectory(cmd.options);
+				const env = resolveEnvironment(cmd.options);
+				const stdio = buildStdioArray(stdinConfig, stdoutConfig, stderrConfig, resolvedAdditionalFds);
+				const [childProcess, exitSignal] = yield* acquireRelease(spawn(cmd, {
+					cwd,
+					env,
+					stdio,
+					detached: cmd.options.detached ?? process.platform !== "win32",
+					shell: cmd.options.shell
+				}), fnUntraced(function* ([childProcess, exitSignal]) {
+					const exited = yield* isDone(exitSignal);
+					const killWithTimeout = withTimeout(childProcess, cmd, cmd.options);
+					if (exited) {
+						const [code] = yield* _await(exitSignal);
+						if (code !== 0 && isNotNull(code)) return yield* ignore(killWithTimeout(killProcessGroup));
+						return yield* void_;
+					}
+					if (!isReferenced) return yield* void_;
+					return yield* killWithTimeout((command, childProcess, signal) => catch_(killProcessGroup(command, childProcess, signal), () => killProcess(command, childProcess, signal))).pipe(andThen(_await(exitSignal)), ignore);
+				}));
+				const pid = ProcessId(childProcess.pid);
+				childProcess.on("exit", (code) => {
+					if (code !== 0 && isNotNull(code)) killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? "SIGTERM");
+				});
+				const reref = sync(() => {
+					if (!isReferenced) {
+						childProcess.ref();
+						isReferenced = true;
+					}
+				});
+				const unref = sync(() => {
+					if (isReferenced) {
+						childProcess.unref();
+						isReferenced = false;
+					}
+					return reref;
+				});
+				const stdin = yield* setupChildStdin(cmd, childProcess, stdinConfig);
+				const { all, stderr, stdout } = setupChildOutputStreams(cmd, childProcess, stdoutConfig, stderrConfig);
+				const { getInputFd, getOutputFd } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds);
+				const isRunning = map(isDone(exitSignal), (done) => !done);
+				const exitCode = flatMap(_await(exitSignal), ([code, signal]) => {
+					if (isNotNull(code)) return succeed(ExitCode(code));
+					return fail(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`), cmd));
+				});
+				const kill = (options) => {
+					return withTimeout(childProcess, cmd, options)((command, childProcess, signal) => catch_(killProcessGroup(command, childProcess, signal), () => killProcess(command, childProcess, signal))).pipe(andThen(_await(exitSignal)), asVoid);
+				};
+				return makeHandle({
+					pid,
+					exitCode,
+					isRunning,
+					kill,
+					stdin,
+					stdout,
+					stderr,
+					all,
+					getInputFd,
+					getOutputFd,
+					unref
+				});
+			}
+			case "PipedCommand": {
+				const { commands, pipeOptions } = flattenCommand(cmd);
+				const [root, ...pipeline] = commands;
+				const handles = [yield* spawnCommand(root)];
+				for (let i = 0; i < pipeline.length; i++) {
+					const command = pipeline[i];
+					const options = pipeOptions[i] ?? {};
+					const stdinConfig = resolveStdinOption(command.options);
+					const sourceStream = unwrap(succeed(getSourceStream(handles[handles.length - 1], options.from)));
+					const toOption = options.to ?? "stdin";
+					if (toOption === "stdin") handles.push(yield* spawnCommand(make$3(command.command, command.args, {
+						...command.options,
+						stdin: {
+							...stdinConfig,
+							stream: sourceStream
+						}
+					})));
+					else {
+						const fd = parseFdName(toOption);
+						if (isNotUndefined(fd)) {
+							const fdName$1 = fdName(fd);
+							const existingFds = command.options.additionalFds ?? {};
+							handles.push(yield* spawnCommand(make$3(command.command, command.args, {
+								...command.options,
+								additionalFds: {
+									...existingFds,
+									[fdName$1]: {
+										type: "input",
+										stream: sourceStream
+									}
+								}
+							})));
+						} else handles.push(yield* spawnCommand(make$3(command.command, command.args, {
+							...command.options,
+							stdin: {
+								...stdinConfig,
+								stream: sourceStream
+							}
+						})));
+					}
+				}
+				const handle = handles[handles.length - 1];
+				const unref = gen(function* () {
+					const rerefs = [];
+					for (const handle of handles) rerefs.push(yield* handle.unref);
+					return forEach([...rerefs].reverse(), (reref) => reref, { discard: true });
+				});
+				return makeHandle({
+					pid: handle.pid,
+					exitCode: handle.exitCode,
+					isRunning: handle.isRunning,
+					kill: handle.kill,
+					stdin: handle.stdin,
+					stdout: handle.stdout,
+					stderr: handle.stderr,
+					all: handle.all,
+					getInputFd: handle.getInputFd,
+					getOutputFd: handle.getOutputFd,
+					unref
+				});
+			}
+		}
+	});
+	return make$4(spawnCommand);
+}));
+/**
+* Flattens a `Command` into an array of `StandardCommand`s along with pipe
+* options for each connection.
+*
+* @category transforming
+* @since 4.0.0
+*/
+var flattenCommand = (command) => {
+	const commands = [];
+	const pipeOptions = [];
+	const flatten = (cmd) => {
+		switch (cmd._tag) {
+			case "StandardCommand":
+				commands.push(cmd);
+				break;
+			case "PipedCommand":
+				flatten(cmd.left);
+				pipeOptions.push(cmd.options);
+				flatten(cmd.right);
+				break;
+		}
+	};
+	flatten(command);
+	if (commands.length === 0) throw new Error("flattenCommand produced empty commands array");
+	const [first, ...rest] = commands;
+	return {
+		commands: [first, ...rest],
+		pipeOptions
+	};
+};
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js
+/**
+* Shared Node-compatible implementation of Effect's `FileSystem` service.
+*
+* This module adapts Node's `node:fs`, `node:os`, and `node:path` APIs into a
+* `FileSystem` layer for Effect programs running on Node-compatible runtimes.
+* Platform packages use it to provide file and directory I/O, permissions,
+* links, metadata, temporary files and directories, and file watching through
+* the shared `FileSystem` service.
+*
+* @since 4.0.0
+*/
+var handleBadArgument = (method) => (err) => badArgument({
+	module: "FileSystem",
+	method,
+	description: err.message ?? String(err)
+});
+var access = /*#__PURE__*/ (() => {
+	const nodeAccess = /*#__PURE__*/ effectify(NFS.access, /*#__PURE__*/ handleErrnoException("FileSystem", "access"), /*#__PURE__*/ handleBadArgument("access"));
+	return (path, options) => {
+		let mode = NFS.constants.F_OK;
+		if (options?.readable) mode |= NFS.constants.R_OK;
+		if (options?.writable) mode |= NFS.constants.W_OK;
+		return nodeAccess(path, mode);
+	};
+})();
+var copy = /*#__PURE__*/ (() => {
+	const nodeCp = /*#__PURE__*/ effectify(NFS.cp, /*#__PURE__*/ handleErrnoException("FileSystem", "copy"), /*#__PURE__*/ handleBadArgument("copy"));
+	return (fromPath, toPath, options) => nodeCp(fromPath, toPath, {
+		force: options?.overwrite ?? false,
+		preserveTimestamps: options?.preserveTimestamps ?? false,
+		recursive: true
+	});
+})();
+var copyFile = /*#__PURE__*/ (() => {
+	const nodeCopyFile = /*#__PURE__*/ effectify(NFS.copyFile, /*#__PURE__*/ handleErrnoException("FileSystem", "copyFile"), /*#__PURE__*/ handleBadArgument("copyFile"));
+	return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+var chmod = /*#__PURE__*/ (() => {
+	const nodeChmod = /*#__PURE__*/ effectify(NFS.chmod, /*#__PURE__*/ handleErrnoException("FileSystem", "chmod"), /*#__PURE__*/ handleBadArgument("chmod"));
+	return (path, mode) => nodeChmod(path, mode);
+})();
+var chown = /*#__PURE__*/ (() => {
+	const nodeChown = /*#__PURE__*/ effectify(NFS.chown, /*#__PURE__*/ handleErrnoException("FileSystem", "chown"), /*#__PURE__*/ handleBadArgument("chown"));
+	return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+var glob = /*#__PURE__*/ (() => {
+	const nodeGlob = /*#__PURE__*/ effectify(NFS.glob, /*#__PURE__*/ handleErrnoException("FileSystem", "glob"), /*#__PURE__*/ handleBadArgument("glob"));
+	return (pattern, options) => nodeGlob(pattern, {
+		cwd: options?.root,
+		exclude: options?.exclude
+	});
+})();
+var link = /*#__PURE__*/ (() => {
+	const nodeLink = /*#__PURE__*/ effectify(NFS.link, /*#__PURE__*/ handleErrnoException("FileSystem", "link"), /*#__PURE__*/ handleBadArgument("link"));
+	return (existingPath, newPath) => nodeLink(existingPath, newPath);
+})();
+var makeDirectory = /*#__PURE__*/ (() => {
+	const nodeMkdir = /*#__PURE__*/ effectify(NFS.mkdir, /*#__PURE__*/ handleErrnoException("FileSystem", "makeDirectory"), /*#__PURE__*/ handleBadArgument("makeDirectory"));
+	return (path, options) => nodeMkdir(path, {
+		recursive: options?.recursive ?? false,
+		mode: options?.mode
+	});
+})();
+var makeTempDirectoryFactory = (method) => {
+	const nodeMkdtemp = effectify(NFS.mkdtemp, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (options) => suspend(() => {
+		const prefix = options?.prefix ?? "";
+		const directory = typeof options?.directory === "string" ? Path.join(options.directory, ".") : OS.tmpdir();
+		return nodeMkdtemp(prefix ? Path.join(directory, prefix) : directory + "/");
+	});
+};
+var makeTempDirectory = /*#__PURE__*/ makeTempDirectoryFactory("makeTempDirectory");
+var removeFactory = (method) => {
+	const nodeRm = effectify(NFS.rm, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (path, options) => nodeRm(path, {
+		recursive: options?.recursive ?? false,
+		force: options?.force ?? false
+	});
+};
+var remove = /*#__PURE__*/ removeFactory("remove");
+var makeTempDirectoryScoped = /*#__PURE__*/ (() => {
+	const makeDirectory = /*#__PURE__*/ makeTempDirectoryFactory("makeTempDirectoryScoped");
+	const removeDirectory = /*#__PURE__*/ removeFactory("makeTempDirectoryScoped");
+	return (options) => acquireRelease(makeDirectory(options), (directory) => orDie(removeDirectory(directory, { recursive: true })));
+})();
+var openFactory = (method) => {
+	const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	return (path, options) => pipe(acquireRelease(nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie(nodeClose(fd))), map((fd) => makeFile(FileDescriptor(fd), options?.flag?.startsWith("a") ?? false)));
+};
+var open = /*#__PURE__*/ openFactory("open");
+var makeFile = /*#__PURE__*/ (() => {
+	const nodeReadFactory = (method) => effectify(NFS.read, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeRead = /*#__PURE__*/ nodeReadFactory("read");
+	const nodeReadAlloc = /*#__PURE__*/ nodeReadFactory("readAlloc");
+	const nodeStat = /*#__PURE__*/ effectify(NFS.fstat, /*#__PURE__*/ handleErrnoException("FileSystem", "stat"), /*#__PURE__*/ handleBadArgument("stat"));
+	const nodeTruncate = /*#__PURE__*/ effectify(NFS.ftruncate, /*#__PURE__*/ handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/ handleBadArgument("truncate"));
+	const nodeSync = /*#__PURE__*/ effectify(NFS.fsync, /*#__PURE__*/ handleErrnoException("FileSystem", "sync"), /*#__PURE__*/ handleBadArgument("sync"));
+	const nodeWriteFactory = (method) => effectify(NFS.write, handleErrnoException("FileSystem", method), handleBadArgument(method));
+	const nodeWrite = /*#__PURE__*/ nodeWriteFactory("write");
+	const nodeWriteAll = /*#__PURE__*/ nodeWriteFactory("writeAll");
+	class FileImpl {
+		[FileTypeId];
+		fd;
+		append;
+		position = /*#__PURE__*/ BigInt(0);
+		constructor(fd, append) {
+			this[FileTypeId] = FileTypeId;
+			this.fd = fd;
+			this.append = append;
+		}
+		get stat() {
+			return map(nodeStat(this.fd), makeFileInfo);
+		}
+		get sync() {
+			return nodeSync(this.fd);
+		}
+		seek(offset, from) {
+			const offsetSize = Size(offset);
+			return sync(() => {
+				if (from === "start") this.position = offsetSize;
+				else if (from === "current") this.position = this.position + offsetSize;
+				return this.position;
+			});
+		}
+		read(buffer) {
+			return suspend(() => {
+				const position = this.position;
+				return map(nodeRead(this.fd, {
+					buffer,
+					position
+				}), (bytesRead) => {
+					const sizeRead = Size(bytesRead);
+					this.position = position + sizeRead;
+					return sizeRead;
+				});
+			});
+		}
+		readAlloc(size) {
+			const sizeNumber = Number(size);
+			return suspend(() => {
+				const buffer = Buffer.allocUnsafeSlow(sizeNumber);
+				const position = this.position;
+				return map(nodeReadAlloc(this.fd, {
+					buffer,
+					position
+				}), (bytesRead) => {
+					if (bytesRead === 0) return none();
+					this.position = position + BigInt(bytesRead);
+					if (bytesRead === sizeNumber) return some(buffer);
+					const dst = Buffer.allocUnsafeSlow(bytesRead);
+					buffer.copy(dst, 0, 0, bytesRead);
+					return some(dst);
+				});
+			});
+		}
+		truncate(length) {
+			return map(nodeTruncate(this.fd, length ? Number(length) : void 0), () => {
+				if (!this.append) {
+					const len = BigInt(length ?? 0);
+					if (this.position > len) this.position = len;
+				}
+			});
+		}
+		write(buffer) {
+			return suspend(() => {
+				const position = this.position;
+				return map(nodeWrite(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
+					const sizeWritten = Size(bytesWritten);
+					if (!this.append) this.position = position + sizeWritten;
+					return sizeWritten;
+				});
+			});
+		}
+		writeAllChunk(buffer) {
+			return suspend(() => {
+				const position = this.position;
+				return flatMap(nodeWriteAll(this.fd, buffer, void 0, void 0, this.append ? void 0 : Number(position)), (bytesWritten) => {
+					if (bytesWritten === 0) return fail(systemError({
+						module: "FileSystem",
+						method: "writeAll",
+						_tag: "WriteZero",
+						pathOrDescriptor: this.fd,
+						description: "write returned 0 bytes written"
+					}));
+					if (!this.append) this.position = position + BigInt(bytesWritten);
+					return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : void_;
+				});
+			});
+		}
+		writeAll(buffer) {
+			return this.writeAllChunk(buffer);
+		}
+	}
+	return (fd, append) => new FileImpl(fd, append);
+})();
+var makeTempFileFactory = (method) => {
+	const makeDirectory = makeTempDirectoryFactory(method);
+	return fnUntraced(function* (options) {
+		const directory = yield* makeDirectory(options);
+		const random = Crypto.randomBytes(6).toString("hex");
+		const name = Path.join(directory, options?.suffix ? `${random}${options.suffix}` : random);
+		yield* writeFile(name, /* @__PURE__ */ new Uint8Array(0));
+		return name;
+	});
+};
+var makeTempFile = /*#__PURE__*/ makeTempFileFactory("makeTempFile");
+var makeTempFileScoped = /*#__PURE__*/ (() => {
+	const makeFile = /*#__PURE__*/ makeTempFileFactory("makeTempFileScoped");
+	const removeDirectory = /*#__PURE__*/ removeFactory("makeTempFileScoped");
+	return (options) => acquireRelease(makeFile(options), (file) => orDie(removeDirectory(Path.dirname(file), { recursive: true })));
+})();
+var readDirectory = (path, options) => tryPromise({
+	try: () => NFS.promises.readdir(path, options),
+	catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
+});
+var readFile = (path) => callback((resume, signal) => {
+	try {
+		NFS.readFile(path, { signal }, (err, data) => {
+			if (err) resume(fail(handleErrnoException("FileSystem", "readFile")(err, [path])));
+			else resume(succeed(data));
+		});
+	} catch (err) {
+		resume(fail(handleBadArgument("readFile")(err)));
+	}
+});
+var readLink = /*#__PURE__*/ (() => {
+	const nodeReadLink = /*#__PURE__*/ effectify(NFS.readlink, /*#__PURE__*/ handleErrnoException("FileSystem", "readLink"), /*#__PURE__*/ handleBadArgument("readLink"));
+	return (path) => nodeReadLink(path);
+})();
+var realPath = /*#__PURE__*/ (() => {
+	const nodeRealPath = /*#__PURE__*/ effectify(NFS.realpath, /*#__PURE__*/ handleErrnoException("FileSystem", "realPath"), /*#__PURE__*/ handleBadArgument("realPath"));
+	return (path) => nodeRealPath(path);
+})();
+var rename = /*#__PURE__*/ (() => {
+	const nodeRename = /*#__PURE__*/ effectify(NFS.rename, /*#__PURE__*/ handleErrnoException("FileSystem", "rename"), /*#__PURE__*/ handleBadArgument("rename"));
+	return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+var makeFileInfo = (stat) => ({
+	type: stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : stat.isBlockDevice() ? "BlockDevice" : stat.isCharacterDevice() ? "CharacterDevice" : stat.isFIFO() ? "FIFO" : stat.isSocket() ? "Socket" : "Unknown",
+	mtime: fromNullishOr(stat.mtime),
+	atime: fromNullishOr(stat.atime),
+	birthtime: fromNullishOr(stat.birthtime),
+	dev: stat.dev,
+	rdev: fromNullishOr(stat.rdev),
+	ino: fromNullishOr(stat.ino),
+	mode: stat.mode,
+	nlink: fromNullishOr(stat.nlink),
+	uid: fromNullishOr(stat.uid),
+	gid: fromNullishOr(stat.gid),
+	size: Size(stat.size),
+	blksize: stat.blksize !== void 0 ? some(Size(stat.blksize)) : none(),
+	blocks: fromNullishOr(stat.blocks)
+});
+var stat = /*#__PURE__*/ (() => {
+	const nodeStat = /*#__PURE__*/ effectify(NFS.stat, /*#__PURE__*/ handleErrnoException("FileSystem", "stat"), /*#__PURE__*/ handleBadArgument("stat"));
+	return (path) => map(nodeStat(path), makeFileInfo);
+})();
+var symlink = /*#__PURE__*/ (() => {
+	const nodeSymlink = /*#__PURE__*/ effectify(NFS.symlink, /*#__PURE__*/ handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/ handleBadArgument("symlink"));
+	return (target, path) => nodeSymlink(target, path);
+})();
+var truncate = /*#__PURE__*/ (() => {
+	const nodeTruncate = /*#__PURE__*/ effectify(NFS.truncate, /*#__PURE__*/ handleErrnoException("FileSystem", "truncate"), /*#__PURE__*/ handleBadArgument("truncate"));
+	return (path, length) => nodeTruncate(path, length !== void 0 ? Number(length) : void 0);
+})();
+var utimes = /*#__PURE__*/ (() => {
+	const nodeUtimes = /*#__PURE__*/ effectify(NFS.utimes, /*#__PURE__*/ handleErrnoException("FileSystem", "utime"), /*#__PURE__*/ handleBadArgument("utime"));
+	return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
+})();
+var watchNode = (path) => callback$1((queue) => acquireRelease(sync(() => {
+	const watcher = NFS.watch(path, { recursive: true }, (event, path) => {
+		if (!path) return;
+		switch (event) {
+			case "rename":
+				runFork(matchEffect(stat(path), {
+					onSuccess: (_) => offer(queue, {
+						_tag: "Create",
+						path
+					}),
+					onFailure: (_) => offer(queue, {
+						_tag: "Remove",
+						path
+					})
+				}));
+				return;
+			case "change":
+				offerUnsafe(queue, {
+					_tag: "Update",
+					path
+				});
+				return;
+		}
+	});
+	watcher.on("error", (error) => {
+		failCauseUnsafe(queue, fail$2(systemError({
+			module: "FileSystem",
+			_tag: "Unknown",
+			method: "watch",
+			pathOrDescriptor: path,
+			cause: error
+		})));
+	});
+	watcher.on("close", () => {
+		endUnsafe(queue);
+	});
+	return watcher;
+}), (watcher) => sync(() => watcher.close())));
+var watch = (backend, path) => stat(path).pipe(map((stat) => backend.pipe(flatMap$1((_) => _.register(path, stat)), getOrElse(() => watchNode(path)))), unwrap);
+var writeFile = (path, data, options) => callback((resume, signal) => {
+	try {
+		NFS.writeFile(path, data, {
+			signal,
+			flag: options?.flag,
+			mode: options?.mode
+		}, (err) => {
+			if (err) resume(fail(handleErrnoException("FileSystem", "writeFile")(err, [path])));
+			else resume(void_);
+		});
+	} catch (err) {
+		resume(fail(handleBadArgument("writeFile")(err)));
+	}
+});
+var makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$6({
+	access,
+	chmod,
+	chown,
+	copy,
+	copyFile,
+	glob,
+	link,
+	makeDirectory,
+	makeTempDirectory,
+	makeTempDirectoryScoped,
+	makeTempFile,
+	makeTempFileScoped,
+	open,
+	readDirectory,
+	readFile,
+	readLink,
+	realPath,
+	remove,
+	rename,
+	stat,
+	symlink,
+	truncate,
+	utimes,
+	watch(path) {
+		return watch(backend, path);
+	},
+	writeFile
+}));
+//#endregion
+//#region ../../node_modules/@effect/platform-node/dist/NodeFileSystem.js
+/**
+* Node.js `FileSystem` layer for programs that perform real filesystem I/O.
+*
+* The exported layer satisfies the platform-independent `FileSystem` service
+* with Node-backed operations for files, directories, metadata, permissions,
+* links, temporary paths, and path watching. Effects still call the service from
+* `effect/FileSystem`; this module only chooses the Node implementation.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the `FileSystem` service backed by Node filesystem APIs.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer$9 = /* @__PURE__ */ effect(FileSystem)(makeFileSystem);
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodeCrypto.js
+/**
+* Node-compatible implementation of Effect's `Crypto` service.
+*
+* This module builds the service from `node:crypto`, using `randomBytes` for
+* random data and `createHash` for supported digest algorithms. It exports
+* `make` as the concrete service value and `layer` for providing it through
+* Effect context.
+*
+* @since 1.0.0
+*/
+var toHashAlgorithm = (algorithm) => {
+	switch (algorithm) {
+		case "SHA-1": return "sha1";
+		case "SHA-256": return "sha256";
+		case "SHA-384": return "sha384";
+		case "SHA-512": return "sha512";
+	}
+};
+var digest = (algorithm, data) => try_({
+	try: () => Uint8Array.from(Crypto.createHash(toHashAlgorithm(algorithm)).update(data).digest()),
+	catch: (cause) => systemError({
+		module: "Crypto",
+		method: "digest",
+		_tag: "Unknown",
+		description: "Could not compute digest",
+		cause
+	})
+});
+//#endregion
+//#region ../../node_modules/@effect/platform-node/dist/NodeCrypto.js
+/**
+* The `NodeCrypto` module provides the Node.js `Crypto` service layer for
+* Effect programs. Provide {@link layer} at the edge of a Node application,
+* CLI, script, or test to satisfy `effect/Crypto` with Node's `node:crypto`
+* implementation for secure random bytes, UUID generation, random values, and
+* SHA digest operations.
+*
+* This module is the public Node adapter around the shared Node-compatible
+* implementation. Digest failures are reported as platform errors, and SHA-1
+* remains available only for interoperability with existing protocols.
+*
+* @since 1.0.0
+*/
+/**
+* Layer that provides the Node.js Crypto service implementation.
+*
+* @category layers
+* @since 1.0.0
+*/
+var layer$7 = /* @__PURE__ */ succeed$2(Crypto$1, /* @__PURE__ */ make$9({
+	randomBytes: Crypto.randomBytes,
+	digest
+}));
+//#endregion
+//#region ../../node_modules/@effect/platform-node-shared/dist/NodePath.js
+/**
+* Node-backed provider for Effect's `Path` service.
+*
+* This module turns Node's `node:path` and `node:url` APIs into `Path` layers.
+* `layer` uses the host platform path implementation, while `layerPosix` and
+* `layerWin32` provide fixed POSIX and Windows variants. All three layers also
+* include helpers for converting between file paths and file URLs.
+*
+* @since 4.0.0
+*/
+var fromFileUrl = (url) => try_({
+	try: () => NodeUrl.fileURLToPath(url),
+	catch: (cause) => new BadArgument({
+		module: "Path",
+		method: "fromFileUrl",
+		cause
+	})
+});
+var toFileUrl = (path) => try_({
+	try: () => NodeUrl.pathToFileURL(path),
+	catch: (cause) => new BadArgument({
+		module: "Path",
+		method: "toFileUrl",
+		cause
+	})
+});
+({ ...Path.posix });
+({ ...Path.win32 });
+//#endregion
+//#region ../../node_modules/@effect/platform-node/dist/NodePath.js
+/**
+* Node.js layers for Effect's `Path` service.
+*
+* This module provides the default, POSIX, and Windows variants of the
+* platform-independent `Path` service by reusing the shared Node path
+* implementation. The provided path services include Node file URL conversion
+* behavior.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the default Node `Path` service using the platform's `node:path`
+* implementation.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer$5 = /* @__PURE__ */ succeed$2(Path$1)({
+	[TypeId$1]: TypeId$1,
+	...Path,
+	fromFileUrl,
+	toFileUrl
+});
+//#endregion
+//#region ../../node_modules/@effect/platform-node/dist/NodeStdio.js
+/**
+* Node.js `Stdio` layer for the current process.
+*
+* The exported layer reuses the shared Node stdio implementation. It satisfies
+* the platform-independent `Stdio` service by reading command-line arguments
+* from `process.argv`, consuming input from `process.stdin`, and writing output
+* streams to `process.stdout` and `process.stderr`.
+*
+* @since 4.0.0
+*/
+/**
+* Provides the `Stdio` service backed by the current process arguments,
+* stdin, stdout, and stderr streams.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer$3 = /* @__PURE__ */ succeed$2(Stdio, /*#__PURE__*/ make$10({
+	args: /*#__PURE__*/ sync(() => process.argv.slice(2)),
+	stdout: (options) => fromWritable({
+		evaluate: () => process.stdout,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stdout",
+			_tag: "Unknown",
+			cause
+		}),
+		endOnDone: options?.endOnDone ?? false
+	}),
+	stderr: (options) => fromWritable({
+		evaluate: () => process.stderr,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stderr",
+			_tag: "Unknown",
+			cause
+		}),
+		endOnDone: options?.endOnDone ?? false
+	}),
+	stdin: /*#__PURE__*/ fromReadable({
+		evaluate: () => process.stdin,
+		onError: (cause) => systemError({
+			module: "Stdio",
+			method: "stdin",
+			_tag: "Unknown",
+			cause
+		}),
+		closeOnDone: false
+	})
+}));
+/**
+* Provides the default process-backed `Terminal` service, ending key input on
+* Ctrl+C or Ctrl+D.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer$2 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+	const stdin = process.stdin;
+	const stdout = process.stdout;
+	const rlRef = yield* make$7({ acquire: acquireRelease(sync(() => {
+		const rl = readline.createInterface({
+			input: stdin,
+			escapeCodeTimeout: 50
+		});
+		readline.emitKeypressEvents(stdin, rl);
+		if (stdin.isTTY) stdin.setRawMode(true);
+		return rl;
+	}), (rl) => sync(() => {
+		if (stdin.isTTY) stdin.setRawMode(false);
+		rl.close();
+	})) });
+	const columns = sync(() => stdout.columns ?? 0);
+	const rows = sync(() => stdout.rows ?? 0);
+	const readInput = gen(function* () {
+		yield* get(rlRef);
+		const queue = yield* make$8();
+		const handleKeypress = (s, k) => {
+			const userInput = {
+				input: fromUndefinedOr(s),
+				key: {
+					name: k.name ?? "",
+					ctrl: !!k.ctrl,
+					meta: !!k.meta,
+					shift: !!k.shift
+				}
+			};
+			offerUnsafe(queue, userInput);
+			if (shouldQuit(userInput)) endUnsafe(queue);
+		};
+		yield* addFinalizer$1(() => sync(() => stdin.off("keypress", handleKeypress)));
+		stdin.on("keypress", handleKeypress);
+		return queue;
+	});
+	const readLine = scoped(flatMap(get(rlRef), (readlineInterface) => callback((resume) => {
+		const onLine = (line) => resume(succeed(line));
+		readlineInterface.once("line", onLine);
+		return sync(() => readlineInterface.off("line", onLine));
+	})));
+	const display = (prompt) => uninterruptible(callback((resume) => {
+		stdout.write(prompt, (err) => isNullish(err) ? resume(void_) : resume(fail(badArgument({
+			module: "Terminal",
+			method: "display",
+			description: "Failed to write prompt to stdout",
+			cause: err
+		}))));
+	}));
+	return make$11({
+		columns,
+		rows,
+		readInput,
+		readLine,
+		display
+	});
+}))(defaultShouldQuit));
+function defaultShouldQuit(input) {
+	return input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
+}
+//#endregion
+//#region ../../node_modules/@effect/platform-node/dist/NodeServices.js
+/**
+* Provides the default Node implementations for child process spawning,
+* filesystem, path, stdio, and terminal services.
+*
+* @category layers
+* @since 4.0.0
+*/
+var layer = /*#__PURE__*/ provideMerge(layer$11, /*#__PURE__*/ mergeAll(layer$9, layer$7, layer$5, layer$3, layer$2));
+//#endregion
+export { toString as a, toArrayBuffer as i, layer$9 as n, toUint8Array as o, fromReadable as r, layer as t };
+
+//# sourceMappingURL=NodeServices-CtEw3D6F.js.map