@athrio/loom 0.0.10 → 0.0.11

package/dist/main.js

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
 import { t as __commonJSMin } from "./rolldown-runtime-YU9U6SYh.js";
-import { $ as orDie$1, $p as map$4, $t as Literal, Af as Prototype, Ah as identity, Al as taggedEnum, Bf as filter, Bs as gen, Bt as Defect, Cc as result, Dh as dual, Es as fail, Ff as dedupe, Fn as Union, Gp as fromNullishOr, H as groupedWithin, Hl as provide, Hs as interrupt, I as fromEffect, Il as effect, Kp as fromUndefinedOr, Ku as pretty, Lc as scoped, Lp as match$3, Mm as format, Mp as fail$1, Ms as forEach, N as filter$1, Nh as pipeArguments, O as concat, Os as flatMap, Qp as isSome, Qs as map$2, Ra as take, Rp as succeed$1, Uc as suspend, Vc as succeed, Vp as contains, Wc as sync, Wn as decodeUnknownEffect, Ws as isEffect, Wt as ErrorClass, Xc as tryPromise, Xp as getOrUndefined, Zc as try_, Zp as isNone, Zt as Int, _c as provideService, _f as Service, ah as hasProperty, al as void_, bc as raceFirst, cm as String$2, dc as option, dt as unwrap, ec as mapError, em as match$2, er as is, fc as orDie, fp as sort, fs as catchCause, gc as provideContext, gf as Reference, gs as catchTags, h as Path, hc as provide$1, hs as catchTag, ii as tag, ip as map$3, is as andThen, it as runForEach, jh as pipe, js as fnUntraced, kt as ArraySchema, l as FalseValues, lp as reduce, mc as promise, ms as catchFilter, oi as toCodecStringTree, op as match, ou as MinimumLogLevel, pc as orElseSucceed, q as mapEffect$1, qp as getOrElse, rm as some, s as Boolean, ss as as, tc as match$1, ti as optional$3, tm as none, u as TrueValues, uh as isNotUndefined, vn as String$1, wf as make$1, ws as ensuring, y as FileSystem, yf as empty, yn as Struct, zl as launch } from "./SqlClient-BHo_uVyk.js";
-import { N as error, P as log, _ as orElse, c as errorExitCode, i as isQuitError, l as errorReported, n as QuitError, o as Stdio, r as Terminal, u as makeRunMain, v as tag$1, y as value } from "./dist-CKhPOkpR.js";
-import { a as storeDir, c as LoomCompiler, f as PackageConfig, i as servicePackage, l as ignoredDirs, n as installedServices, o as workspaceRoot, p as LoomConfig, r as removeService, s as DocumentSource, t as addService } from "./LoomStore-BGlpRj6W.js";
-import { t as layer } from "./NodeServices-CtEw3D6F.js";
+import { $ as mkString, $n as UnknownError, $t as effectify, A as log, Ar as map$4, At as fromTransform, B as WatchBackend, Bn as mergeAll, Br as isNullish, Bt as nominal, C as errorExitCode, Cn as result, Cr as flatMap$1, Ct as decodeUnknownEffect, D as Crypto$1, Dn as succeed, Dr as getOrUndefined, Dt as toCodecStringTree, En as serviceOption, Er as getOrElse, Et as tag, F as TypeId$5, Fn as void_, Fr as BaseProto, Ft as offer, G as empty$1, Gn as MinimumLogLevel, Gr as pipeArguments, Gt as asVoid, H as callback$1, Hn as provideMerge, Hr as dual, Ht as addFinalizer$1, I as FileDescriptor, In as catchDone, Ir as format, It as offerUnsafe, J as fromEffect, Jn as isDone, Jt as catchFilter, K as filter$1, Kn as _await, Kt as callback, L as FileSystem, Ln as TaggedError, Lr as hasProperty, Lt as take, M as FalseValues, Mn as tryPromise, Mr as none, Mt as endUnsafe, N as TrueValues, Nn as try_, Nr as some, Nt as failCauseUnsafe, O as make$9, On as suspend, Or as isNone, P as Path$1, Pn as uninterruptible, Pr as String$2, Pt as make$12, Q as merge, Qn as Done, R as FileTypeId, Rn as taggedEnum, Rr as isNotNull, Rt as make$7, S as make$10, Sn as raceFirst, Sr as contains, St as Union, T as makeRunMain, Tn as scoped, Tr as fromUndefinedOr, Tt as optional$3, U as concat, Un as succeed$3, Ur as identity, Ut as andThen, V as make$8, Vn as provide, Vr as isUndefined, Vt as acquireRelease, W as decodeText, Wn as addFinalizer, Wr as pipe, Wt as as, X as isStream, Xn as fail$2, Xt as catchTags, Y as groupedWithin, Yn as makeUnsafe$1, Yt as catchTag, Z as mapEffect$1, Zn as succeed$2, Zt as catch_, _ as QuitError, _n as orDie, _r as reduce, _t as ErrorClass, a as storeDir, an as forever, ar as empty, at as transduce, b as make$13, bn as provideContext, br as match$3, bt as String$1, c as LoomCompiler, cn as ignore, cr as Prototype, ct as make$11, dt as isSink, en as ensuring, er as done, et as orDie$1, f as PackageConfig, fn as map$2, ft as BadArgument, gn as option, gr as of, gt as Defect, hn as matchEffect, hr as match, ht as ArraySchema, i as servicePackage, in as forEach, ir as Service, it as splitLines, j as Boolean, jn as timeoutOrElse, jr as match$2, jt as mapDone, k as error, kn as sync, kr as isSome, l as ignoredDirs, ln as interrupt, lr as dedupe, lt as drain, mn as match$1, mr as map$3, mt as systemError, n as installedServices, nn as flatMap, nr as pretty, nt as runCollect, o as workspaceRoot, on as forkScoped, or as getUnsafe, ot as unwrap, p as LoomConfig, pn as mapError, pt as badArgument, q as fromChannel$1, qn as doneUnsafe, qt as catchCause, r as removeService, rn as fnUntraced, rr as Reference, rt as runForEach, s as DocumentSource, sn as gen, sr as make$6, st as get, t as addService, tn as fail, tr as fail$3, tt as run$2, un as isEffect, ur as filter, ut as fromChannel, v as Terminal, vn as orElseSucceed, vr as sort, vt as Int, w as errorReported, wn as runFork, wr as fromNullishOr, wt as is, x as Stdio, xn as provideService, xr as succeed$1, xt as Struct, y as isQuitError, yn as provide$1, yr as fail$1, yt as Literal, z as Size, zn as effect, zr as isNotUndefined, zt as makeUnsafe } from "./LoomStore-DTpgIJ9l.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 { existsSync, readFileSync, writeFileSync } from "node:fs";
+import * as OS from "node:os";
+import * as Path from "node:path";
 import { dirname, relative, resolve } from "node:path";
+import * as NodeUrl from "node:url";
+import * as readline from "node:readline";
+import { createRequire } from "node:module";
 //#region ../../node_modules/effect/dist/unstable/cli/CliError.js
 /**
 * Defines structured errors for the unstable CLI parser and runner.
@@ -23,7 +29,7 @@ import { dirname, relative, resolve } from "node:path";
 * @category type IDs
 * @since 4.0.0
 */
-var TypeId$3 = "~effect/cli/CliError";
+var TypeId$4 = "~effect/cli/CliError";
 /**
 * Type guard to check if a value is a CLI error.
 *
@@ -54,7 +60,7 @@ var TypeId$3 = "~effect/cli/CliError";
 * @category guards
 * @since 4.0.0
 */
-var isCliError = (u) => hasProperty(u, TypeId$3);
+var isCliError = (u) => hasProperty(u, TypeId$4);
 /**
 * Error thrown when an unrecognized option is encountered.
 *
@@ -88,7 +94,7 @@ var isCliError = (u) => hasProperty(u, TypeId$3);
 * @category models
 * @since 4.0.0
 */
-var UnrecognizedOption = class extends ErrorClass(`${TypeId$3}/UnrecognizedOption`)({
+var UnrecognizedOption = class extends ErrorClass(`${TypeId$4}/UnrecognizedOption`)({
 	_tag: /*#__PURE__*/ tag("UnrecognizedOption"),
 	option: String$1,
 	command: /*#__PURE__*/ optional$3(/*#__PURE__*/ ArraySchema(String$1)),
@@ -99,7 +105,7 @@ var UnrecognizedOption = class extends ErrorClass(`${TypeId$3}/UnrecognizedOptio
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Formats the unrecognized option with command context and suggestions.
 	*
@@ -132,7 +138,7 @@ var UnrecognizedOption = class extends ErrorClass(`${TypeId$3}/UnrecognizedOptio
 * @category models
 * @since 4.0.0
 */
-var DuplicateOption = class extends ErrorClass(`${TypeId$3}/DuplicateOption`)({
+var DuplicateOption = class extends ErrorClass(`${TypeId$4}/DuplicateOption`)({
 	_tag: /*#__PURE__*/ tag("DuplicateOption"),
 	option: String$1,
 	parentCommand: String$1,
@@ -143,7 +149,7 @@ var DuplicateOption = class extends ErrorClass(`${TypeId$3}/DuplicateOption`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Explains which parent and child commands define the duplicate option.
 	*
@@ -183,7 +189,7 @@ var DuplicateOption = class extends ErrorClass(`${TypeId$3}/DuplicateOption`)({
 * @category models
 * @since 4.0.0
 */
-var MissingOption = class extends ErrorClass(`${TypeId$3}/MissingOption`)({
+var MissingOption = class extends ErrorClass(`${TypeId$4}/MissingOption`)({
 	_tag: /*#__PURE__*/ tag("MissingOption"),
 	option: String$1
 }) {
@@ -192,7 +198,7 @@ var MissingOption = class extends ErrorClass(`${TypeId$3}/MissingOption`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Formats the missing required flag for display.
 	*
@@ -231,7 +237,7 @@ var MissingOption = class extends ErrorClass(`${TypeId$3}/MissingOption`)({
 * @category models
 * @since 4.0.0
 */
-var MissingArgument = class extends ErrorClass(`${TypeId$3}/MissingArgument`)({
+var MissingArgument = class extends ErrorClass(`${TypeId$4}/MissingArgument`)({
 	_tag: /*#__PURE__*/ tag("MissingArgument"),
 	argument: String$1
 }) {
@@ -240,7 +246,7 @@ var MissingArgument = class extends ErrorClass(`${TypeId$3}/MissingArgument`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Formats the missing required positional argument for display.
 	*
@@ -284,7 +290,7 @@ var MissingArgument = class extends ErrorClass(`${TypeId$3}/MissingArgument`)({
 * @category models
 * @since 4.0.0
 */
-var InvalidValue = class extends ErrorClass(`${TypeId$3}/InvalidValue`)({
+var InvalidValue = class extends ErrorClass(`${TypeId$4}/InvalidValue`)({
 	_tag: /*#__PURE__*/ tag("InvalidValue"),
 	option: String$1,
 	value: String$1,
@@ -296,7 +302,7 @@ var InvalidValue = class extends ErrorClass(`${TypeId$3}/InvalidValue`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Formats the invalid flag or argument value with the expected input.
 	*
@@ -343,7 +349,7 @@ var InvalidValue = class extends ErrorClass(`${TypeId$3}/InvalidValue`)({
 * @category models
 * @since 4.0.0
 */
-var UnknownSubcommand = class extends ErrorClass(`${TypeId$3}/UnknownSubcommand`)({
+var UnknownSubcommand = class extends ErrorClass(`${TypeId$4}/UnknownSubcommand`)({
 	_tag: /*#__PURE__*/ tag("UnknownSubcommand"),
 	subcommand: String$1,
 	parent: /*#__PURE__*/ optional$3(/*#__PURE__*/ ArraySchema(String$1)),
@@ -354,7 +360,7 @@ var UnknownSubcommand = class extends ErrorClass(`${TypeId$3}/UnknownSubcommand`
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	/**
 	* Formats the unknown subcommand with parent command context and suggestions.
 	*
@@ -401,7 +407,7 @@ var UnknownSubcommand = class extends ErrorClass(`${TypeId$3}/UnknownSubcommand`
 * @category models
 * @since 4.0.0
 */
-var UserError = class extends ErrorClass(`${TypeId$3}/UserError`)({
+var UserError = class extends ErrorClass(`${TypeId$4}/UserError`)({
 	_tag: /*#__PURE__*/ tag("UserError"),
 	cause: /*#__PURE__*/ Defect()
 }) {
@@ -410,7 +416,7 @@ var UserError = class extends ErrorClass(`${TypeId$3}/UserError`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 };
 /**
 * Schema for concrete CLI errors that can be reported together with help output.
@@ -444,12 +450,12 @@ var NonShowHelpErrors = /*#__PURE__*/ Union([
 * @category models
 * @since 4.0.0
 */
-var ShowHelp = class extends ErrorClass(`${TypeId$3}/ShowHelp`)({
+var ShowHelp = class extends ErrorClass(`${TypeId$4}/ShowHelp`)({
 	_tag: /*#__PURE__*/ tag("ShowHelp"),
 	commandPath: /*#__PURE__*/ ArraySchema(String$1),
 	errors: /*#__PURE__*/ ArraySchema(NonShowHelpErrors)
 }) {
-	[TypeId$3] = TypeId$3;
+	[TypeId$4] = TypeId$4;
 	[errorExitCode] = this.errors.length ? 1 : 0;
 	[errorReported] = false;
 	get message() {
@@ -4818,14 +4824,14 @@ var require_toml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 require_ini();
 require_toml();
-var Proto$2 = { ["~effect/cli/Primitive"]: { _A: identity } };
+var Proto$3 = { ["~effect/cli/Primitive"]: { _A: identity } };
 /** @internal */
 var isTrueValue = /*#__PURE__*/ is(TrueValues);
 /** @internal */
 var isFalseValue = /*#__PURE__*/ is(FalseValues);
 /** @internal */
 var isBoolean = (p) => p._tag === "Boolean";
-var makePrimitive = (tag, parse) => Object.assign(Object.create(Proto$2), {
+var makePrimitive = (tag, parse) => Object.assign(Object.create(Proto$3), {
 	_tag: tag,
 	parse
 });
@@ -4988,7 +4994,7 @@ var choice$2 = (choices) => {
 */
 var path$1 = (pathType, mustExist) => makePrimitive("Path", fnUntraced(function* (value) {
 	const fs = yield* FileSystem;
-	const path = yield* Path;
+	const path = yield* Path$1;
 	const absolutePath = path.isAbsolute(value) ? value : path.resolve(value);
 	const exists = yield* mapError(fs.exists(absolutePath), (error) => `Failed to check path existence: ${error.message}`);
 	if (mustExist === true && !exists) return yield* fail(`Path does not exist: ${absolutePath}`);
@@ -5138,7 +5144,7 @@ var eraseLines = (rows) => {
 *
 * @since 4.0.0
 */
-var TypeId$2 = "~effect/cli/Prompt";
+var TypeId$3 = "~effect/cli/Prompt";
 var defaultFigures = {
 	arrowUp: "↑",
 	arrowDown: "↓",
@@ -5239,7 +5245,7 @@ var proto = {
 			return run$1(this);
 		}
 	}),
-	[TypeId$2]: { _Output: (_) => _ }
+	[TypeId$3]: { _Output: (_) => _ }
 };
 var runWithInput = (prompt, terminal, input) => suspend(() => {
 	const op = prompt;
@@ -5493,7 +5499,7 @@ var basePrompt = (options, type) => {
 };
 //#endregion
 //#region ../../node_modules/effect/dist/unstable/cli/Param.js
-var TypeId$1 = "~effect/cli/Param";
+var TypeId$2 = "~effect/cli/Param";
 /**
 * Defines the kind discriminator for positional argument parameters.
 *
@@ -5523,8 +5529,8 @@ var argumentKind = "argument";
 * @since 4.0.0
 */
 var flagKind = "flag";
-var Proto$1 = {
-	[TypeId$1]: { _A: identity },
+var Proto$2 = {
+	[TypeId$2]: { _A: identity },
 	pipe() {
 		return pipeArguments(this, arguments);
 	}
@@ -5547,7 +5553,7 @@ var Proto$1 = {
 * @category refinements
 * @since 4.0.0
 */
-var isParam = (u) => hasProperty(u, TypeId$1);
+var isParam = (u) => hasProperty(u, TypeId$2);
 /**
 * Type guard to check if a Single param is a flag (not an argument).
 *
@@ -5568,7 +5574,7 @@ var isFlagParam = (single) => single.kind === "flag";
 */
 var makeSingle = (params) => {
 	const parse = (args) => params.kind === "argument" ? parsePositional(params.name, params.primitiveType, args) : parseFlag(params.name, params.primitiveType, args);
-	return Object.assign(Object.create(Proto$1), {
+	return Object.assign(Object.create(Proto$2), {
 		_tag: "Single",
 		...params,
 		description: params.description ?? none(),
@@ -5856,7 +5862,7 @@ var withDescription$1 = /*#__PURE__*/ dual(2, (self, description) => {
 */
 var map$1 = /*#__PURE__*/ dual(2, (self, f) => {
 	const parse = (args) => map$2(self.parse(args), ([operands, value]) => [operands, f(value)]);
-	return Object.assign(Object.create(Proto$1), {
+	return Object.assign(Object.create(Proto$2), {
 		_tag: "Map",
 		kind: self.kind,
 		param: self,
@@ -5864,7 +5870,7 @@ var map$1 = /*#__PURE__*/ dual(2, (self, f) => {
 		parse
 	});
 });
-var transform = (self, f) => Object.assign(Object.create(Proto$1), {
+var transform = (self, f) => Object.assign(Object.create(Proto$2), {
 	_tag: "Transform",
 	kind: self.kind,
 	param: self,
@@ -5932,7 +5938,7 @@ var optional$2 = (param) => {
 			MissingArgument: () => succeed([args.arguments, none()])
 		}));
 	});
-	return Object.assign(Object.create(Proto$1), {
+	return Object.assign(Object.create(Proto$2), {
 		_tag: "Optional",
 		kind: param.kind,
 		param,
@@ -6014,7 +6020,7 @@ var variadic = (self, options) => {
 		if (single.kind === "argument") return parsePositionalVariadic(self, single, args, options);
 		else return parseOptionVariadic(self, single, args, options);
 	};
-	return Object.assign(Object.create(Proto$1), {
+	return Object.assign(Object.create(Proto$2), {
 		_tag: "Variadic",
 		kind: self.kind,
 		param: self,
@@ -7323,13 +7329,13 @@ var reconstructTree = (tree, results) => {
 * Internal implementation details for CLI commands.
 * Public API is in ../Command.ts
 */
-var TypeId = "~effect/cli/Command";
+var TypeId$1 = "~effect/cli/Command";
 /**
 * Casts a Command to its internal implementation.
 * For use by internal modules that need access to config, parse, handle, etc.
 */
 var toImpl = (self) => self;
-var Proto = { .../*#__PURE__*/ Prototype({
+var Proto$1 = { .../*#__PURE__*/ Prototype({
 	label: "Command",
 	evaluate() {
 		return toImpl(this).service;
@@ -7404,8 +7410,8 @@ var makeCommand = (options) => {
 			...examples.length > 0 && { examples }
 		};
 	};
-	return Object.assign(Object.create(Proto), {
-		[TypeId]: TypeId,
+	return Object.assign(Object.create(Proto$1), {
+		[TypeId$1]: TypeId$1,
 		name: options.name,
 		examples: options.examples ?? [],
 		annotations,
@@ -8466,7 +8472,7 @@ var scanCommandLevel = (tokens, context) => {
 * @category guards
 * @since 4.0.0
 */
-var isCommand = (u) => hasProperty(u, TypeId);
+var isCommand = (u) => hasProperty(u, TypeId$1);
 /**
 * Creates a `Command` from a name, an optional configuration, and an optional
 * handler.
@@ -8524,7 +8530,7 @@ var isCommand = (u) => hasProperty(u, TypeId);
 * @category constructors
 * @since 4.0.0
 */
-var make = (name, config, handler) => {
+var make$5 = (name, config, handler) => {
 	return makeCommand({
 		name,
 		config: parseConfig(config ?? {}),
@@ -8817,12 +8823,1483 @@ var runWith = (command, config) => {
 		program = provideService(program, LogLevel, logLevel);
 		const services = match$2(logLevel, {
 			onNone: () => empty(),
-			onSome: (level) => make$1(MinimumLogLevel, level)
+			onSome: (level) => make$6(MinimumLogLevel, level)
 		});
 		yield* provideContext(program, services);
 	}, catchFilter((error) => isCliError(error) && error._tag === "ShowHelp" ? succeed$1(error) : fail$1(error), (error) => andThen(showHelp(command, error), fail(error))), catchFilter((e) => isQuitError(e) ? succeed$1(e) : fail$1(e), (_) => interrupt));
 };
 //#endregion
+//#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$2((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
+}));
+var readableToPullUnsafe = (options) => {
+	const readable = options.readable;
+	const closeOnDone = options.closeOnDone ?? true;
+	const exit = options.exit ?? make$7(void 0);
+	const latch = makeUnsafe(false);
+	function onReadable() {
+		latch.openUnsafe();
+	}
+	function onError(error) {
+		exit.current = fail$2(options.onError(error));
+		latch.openUnsafe();
+	}
+	function onEnd() {
+		exit.current = fail$2(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$1
+		};
+		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$2(config.stream, sink));
+					inputSinks.set(fd, sink);
+					break;
+				}
+				case "output": {
+					let stream = empty$1;
+					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$1
+		};
+	});
+	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$2(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$1;
+		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$1;
+		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$2(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$2(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$1 = /*#__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$2((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$2(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$2(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$2(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$2(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$2(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$2(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$3(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$2((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$2(/*#__PURE__*/ serviceOption(WatchBackend), (backend) => make$8({
+	access,
+	chmod,
+	chown,
+	copy,
+	copyFile,
+	glob,
+	link,
+	makeDirectory,
+	makeTempDirectory,
+	makeTempDirectoryScoped,
+	makeTempFile,
+	makeTempFileScoped,
+	open,
+	readDirectory,
+	readFile,
+	readLink,
+	realPath,
+	remove: remove$1,
+	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$3(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$3(Path$1)({
+	[TypeId$5]: TypeId$5,
+	...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$3(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$11({ 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$12();
+		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$13({
+		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
 //#region ../../node_modules/@effect/platform-node/dist/NodeRuntime.js
 /**
 * Node.js process runner for Effect programs.
@@ -8995,7 +10472,7 @@ var tangleWatch = (file) => gen(function* () {
 	yield* log(`loom: watching ${file} — re-tangling on change`);
 	yield* runForEach(tangler.watch(resolve(process.cwd(), file)), match$3({
 		onSuccess: reportWritten,
-		onFailure: (error$2) => error(error$2.message)
+		onFailure: (error$1) => error(error$1.message)
 	}));
 });
 var tangle = (file, watch) => watch ? tangleWatch(file) : tangleOnce(file);
@@ -9070,7 +10547,7 @@ var add = (language) => gen(function* () {
 	yield* addService(language, dir);
 	yield* updateLanguages(config, dir, (ids) => [.../* @__PURE__ */ new Set([...ids, language])]);
 	yield* log(`\n   ${teal("✓")} activated ${language}\n   ${dim(`store: ${storeDir(dir)}`)}\n`);
-}).pipe(catchTag("StoreError", (error$1) => error(`loom: could not install ${servicePackage(error$1.id)} — ${String(error$1.cause)}`).pipe(andThen(sync(() => void (process.exitCode = 1))))));
+}).pipe(catchTag("StoreError", (error$2) => error(`loom: could not install ${servicePackage(error$2.id)} — ${String(error$2.cause)}`).pipe(andThen(sync(() => void (process.exitCode = 1))))));
 var remove = (language) => gen(function* () {
 	const config = yield* LoomConfig;
 	const dir = process.cwd();
@@ -9115,71 +10592,49 @@ var set = (name, value) => gen(function* () {
 	const corpus = resolve(workspace, current?.corpus ?? "corpus");
 	yield* log(`loom: set ${name} = ${value} (re-tangled ${(yield* tangler.tangle(corpus)).length} files)`);
 }).pipe(catchTag("TangleError", (e) => error(e.message).pipe(andThen(sync(() => void (process.exitCode = 1))))));
-var PORT_ONLY = /^[0-9]+$/;
-var HAS_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
-var addressOf = (given) => HAS_SCHEME.test(given) ? given : PORT_ONLY.test(given) ? `http://localhost:${given}` : `http://${given}`;
-var within = (one, other) => one === other || one.startsWith(`${other}/`) || other.startsWith(`${one}/`);
-var refusalOf = (standing, project, directory) => value(standing).pipe(tag$1("Taken", () => some(`loom: \`${project}\` is registered to another project, and its notes point elsewhere.\n      This directory is ${directory}.\n      Run Design here under a different name, or run it in the directory that owns \`${project}\`.`)), tag$1("Misplaced", () => some(`loom: \`${project}\` is registered, but ${directory} carries no identity for it.\n      This is almost always the wrong directory. Run Design from the project it names.`)), orElse(() => none()));
-var design = (project, given, port) => {
-	const application = addressOf(given);
-	return gen(function* () {
-		const directory = process.cwd();
-		yield* promise(async () => {
-			const { createRequire } = await import("node:module");
-			const scope = globalThis;
-			scope.require = scope.require ?? createRequire(import.meta.url);
-		});
-		const proxy = yield* tryPromise(() => import("./design-S_129JVC.js"));
-		const kept = yield* tryPromise(() => import("./store-CtvrwAS8.js"));
-		const projects = yield* tryPromise(() => import("./identity-DvFsrt2d.js"));
-		const store = kept.localStore();
-		yield* match$2(refusalOf(yield* projects.settle({
-			project,
-			directory,
-			address: application,
-			store
-		}), project, directory), {
-			onSome: (message) => error(message).pipe(andThen(sync(() => void (process.exitCode = 1)))),
-			onNone: () => gen(function* () {
-				yield* match$2(yield* projects.servedFrom(application), {
-					onNone: () => void_,
-					onSome: (from) => within(from, directory) ? void_ : error(`loom: warning — the server on ${application} is running in ${from}, not in ${directory}`)
-				});
-				yield* log(`loom: Design on http://localhost:${port}, in front of ${application}, noting ${project} in ${directory}`);
-				yield* launch(proxy.designServer({
-					port,
-					application,
-					project,
-					store
-				}));
-			})
-		});
-	}).pipe(catchCause((cause) => error(`loom: Design could not run in front of ${application}\n${pretty(cause)}`).pipe(andThen(sync(() => void (process.exitCode = 1))))));
-};
-var tangleCommand = make("tangle", {
+var DesignMissing = class extends TaggedError("DesignMissing") {};
+var manifestOf = (base) => try_(() => createRequire(base).resolve("@athrio/loom-design/package.json"));
+var designBinary = gen(function* () {
+	const directory = process.cwd();
+	return resolve(dirname(yield* manifestOf(resolve(directory, "index.js")).pipe(catch_(() => manifestOf(import.meta.url)), mapError(() => new DesignMissing({ directory })))), "dist", "loom-design.js");
+});
+var design = (project, application, port) => gen(function* () {
+	const code = yield* scoped(flatMap(make$3(yield* designBinary, [
+		project,
+		application,
+		"--port",
+		String(port)
+	], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit"
+	}), (running) => running.exitCode));
+	yield* sync(() => void (process.exitCode = code));
+}).pipe(catchTag("DesignMissing", () => error("loom: Loom Design is not installed.\n      Add it with `bun add -d @athrio/loom-design`, then run this again.").pipe(andThen(sync(() => void (process.exitCode = 1))))), catchCause((cause) => error(`loom: Loom Design could not start\n${pretty(cause)}`).pipe(andThen(sync(() => void (process.exitCode = 1))))));
+var tangleCommand = make$5("tangle", {
 	path: string("path"),
 	watch: boolean("watch")
 }, ({ path, watch }) => tangle(path, watch));
-var orphansCommand = make("orphans", { prune: boolean("prune") }, ({ prune }) => orphans(prune));
-var weaveCommand = make("weave", {
+var orphansCommand = make$5("orphans", { prune: boolean("prune") }, ({ prune }) => orphans(prune));
+var weaveCommand = make$5("weave", {
 	path: string("path"),
 	out: string("out")
 }, ({ path, out }) => weave(path, out));
-var tocCommand = make("toc", { path: string("path") }, ({ path }) => toc(path));
-var initCommand = make("init", { dir: optional$1(directory("dir")) }, ({ dir }) => init(dir));
-var addCommand = make("add", { language: string("language") }, ({ language }) => add(language));
-var removeCommand = make("remove", { language: string("language") }, ({ language }) => remove(language));
-var statusCommand = make("status", {}, () => status);
-var setCommand = make("set", {
+var tocCommand = make$5("toc", { path: string("path") }, ({ path }) => toc(path));
+var initCommand = make$5("init", { dir: optional$1(directory("dir")) }, ({ dir }) => init(dir));
+var addCommand = make$5("add", { language: string("language") }, ({ language }) => add(language));
+var removeCommand = make$5("remove", { language: string("language") }, ({ language }) => remove(language));
+var statusCommand = make$5("status", {}, () => status);
+var setCommand = make$5("set", {
 	name: string("name"),
 	value: string("value")
 }, ({ name, value }) => set(name, value));
-var designCommand = make("design", {
+var designCommand = make$5("design", {
 	project: string("name"),
 	application: string("address"),
 	port: integer("port").pipe(withDefault(5710))
 }, ({ project, application, port }) => design(project, application, port));
-var program = run(make("loom").pipe(withSubcommands([
+var program = run(make$5("loom").pipe(withSubcommands([
 	tangleCommand,
 	orphansCommand,
 	weaveCommand,
@@ -9190,11 +10645,10 @@ var program = run(make("loom").pipe(withSubcommands([
 	statusCommand,
 	setCommand,
 	designCommand
-])), { version: "0.0.10" }).pipe(provide$1(LoomTangler.layer), provide$1(LoomWeaver.layer), provide$1(LoomContents.layer), provide$1(DocumentSource.layer), provide$1(PackageConfig.layer), provide$1(LoomConfig.layer), provide$1(layer));
+])), { version: "0.0.11" }).pipe(provide$1(LoomTangler.layer), provide$1(LoomWeaver.layer), provide$1(LoomContents.layer), provide$1(DocumentSource.layer), provide$1(PackageConfig.layer), provide$1(LoomConfig.layer), provide$1(layer));
 if (process.argv[2] === "lsp") {
-	const { createRequire } = await import("node:module");
 	globalThis.require = createRequire(import.meta.url);
-	const { startLanguageServer } = await import("./LoomServer-JbCtLtxV.js");
+	const { startLanguageServer } = await import("./LoomServer-mL8VcuCS.js");
 	startLanguageServer();
 } else runMain(program);
 //#endregion