@das-org/dascode 0.0.31

package/dist/NodeTerminal-C6yhrF1E.mjs

@@ -0,0 +1,1813 @@
+#!/usr/bin/env node
+
+import { Ar as clockWith, Cd as identity, Di as matchEffect, Eu as some, Fu as Prototype, Gi as runFork, Gr as flatMap, Gu as BaseProto, Ir as effectify, It as tag, Oo as succeed$2, Pi as orDie, Po as addFinalizer, Sa as void_, Ts as fail$2, Vi as raceFirst, Xo as doneUnsafe, Xr as forEach, Yr as fnUntraced, Za as catchDone, Zi as scoped, Zr as forever, _r as as, _s as Done, aa as suspend, ad as hasProperty, ai as ignore, cd as isNullish, cr as acquireRelease, cs as fail$1, ea as serviceOption, eu as getUnsafe, f as ErrorClass, fd as isUndefined, fr as andThen, fu as fromNullishOr, ha as try_, hs as succeed$1, ii as gen, is as makeUnsafe, kr as catch_, ma as tryPromise, mu as getOrElse, na as succeed, ns as isDone, oa as sync, od as isNotNull, pa as timeoutOrElse, pu as fromUndefinedOr, ql as Service, qo as _await, sd as isNotUndefined, ti as forkScoped, ur as addFinalizer$1, uu as flatMap$1, va as uninterruptible, vo as effect, wd as pipe, wl as of, ws as done, wu as none, xr as callback, xs as UnknownError, yi as map, yr as asVoid, zr as fail } from "./Schema-DuQUv9rO.mjs";
+import { $t as offer, At as isSink, Cn as BadArgument, D as fromChannel$1, Dn as nominal, Dt as drain, En as systemError, F as isStream, H as mkString, It as fromTransform, Jt as endUnsafe, Lt as mapDone, Q as runCollect, Qt as make$11, Tn as badArgument, V as merge, Z as run, Zt as failCauseUnsafe, _t as make$10, a as FileTypeId, c as make$9, ft as transduce, gn as makeUnsafe$1, gt as get, h as decodeText, i as FileSystem, it as splitLines, kt as fromChannel, l as callback$1, mn as make$8, mt as unwrap, n as TypeId$4, o as Size, r as FileDescriptor, s as WatchBackend, t as Path$1, tn as offerUnsafe, v as empty } from "./Path-BB53LP8h.mjs";
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
+import * as NodeCrypto 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/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/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
+*/
+const ExitCode = /*#__PURE__*/ nominal();
+/**
+* Constructs branded child process `ProcessId` values.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const ProcessId = /*#__PURE__*/ nominal();
+const HandleTypeId = "~effect/ChildProcessSpawner/ChildProcessHandle";
+const HandleProto = {
+	[HandleTypeId]: HandleTypeId,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "ChildProcessHandle",
+			pid: this.pid
+		};
+	}
+};
+/**
+* Constructs a new `ChildProcessHandle`.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const makeHandle = (params) => Object.setPrototypeOf({ ...params }, HandleProto);
+/**
+* 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
+*/
+const make$7 = (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/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/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
+*/
+const TypeId$3 = "~effect/unstable/process/ChildProcess";
+const Proto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Command",
+		evaluate(fiber) {
+			return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
+		}
+	}),
+	[TypeId$3]: TypeId$3
+};
+const 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
+*/
+const make$6 = 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);
+};
+const 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
+*/
+const 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
+*/
+const fdName = (fd) => `fd${fd}`;
+const parseTemplates = (templates, expressions) => {
+	let tokens = [];
+	for (const [index, template] of templates.entries()) tokens = parseTemplate(templates, expressions, tokens, template, index);
+	return tokens;
+};
+const 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];
+	const expressionTokens = Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)];
+	return concatTokens(nextTokens, expressionTokens, hasTrailingWhitespace);
+};
+/**
+* Convert valid expressions defined in a template string command (i.e. using
+* `${expression}` into strings.
+*/
+const parseExpression = (expression) => {
+	if (typeof expression === "string") return expression;
+	return String(expression);
+};
+const 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
+*/
+const 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).
+*/
+const 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.
+*/
+const 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/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/node_modules/@effect/platform-node-shared/dist/internal/utils.js
+/** @internal */
+const 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/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/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
+*/
+const 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
+*/
+const 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
+*/
+const 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/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const 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
+*/
+const toUint8Array = (readable, options) => map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer));
+const readableToPullUnsafe = (options) => {
+	const readable = options.readable;
+	const closeOnDone = options.closeOnDone ?? true;
+	const exit = options.exit ?? make$8(void 0);
+	const latch = makeUnsafe$1(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);
+};
+const defaultOnError = (error) => new UnknownError(error);
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+const toError = (error) => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));
+const 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
+*/
+const layer$5 = /*#__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();
+		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`, { windowsHide: true }, (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`, { windowsHide: true }, () => {});
+			return;
+		}
+		try {
+			globalThis.process.kill(-childProcess.pid, signal);
+		} catch {}
+	};
+	const killProcess = (command, childProcess, signal) => suspend(() => {
+		if (!childProcess.kill(signal)) {
+			const error = new globalThis.Error("Failed to kill child process");
+			return fail(toPlatformError("kill", error, 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,
+					...globalThis.process.platform === "win32" ? { windowsHide: true } : {}
+				}), 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) => killProcessGroup(command, childProcess, signal).pipe(catch_(() => killProcess(command, childProcess, signal)), andThen(_await(exitSignal)))).pipe(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));
+					const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);
+					return fail(toPlatformError("exitCode", error, cmd));
+				});
+				const kill = (options) => {
+					return withTimeout(childProcess, cmd, options)((command, childProcess, signal) => killProcessGroup(command, childProcess, signal).pipe(catch_(() => killProcess(command, childProcess, signal)), andThen(_await(exitSignal)))).pipe(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$6(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$6(command.command, command.args, {
+								...command.options,
+								additionalFds: {
+									...existingFds,
+									[fdName$1]: {
+										type: "input",
+										stream: sourceStream
+									}
+								}
+							})));
+						} else handles.push(yield* spawnCommand(make$6(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$7(spawnCommand);
+}));
+/**
+* Flattens a `Command` into an array of `StandardCommand`s along with pipe
+* options for each connection.
+*
+* @category transforming
+* @since 4.0.0
+*/
+const 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/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/Crypto.js
+/**
+* Defines a platform-independent service for cryptographic operations.
+*
+* Runtime packages provide concrete implementations backed by the host
+* platform's cryptography APIs. This module defines the service interface and a
+* constructor from random-byte and digest primitives. The service provides
+* secure random bytes and numbers, UUIDv4 and UUIDv7 generation, shuffling, and
+* SHA message digests.
+*
+* @since 4.0.0
+*/
+const TypeId$2 = "~effect/platform/Crypto";
+/**
+* Service tag for platform cryptography.
+*
+* **When to use**
+*
+* Use when you need to provide or retrieve the full platform cryptography
+* service from an effect's context.
+*
+* **Details**
+*
+* Providing this service supplies platform-agnostic cryptographic operations
+* such as hashing, UUID generation, and secure random values.
+*
+* @see {@link make} for constructing a Crypto service from primitive operations
+*
+* @category services
+* @since 4.0.0
+*/
+const Crypto = /*#__PURE__*/ Service("effect/Crypto");
+/**
+* Creates a `Crypto` service from the primitive implementation, deriving the
+* random generator helpers and UUID generation from those primitives.
+*
+* **When to use**
+*
+* Use to build a Crypto service for a platform integration, test layer, or
+* custom runtime from primitive random-byte and digest operations.
+*
+* **Details**
+*
+* The constructor derives random numbers, booleans, integer ranges, shuffling,
+* and UUID generation from `impl.randomBytes`. Digest operations delegate to
+* `impl.digest`.
+*
+* **Gotchas**
+*
+* `impl.randomBytes` must return cryptographically secure bytes of the
+* requested length. UUID formatting mutates the byte array returned for UUID
+* generation, so the implementation should return a fresh array for each call.
+*
+* **Example** (Creating a Crypto service)
+*
+* ```ts
+* import { Crypto, Effect, Layer } from "effect"
+*
+* const TestCrypto = Layer.succeed(
+*   Crypto.Crypto,
+*   Crypto.make({
+*     randomBytes: (size) => new Uint8Array(size),
+*     digest: (_algorithm, data) => Effect.succeed(data)
+*   })
+* )
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$4 = (impl) => {
+	const randomBytesUnsafe = impl.randomBytes;
+	const randomBytes = (size) => map(validateSize("randomBytes", size), randomBytesUnsafe);
+	const nextDoubleUnsafe = () => {
+		const bytes = randomBytesUnsafe(7);
+		return ((bytes[0] & 31) * 2 ** 48 + bytes[1] * 2 ** 40 + bytes[2] * 2 ** 32 + bytes[3] * 2 ** 24 + bytes[4] * 2 ** 16 + bytes[5] * 2 ** 8 + bytes[6]) / 2 ** 53;
+	};
+	const nextIntUnsafe = () => Math.floor(nextDoubleUnsafe() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;
+	return Crypto.of({
+		[TypeId$2]: TypeId$2,
+		randomBytes,
+		nextDoubleUnsafe,
+		nextIntUnsafe,
+		digest: impl.digest,
+		random: sync(() => nextDoubleUnsafe()),
+		randomBoolean: sync(() => nextDoubleUnsafe() > .5),
+		randomInt: sync(() => nextIntUnsafe()),
+		randomBetween: (min, max) => sync(() => nextDoubleUnsafe() * (max - min) + min),
+		randomIntBetween(min, max, options) {
+			const extra = options?.halfOpen === true ? 0 : 1;
+			return sync(() => {
+				const minInt = Math.ceil(min);
+				const maxInt = Math.floor(max);
+				return Math.floor(nextDoubleUnsafe() * (maxInt - minInt + extra)) + minInt;
+			});
+		},
+		randomShuffle: (elements) => sync(() => {
+			const buffer = Array.from(elements);
+			for (let i = buffer.length - 1; i >= 1; i = i - 1) {
+				const index = Math.min(i, Math.floor(nextDoubleUnsafe() * (i + 1)));
+				const value = buffer[i];
+				buffer[i] = buffer[index];
+				buffer[index] = value;
+			}
+			return buffer;
+		}),
+		randomUUIDv4: sync(() => formatUUIDv4(randomBytesUnsafe(16))),
+		randomUUIDv7: clockWith((clock) => succeed(formatUUIDv7(clock.currentTimeMillisUnsafe(), randomBytesUnsafe(16))))
+	});
+};
+const validateSize = (method, size) => Number.isSafeInteger(size) && size >= 0 ? succeed(size) : fail(badArgument({
+	module: "Crypto",
+	method,
+	description: "size must be a non-negative safe integer"
+}));
+const hex = (byte) => byte.toString(16).padStart(2, "0");
+const formatUUID = (bytes) => {
+	return [
+		bytes.subarray(0, 4),
+		bytes.subarray(4, 6),
+		bytes.subarray(6, 8),
+		bytes.subarray(8, 10),
+		bytes.subarray(10, 16)
+	].map((segment) => Array.from(segment, hex).join("")).join("-");
+};
+const formatUUIDv4 = (bytes) => {
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	return formatUUID(bytes);
+};
+const maxUUIDv7Timestamp = 2 ** 48 - 1;
+const formatUUIDv7 = (timestampMillis, bytes) => {
+	const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxUUIDv7Timestamp);
+	bytes[0] = Math.floor(timestamp / 2 ** 40);
+	bytes[1] = Math.floor(timestamp / 2 ** 32) & 255;
+	bytes[2] = Math.floor(timestamp / 2 ** 24) & 255;
+	bytes[3] = Math.floor(timestamp / 2 ** 16) & 255;
+	bytes[4] = Math.floor(timestamp / 2 ** 8) & 255;
+	bytes[5] = timestamp & 255;
+	bytes[6] = bytes[6] & 15 | 112;
+	bytes[8] = bytes[8] & 63 | 128;
+	return formatUUID(bytes);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/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
+*/
+const toHashAlgorithm = (algorithm) => {
+	switch (algorithm) {
+		case "SHA-1": return "sha1";
+		case "SHA-256": return "sha256";
+		case "SHA-384": return "sha384";
+		case "SHA-512": return "sha512";
+	}
+};
+const digest = (algorithm, data) => try_({
+	try: () => Uint8Array.from(NodeCrypto.createHash(toHashAlgorithm(algorithm)).update(data).digest()),
+	catch: (cause) => systemError({
+		module: "Crypto",
+		method: "digest",
+		_tag: "Unknown",
+		description: "Could not compute digest",
+		cause
+	})
+});
+/**
+* Layer that provides the Node.js Crypto service implementation.
+*
+* @category layers
+* @since 1.0.0
+*/
+const layer$4 = /*#__PURE__*/ succeed$2(Crypto, /* @__PURE__ */ make$4({
+	randomBytes: NodeCrypto.randomBytes,
+	digest
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/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
+*/
+const handleBadArgument = (method) => (err) => badArgument({
+	module: "FileSystem",
+	method,
+	description: err.message ?? String(err)
+});
+const 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);
+	};
+})();
+const 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
+	});
+})();
+const copyFile = /*#__PURE__*/ (() => {
+	const nodeCopyFile = /*#__PURE__*/ effectify(NFS.copyFile, /*#__PURE__*/ handleErrnoException("FileSystem", "copyFile"), /*#__PURE__*/ handleBadArgument("copyFile"));
+	return (fromPath, toPath) => nodeCopyFile(fromPath, toPath);
+})();
+const chmod = /*#__PURE__*/ (() => {
+	const nodeChmod = /*#__PURE__*/ effectify(NFS.chmod, /*#__PURE__*/ handleErrnoException("FileSystem", "chmod"), /*#__PURE__*/ handleBadArgument("chmod"));
+	return (path, mode) => nodeChmod(path, mode);
+})();
+const chown = /*#__PURE__*/ (() => {
+	const nodeChown = /*#__PURE__*/ effectify(NFS.chown, /*#__PURE__*/ handleErrnoException("FileSystem", "chown"), /*#__PURE__*/ handleBadArgument("chown"));
+	return (path, uid, gid) => nodeChown(path, uid, gid);
+})();
+const 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
+	});
+})();
+const link = /*#__PURE__*/ (() => {
+	const nodeLink = /*#__PURE__*/ effectify(NFS.link, /*#__PURE__*/ handleErrnoException("FileSystem", "link"), /*#__PURE__*/ handleBadArgument("link"));
+	return (existingPath, newPath) => nodeLink(existingPath, newPath);
+})();
+const 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
+	});
+})();
+const 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 + "/");
+	});
+};
+const makeTempDirectory = /*#__PURE__*/ makeTempDirectoryFactory("makeTempDirectory");
+const 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
+	});
+};
+const remove = /*#__PURE__*/ removeFactory("remove");
+const makeTempDirectoryScoped = /*#__PURE__*/ (() => {
+	const makeDirectory = /*#__PURE__*/ makeTempDirectoryFactory("makeTempDirectoryScoped");
+	const removeDirectory = /*#__PURE__*/ removeFactory("makeTempDirectoryScoped");
+	return (options) => acquireRelease(makeDirectory(options), (directory) => orDie(removeDirectory(directory, { recursive: true })));
+})();
+const 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)));
+};
+const open = /*#__PURE__*/ openFactory("open");
+const 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);
+})();
+const makeTempFileFactory = (method) => {
+	const makeDirectory = makeTempDirectoryFactory(method);
+	return fnUntraced(function* (options) {
+		const directory = yield* makeDirectory(options);
+		const random = NodeCrypto.randomBytes(6).toString("hex");
+		const name = Path.join(directory, options?.suffix ? `${random}${options.suffix}` : random);
+		yield* writeFile(name, /* @__PURE__ */ new Uint8Array(0));
+		return name;
+	});
+};
+const makeTempFile = /*#__PURE__*/ makeTempFileFactory("makeTempFile");
+const 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 })));
+})();
+const readDirectory = (path, options) => tryPromise({
+	try: () => NFS.promises.readdir(path, options),
+	catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
+});
+const 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)));
+	}
+});
+const readLink = /*#__PURE__*/ (() => {
+	const nodeReadLink = /*#__PURE__*/ effectify(NFS.readlink, /*#__PURE__*/ handleErrnoException("FileSystem", "readLink"), /*#__PURE__*/ handleBadArgument("readLink"));
+	return (path) => nodeReadLink(path);
+})();
+const realPath = /*#__PURE__*/ (() => {
+	const nodeRealPath = /*#__PURE__*/ effectify(NFS.realpath, /*#__PURE__*/ handleErrnoException("FileSystem", "realPath"), /*#__PURE__*/ handleBadArgument("realPath"));
+	return (path) => nodeRealPath(path);
+})();
+const rename = /*#__PURE__*/ (() => {
+	const nodeRename = /*#__PURE__*/ effectify(NFS.rename, /*#__PURE__*/ handleErrnoException("FileSystem", "rename"), /*#__PURE__*/ handleBadArgument("rename"));
+	return (oldPath, newPath) => nodeRename(oldPath, newPath);
+})();
+const 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)
+});
+const stat = /*#__PURE__*/ (() => {
+	const nodeStat = /*#__PURE__*/ effectify(NFS.stat, /*#__PURE__*/ handleErrnoException("FileSystem", "stat"), /*#__PURE__*/ handleBadArgument("stat"));
+	return (path) => map(nodeStat(path), makeFileInfo);
+})();
+const symlink = /*#__PURE__*/ (() => {
+	const nodeSymlink = /*#__PURE__*/ effectify(NFS.symlink, /*#__PURE__*/ handleErrnoException("FileSystem", "symlink"), /*#__PURE__*/ handleBadArgument("symlink"));
+	return (target, path) => nodeSymlink(target, path);
+})();
+const 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);
+})();
+const utimes = /*#__PURE__*/ (() => {
+	const nodeUtimes = /*#__PURE__*/ effectify(NFS.utimes, /*#__PURE__*/ handleErrnoException("FileSystem", "utime"), /*#__PURE__*/ handleBadArgument("utime"));
+	return (path, atime, mtime) => nodeUtimes(path, atime, mtime);
+})();
+const 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())));
+const watch = (backend, path) => stat(path).pipe(map((stat) => backend.pipe(flatMap$1((_) => _.register(path, stat)), getOrElse(() => watchNode(path)))), unwrap);
+const 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)));
+	}
+});
+const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$9({
+	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
+}));
+/**
+* Provides the `FileSystem` service backed by Node filesystem APIs, including
+* file operations, directory operations, links, metadata, and file watching.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$3 = /*#__PURE__*/ effect(FileSystem)(makeFileSystem);
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/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
+*/
+const fromFileUrl = (url) => try_({
+	try: () => NodeUrl.fileURLToPath(url),
+	catch: (cause) => new BadArgument({
+		module: "Path",
+		method: "fromFileUrl",
+		cause
+	})
+});
+const toFileUrl = (path) => try_({
+	try: () => NodeUrl.pathToFileURL(path),
+	catch: (cause) => new BadArgument({
+		module: "Path",
+		method: "toFileUrl",
+		cause
+	})
+});
+({ ...Path.posix });
+({ ...Path.win32 });
+/**
+* Provides the default `Path` service using the host platform's Node path
+* implementation plus file URL conversion helpers.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$2 = /*#__PURE__*/ succeed$2(Path$1)({
+	[TypeId$4]: TypeId$4,
+	...Path,
+	fromFileUrl,
+	toFileUrl
+});
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/Stdio.js
+/**
+* Service contract for command-line arguments and standard input, output, and
+* error output. It lets programs depend on standard I/O through the Effect
+* environment instead of reading from or writing to global process handles
+* directly.
+*
+* The service exposes arguments as an `Effect`, stdout and stderr as `Sink`s
+* that accept strings or bytes, and stdin as a byte `Stream`. This module also
+* provides a constructor for service values and a small test layer with
+* overridable defaults.
+*
+* @since 4.0.0
+*/
+/**
+* Runtime identifier stored on `Stdio` service implementations.
+*
+* **Details**
+*
+* This marker is part of the runtime representation of `Stdio` service
+* implementations.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$1 = "~effect/Stdio";
+/**
+* Service tag for process standard I/O.
+*
+* **When to use**
+*
+* Use when you need command-line arguments or standard I/O streams supplied by
+* an effect's environment.
+*
+* @see {@link make} for constructing a `Stdio` service directly
+* @see {@link layerTest} for a test layer with defaults and overrides
+*
+* @category services
+* @since 4.0.0
+*/
+const Stdio = /*#__PURE__*/ Service(TypeId$1);
+/**
+* Creates a `Stdio` service implementation from the provided fields and
+* attaches the `Stdio` type identifier.
+*
+* **When to use**
+*
+* Use when you need to assemble a concrete `Stdio` service from command-line
+* arguments and standard I/O implementations.
+*
+* **Details**
+*
+* The returned service reuses the supplied fields unchanged and only adds the
+* `Stdio` type identifier; it does not create a `Layer` or provide defaults.
+*
+* @see {@link layerTest} for a test layer with default fields that can be overridden
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$2 = (options) => ({
+	[TypeId$1]: TypeId$1,
+	...options
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@effect+platform-node-share_9c633f87f6fead147ad02fc5b0d67765/node_modules/@effect/platform-node-shared/dist/NodeStdio.js
+/**
+* Shared Node.js implementation of the Effect `Stdio` service.
+*
+* `NodeStdio` provides {@link Stdio.Stdio} from the current Node process. The
+* exported {@link layer} reads command-line arguments from `process.argv`,
+* consumes input from `process.stdin`, and writes normal and error output to
+* `process.stdout` and `process.stderr`. Standard input remains open, and
+* standard output and error output are not ended unless requested.
+*
+* @since 4.0.0
+*/
+/**
+* Provides `Stdio` from `process.argv`, `process.stdin`, `process.stdout`,
+* and `process.stderr`; stdin remains open and stdout/stderr are not ended by
+* default.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer$1 = /*#__PURE__*/ succeed$2(Stdio, /*#__PURE__*/ make$2({
+	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
+	})
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/Terminal.js
+const TypeId = "~effect/platform/Terminal";
+const QuitErrorTypeId = "effect/platform/Terminal/QuitError";
+/**
+* Represents an error that occurs when a user attempts to
+* quit out of a `Terminal` prompt for input (usually by entering `ctrl`+`c`).
+*
+* **When to use**
+*
+* Use when implementing terminal input or prompts that need to signal
+* user-requested cancellation through the typed error channel.
+*
+* @see {@link isQuitError} for checking unknown errors when handling terminal cancellation
+*
+* @category QuitError
+* @since 4.0.0
+*/
+var QuitError = class extends ErrorClass("QuitError")({ _tag: /*#__PURE__*/ tag("QuitError") }) {
+	/**
+	* Marks this value as a terminal quit error for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[QuitErrorTypeId] = QuitErrorTypeId;
+};
+/**
+* Returns `true` if the provided value is a `Terminal.QuitError`.
+*
+* **When to use**
+*
+* Use to narrow unknown failures to `QuitError` when handling terminal input
+* cancellation.
+*
+* **Details**
+*
+* Returns `true` when the value carries the `QuitError` runtime marker and
+* narrows it to `QuitError`.
+*
+* @see {@link QuitError} for the error value produced when terminal input is quit
+*
+* @category guards
+* @since 4.0.0
+*/
+const isQuitError = (u) => hasProperty(u, QuitErrorTypeId);
+/**
+* Service tag for command-line input and output services.
+*
+* **When to use**
+*
+* Use to access or provide platform terminal capabilities such as reading
+* input, writing output, and inspecting terminal dimensions.
+*
+* @category services
+* @since 4.0.0
+*/
+const Terminal = /*#__PURE__*/ Service("effect/platform/Terminal");
+/**
+* Creates a `Terminal` service implementation.
+*
+* **When to use**
+*
+* Use to construct a custom `Terminal` service implementation from concrete
+* terminal capabilities when writing a platform adapter, test implementation,
+* or custom runtime service.
+*
+* **Details**
+*
+* The implementation object supplies `columns`, `rows`, `readInput`,
+* `readLine`, and `display`; `make` attaches the `Terminal` service marker so
+* the result can be provided through the `Terminal` context service.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (impl) => Terminal.of({
+	...impl,
+	[TypeId]: TypeId
+});
+/**
+* Provides the default process-backed `Terminal` service, ending key input on
+* Ctrl+C or Ctrl+D.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+	const stdin = process.stdin;
+	const stdout = process.stdout;
+	const rlRef = yield* make$10({ 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$11();
+		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$1({
+		columns,
+		rows,
+		readInput,
+		readLine,
+		display
+	});
+}))(defaultShouldQuit));
+function defaultShouldQuit(input) {
+	return input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
+}
+//#endregion
+export { make$6 as _, layer$1 as a, layer$2 as c, Crypto as d, layer$5 as f, toUint8Array as g, toString as h, isQuitError as i, layer$3 as l, toArrayBuffer as m, QuitError as n, Stdio as o, fromReadable as p, Terminal as r, make$2 as s, layer as t, layer$4 as u, ChildProcessSpawner as v, ExitCode as y };
+
+//# sourceMappingURL=NodeTerminal-C6yhrF1E.mjs.map