@athrio/loom 0.0.8 → 0.0.10

package/dist/main.js

@@ -1,16 +1,11 @@
 #!/usr/bin/env node
 import { t as __commonJSMin } from "./rolldown-runtime-YU9U6SYh.js";
-import { $ as mkString, $n as done, $t as ensuring, A as log, An as timeoutOrElse, Ar as none, At as mapDone, B as WatchBackend, Bn as provide, Br as dual, Bt as acquireRelease, C as errorExitCode, Cn as runFork, Cr as fromUndefinedOr, Ct as is, D as Crypto$1, Dn as suspend, Dr as isSome, En as succeed, Er as isNone, Et as toCodecStringTree, F as TypeId$5, Fn as catchDone, Fr as hasProperty, Ft as offerUnsafe, G as empty$1, Gn as _await, Gt as callback, H as callback$1, Hn as succeed$3, Hr as pipe, Ht as andThen, I as FileDescriptor, Ir as isNotNull, It as take, J as fromEffect, Jn as makeUnsafe$1, Jt as catchTag, K as filter$1, Kn as doneUnsafe, L as FileSystem, Ln as taggedEnum, Lr as isNotUndefined, Lt as make$7, M as FalseValues, Mn as try_, Mr as String$2, Mt as failCauseUnsafe, N as TrueValues, Nn as uninterruptible, Nr as BaseProto, Nt as make$12, O as make$9, On as sync, Or as map$4, P as Path$1, Pn as void_, Pr as format, Pt as offer, Q as merge, Qn as UnknownError, Qt as effectify, R as FileTypeId, Rn as effect, Rr as isNullish, Rt as makeUnsafe, S as make$10, Sn as result, Sr as fromNullishOr, St as decodeUnknownEffect, T as makeRunMain, Tn as serviceOption, Tr as getOrUndefined, Tt as tag, U as concat, Un as addFinalizer, Ur as pipeArguments, Ut as as, V as make$8, Vn as provideMerge, Vr as identity, Vt as addFinalizer$1, W as decodeText, Wn as MinimumLogLevel, Wt as asVoid, X as isStream, Xn as succeed$2, Xt as catch_, Y as groupedWithin, Yn as fail$2, Yt as catchTags, Z as mapEffect, Zn as Done, _ as QuitError, _n as orElseSucceed, _r as fail$1, _t as ErrorClass, a as storeDir, an as forkScoped, ar as make$6, at as transduce, b as make$13, bn as provideService, br as contains, bt as Struct, c as LoomCompiler, cn as interrupt, cr as filter, ct as make$11, dn as map$2, dt as isSink, en as fail, er as fail$3, et as orDie$1, f as PackageConfig, fn as mapError, fr as map$3, ft as BadArgument, gn as orDie, gr as sort, gt as Defect, hn as option, hr as reduce, ht as ArraySchema, i as servicePackage, in as forever, ir as getUnsafe, it as splitLines, j as Boolean, jn as tryPromise, jr as some, jt as endUnsafe, k as error, kr as match$2, kt as fromTransform, l as ignoredDirs, ln as isEffect, lt as drain, mn as matchEffect, mr as of, mt as systemError, n as installedServices, nn as fnUntraced, nr as Service, nt as runCollect, o as workspaceRoot, on as gen, or as Prototype, ot as unwrap, p as LoomConfig, pn as match$1, pr as match, pt as badArgument, q as fromChannel$1, qn as isDone, qt as catchFilter, r as removeService, rn as forEach, rr as empty, rt as runForEach, s as DocumentSource, sn as ignore, sr as dedupe, st as get, t as addService, tn as flatMap, tr as Reference, tt as run$2, ut as fromChannel, v as Terminal, vn as provide$1, vr as match$3, vt as Literal, w as errorReported, wn as scoped, wr as getOrElse, wt as optional$3, x as Stdio, xn as raceFirst, xr as flatMap$1, xt as Union, y as isQuitError, yn as provideContext, yr as succeed$1, yt as String$1, z as Size, zn as mergeAll, zr as isUndefined, zt as nominal } from "./LoomStore-C2tWuEsJ.js";
-import * as NodeChildProcess from "node:child_process";
-import { PassThrough } from "node:stream";
-import * as Crypto from "node:crypto";
-import * as NFS from "node:fs";
+import { $ as 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 { 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";
 //#region ../../node_modules/effect/dist/unstable/cli/CliError.js
 /**
 * Defines structured errors for the unstable CLI parser and runner.
@@ -28,7 +23,7 @@ import * as readline from "node:readline";
 * @category type IDs
 * @since 4.0.0
 */
-var TypeId$4 = "~effect/cli/CliError";
+var TypeId$3 = "~effect/cli/CliError";
 /**
 * Type guard to check if a value is a CLI error.
 *
@@ -59,7 +54,7 @@ var TypeId$4 = "~effect/cli/CliError";
 * @category guards
 * @since 4.0.0
 */
-var isCliError = (u) => hasProperty(u, TypeId$4);
+var isCliError = (u) => hasProperty(u, TypeId$3);
 /**
 * Error thrown when an unrecognized option is encountered.
 *
@@ -93,7 +88,7 @@ var isCliError = (u) => hasProperty(u, TypeId$4);
 * @category models
 * @since 4.0.0
 */
-var UnrecognizedOption = class extends ErrorClass(`${TypeId$4}/UnrecognizedOption`)({
+var UnrecognizedOption = class extends ErrorClass(`${TypeId$3}/UnrecognizedOption`)({
 	_tag: /*#__PURE__*/ tag("UnrecognizedOption"),
 	option: String$1,
 	command: /*#__PURE__*/ optional$3(/*#__PURE__*/ ArraySchema(String$1)),
@@ -104,7 +99,7 @@ var UnrecognizedOption = class extends ErrorClass(`${TypeId$4}/UnrecognizedOptio
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Formats the unrecognized option with command context and suggestions.
 	*
@@ -137,7 +132,7 @@ var UnrecognizedOption = class extends ErrorClass(`${TypeId$4}/UnrecognizedOptio
 * @category models
 * @since 4.0.0
 */
-var DuplicateOption = class extends ErrorClass(`${TypeId$4}/DuplicateOption`)({
+var DuplicateOption = class extends ErrorClass(`${TypeId$3}/DuplicateOption`)({
 	_tag: /*#__PURE__*/ tag("DuplicateOption"),
 	option: String$1,
 	parentCommand: String$1,
@@ -148,7 +143,7 @@ var DuplicateOption = class extends ErrorClass(`${TypeId$4}/DuplicateOption`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Explains which parent and child commands define the duplicate option.
 	*
@@ -188,7 +183,7 @@ var DuplicateOption = class extends ErrorClass(`${TypeId$4}/DuplicateOption`)({
 * @category models
 * @since 4.0.0
 */
-var MissingOption = class extends ErrorClass(`${TypeId$4}/MissingOption`)({
+var MissingOption = class extends ErrorClass(`${TypeId$3}/MissingOption`)({
 	_tag: /*#__PURE__*/ tag("MissingOption"),
 	option: String$1
 }) {
@@ -197,7 +192,7 @@ var MissingOption = class extends ErrorClass(`${TypeId$4}/MissingOption`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Formats the missing required flag for display.
 	*
@@ -236,7 +231,7 @@ var MissingOption = class extends ErrorClass(`${TypeId$4}/MissingOption`)({
 * @category models
 * @since 4.0.0
 */
-var MissingArgument = class extends ErrorClass(`${TypeId$4}/MissingArgument`)({
+var MissingArgument = class extends ErrorClass(`${TypeId$3}/MissingArgument`)({
 	_tag: /*#__PURE__*/ tag("MissingArgument"),
 	argument: String$1
 }) {
@@ -245,7 +240,7 @@ var MissingArgument = class extends ErrorClass(`${TypeId$4}/MissingArgument`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Formats the missing required positional argument for display.
 	*
@@ -289,7 +284,7 @@ var MissingArgument = class extends ErrorClass(`${TypeId$4}/MissingArgument`)({
 * @category models
 * @since 4.0.0
 */
-var InvalidValue = class extends ErrorClass(`${TypeId$4}/InvalidValue`)({
+var InvalidValue = class extends ErrorClass(`${TypeId$3}/InvalidValue`)({
 	_tag: /*#__PURE__*/ tag("InvalidValue"),
 	option: String$1,
 	value: String$1,
@@ -301,7 +296,7 @@ var InvalidValue = class extends ErrorClass(`${TypeId$4}/InvalidValue`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Formats the invalid flag or argument value with the expected input.
 	*
@@ -348,7 +343,7 @@ var InvalidValue = class extends ErrorClass(`${TypeId$4}/InvalidValue`)({
 * @category models
 * @since 4.0.0
 */
-var UnknownSubcommand = class extends ErrorClass(`${TypeId$4}/UnknownSubcommand`)({
+var UnknownSubcommand = class extends ErrorClass(`${TypeId$3}/UnknownSubcommand`)({
 	_tag: /*#__PURE__*/ tag("UnknownSubcommand"),
 	subcommand: String$1,
 	parent: /*#__PURE__*/ optional$3(/*#__PURE__*/ ArraySchema(String$1)),
@@ -359,7 +354,7 @@ var UnknownSubcommand = class extends ErrorClass(`${TypeId$4}/UnknownSubcommand`
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	/**
 	* Formats the unknown subcommand with parent command context and suggestions.
 	*
@@ -406,7 +401,7 @@ var UnknownSubcommand = class extends ErrorClass(`${TypeId$4}/UnknownSubcommand`
 * @category models
 * @since 4.0.0
 */
-var UserError = class extends ErrorClass(`${TypeId$4}/UserError`)({
+var UserError = class extends ErrorClass(`${TypeId$3}/UserError`)({
 	_tag: /*#__PURE__*/ tag("UserError"),
 	cause: /*#__PURE__*/ Defect()
 }) {
@@ -415,7 +410,7 @@ var UserError = class extends ErrorClass(`${TypeId$4}/UserError`)({
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 };
 /**
 * Schema for concrete CLI errors that can be reported together with help output.
@@ -449,12 +444,12 @@ var NonShowHelpErrors = /*#__PURE__*/ Union([
 * @category models
 * @since 4.0.0
 */
-var ShowHelp = class extends ErrorClass(`${TypeId$4}/ShowHelp`)({
+var ShowHelp = class extends ErrorClass(`${TypeId$3}/ShowHelp`)({
 	_tag: /*#__PURE__*/ tag("ShowHelp"),
 	commandPath: /*#__PURE__*/ ArraySchema(String$1),
 	errors: /*#__PURE__*/ ArraySchema(NonShowHelpErrors)
 }) {
-	[TypeId$4] = TypeId$4;
+	[TypeId$3] = TypeId$3;
 	[errorExitCode] = this.errors.length ? 1 : 0;
 	[errorReported] = false;
 	get message() {
@@ -4823,14 +4818,14 @@ var require_toml = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 }));
 require_ini();
 require_toml();
-var Proto$3 = { ["~effect/cli/Primitive"]: { _A: identity } };
+var Proto$2 = { ["~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$3), {
+var makePrimitive = (tag, parse) => Object.assign(Object.create(Proto$2), {
 	_tag: tag,
 	parse
 });
@@ -4873,6 +4868,31 @@ var makeSchemaPrimitive = (tag, schema) => {
 */
 var boolean$2 = /*#__PURE__*/ makeSchemaPrimitive("Boolean", Boolean);
 /**
+* Creates a primitive that parses integer numbers from string input.
+*
+* **Example** (Parsing integer values)
+*
+* ```ts
+* import { Effect } from "effect"
+* import { Primitive } from "effect/unstable/cli"
+*
+* const parseInteger = Effect.gen(function*() {
+*   const result1 = yield* Primitive.integer.parse("42")
+*   console.log(result1) // 42
+*
+*   const result2 = yield* Primitive.integer.parse("-123")
+*   console.log(result2) // -123
+*
+*   const result3 = yield* Primitive.integer.parse("0")
+*   console.log(result3) // 0
+* })
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+var integer$2 = /*#__PURE__*/ makeSchemaPrimitive("Integer", Int);
+/**
 * Creates a primitive that accepts any string value without validation.
 *
 * **Example** (Parsing string values)
@@ -4968,7 +4988,7 @@ var choice$2 = (choices) => {
 */
 var path$1 = (pathType, mustExist) => makePrimitive("Path", fnUntraced(function* (value) {
 	const fs = yield* FileSystem;
-	const path = yield* Path$1;
+	const path = yield* Path;
 	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}`);
@@ -5118,7 +5138,7 @@ var eraseLines = (rows) => {
 *
 * @since 4.0.0
 */
-var TypeId$3 = "~effect/cli/Prompt";
+var TypeId$2 = "~effect/cli/Prompt";
 var defaultFigures = {
 	arrowUp: "↑",
 	arrowDown: "↓",
@@ -5219,7 +5239,7 @@ var proto = {
 			return run$1(this);
 		}
 	}),
-	[TypeId$3]: { _Output: (_) => _ }
+	[TypeId$2]: { _Output: (_) => _ }
 };
 var runWithInput = (prompt, terminal, input) => suspend(() => {
 	const op = prompt;
@@ -5473,7 +5493,7 @@ var basePrompt = (options, type) => {
 };
 //#endregion
 //#region ../../node_modules/effect/dist/unstable/cli/Param.js
-var TypeId$2 = "~effect/cli/Param";
+var TypeId$1 = "~effect/cli/Param";
 /**
 * Defines the kind discriminator for positional argument parameters.
 *
@@ -5503,8 +5523,8 @@ var argumentKind = "argument";
 * @since 4.0.0
 */
 var flagKind = "flag";
-var Proto$2 = {
-	[TypeId$2]: { _A: identity },
+var Proto$1 = {
+	[TypeId$1]: { _A: identity },
 	pipe() {
 		return pipeArguments(this, arguments);
 	}
@@ -5527,7 +5547,7 @@ var Proto$2 = {
 * @category refinements
 * @since 4.0.0
 */
-var isParam = (u) => hasProperty(u, TypeId$2);
+var isParam = (u) => hasProperty(u, TypeId$1);
 /**
 * Type guard to check if a Single param is a flag (not an argument).
 *
@@ -5548,7 +5568,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$2), {
+	return Object.assign(Object.create(Proto$1), {
 		_tag: "Single",
 		...params,
 		description: params.description ?? none(),
@@ -5609,6 +5629,31 @@ var boolean$1 = (kind, name) => makeSingle({
 	kind
 });
 /**
+* Creates an integer parameter.
+*
+* **Example** (Creating integer parameters)
+*
+* ```ts
+* import { Param } from "effect/unstable/cli"
+*
+* // Create an integer flag
+* const portFlag = Param.integer(Param.flagKind, "port")
+*
+* // Create an integer argument
+* const countArg = Param.integer(Param.argumentKind, "count")
+*
+* // Usage in CLI: --port 8080 or as positional argument: 42
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+var integer$1 = (kind, name) => makeSingle({
+	name,
+	primitiveType: integer$2,
+	kind
+});
+/**
 * Constructs command-line params that represent a choice between several
 * inputs. The input will be mapped to it's associated value during parsing.
 *
@@ -5811,7 +5856,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$2), {
+	return Object.assign(Object.create(Proto$1), {
 		_tag: "Map",
 		kind: self.kind,
 		param: self,
@@ -5819,7 +5864,7 @@ var map$1 = /*#__PURE__*/ dual(2, (self, f) => {
 		parse
 	});
 });
-var transform = (self, f) => Object.assign(Object.create(Proto$2), {
+var transform = (self, f) => Object.assign(Object.create(Proto$1), {
 	_tag: "Transform",
 	kind: self.kind,
 	param: self,
@@ -5827,6 +5872,35 @@ var transform = (self, f) => Object.assign(Object.create(Proto$2), {
 	parse: f(self.parse)
 });
 /**
+* Transforms the parsed value of an option using an effectful mapping function.
+*
+* **Example** (Mapping parsed values effectfully)
+*
+* ```ts
+* import { Effect } from "effect"
+* import { CliError, Param } from "effect/unstable/cli"
+*
+* const validatedEmail = Param.string(Param.flagKind, "email").pipe(
+*   Param.mapEffect((email) =>
+*     email.includes("@")
+*       ? Effect.succeed(email)
+*       : Effect.fail(
+*         new CliError.InvalidValue({
+*           option: "email",
+*           value: email,
+*           expected: "valid email format",
+*           kind: "flag"
+*         })
+*       )
+*   )
+* )
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var mapEffect = /*#__PURE__*/ dual(2, (self, f) => transform(self, (parse) => (args) => flatMap(parse(args), ([leftover, a]) => f(a).pipe(map$2((b) => [leftover, b])))));
+/**
 * Makes a flag or positional argument optional.
 *
 * **Details**
@@ -5858,7 +5932,7 @@ var optional$2 = (param) => {
 			MissingArgument: () => succeed([args.arguments, none()])
 		}));
 	});
-	return Object.assign(Object.create(Proto$2), {
+	return Object.assign(Object.create(Proto$1), {
 		_tag: "Optional",
 		kind: param.kind,
 		param,
@@ -5866,6 +5940,42 @@ var optional$2 = (param) => {
 	});
 };
 /**
+* Makes a flag or positional argument optional by supplying a fallback value.
+*
+* **Details**
+*
+* The fallback may be a pure value or an effect. It is used only when the
+* parameter is absent; provided values are parsed normally.
+*
+* **Example** (Providing default values)
+*
+* ```ts
+* import { Param } from "effect/unstable/cli"
+*
+* // Using the pipe operator to make an option optional
+* const port = Param.integer(Param.flagKind, "port").pipe(
+*   Param.withDefault(8080)
+* )
+*
+* // Can also be used with other combinators
+* const verbose = Param.boolean(Param.flagKind, "verbose").pipe(
+*   Param.withAlias("-v"),
+*   Param.withDescription("Enable verbose output"),
+*   Param.withDefault(false)
+* )
+* ```
+*
+* @category combinators
+* @since 4.0.0
+*/
+var withDefault$1 = /*#__PURE__*/ dual(2, (self, defaultValue) => {
+	if (!isEffect(defaultValue)) return map$1(optional$2(self), getOrElse(() => defaultValue));
+	return mapEffect(optional$2(self), match$2({
+		onNone: () => defaultValue,
+		onSome: succeed
+	}));
+});
+/**
 * Creates a variadic parameter that can be specified multiple times.
 *
 * **Details**
@@ -5904,7 +6014,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$2), {
+	return Object.assign(Object.create(Proto$1), {
 		_tag: "Variadic",
 		kind: self.kind,
 		param: self,
@@ -6879,6 +6989,22 @@ var generate = (executableName, shell, descriptor) => {
 */
 var boolean = (name) => boolean$1(flagKind, name);
 /**
+* Creates an integer flag that accepts whole number input.
+*
+* **Example** (Creating integer flags)
+*
+* ```ts
+* import { Flag } from "effect/unstable/cli"
+*
+* const portFlag = Flag.integer("port")
+* // Usage: --port 8080
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+var integer = (name) => integer$1(flagKind, name);
+/**
 * Constructs option parameters that represent a choice between several inputs.
 * Each tuple maps a string flag value to an associated typed value.
 *
@@ -7024,6 +7150,29 @@ var withMetavar = /*#__PURE__*/ dual(2, (self, metavar) => withMetavar$1(self, m
 */
 var optional = (param) => optional$2(param);
 /**
+* Provides a default value for a flag when it's not specified.
+*
+* **Example** (Providing default values)
+*
+* ```ts
+* import { Flag } from "effect/unstable/cli"
+*
+* const portFlag = Flag.integer("port").pipe(
+*   Flag.withDefault(8080)
+* )
+* // If --port is not provided, defaults to 8080
+*
+* const hostFlag = Flag.string("host").pipe(
+*   Flag.withDefault("localhost")
+* )
+* // If --host is not provided, defaults to "localhost"
+* ```
+*
+* @category optionality
+* @since 4.0.0
+*/
+var withDefault = withDefault$1;
+/**
 * Transforms the parsed value of a flag using a mapping function.
 *
 * **Example** (Mapping parsed values)
@@ -7174,13 +7323,13 @@ var reconstructTree = (tree, results) => {
 * Internal implementation details for CLI commands.
 * Public API is in ../Command.ts
 */
-var TypeId$1 = "~effect/cli/Command";
+var TypeId = "~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$1 = { .../*#__PURE__*/ Prototype({
+var Proto = { .../*#__PURE__*/ Prototype({
 	label: "Command",
 	evaluate() {
 		return toImpl(this).service;
@@ -7255,8 +7404,8 @@ var makeCommand = (options) => {
 			...examples.length > 0 && { examples }
 		};
 	};
-	return Object.assign(Object.create(Proto$1), {
-		[TypeId$1]: TypeId$1,
+	return Object.assign(Object.create(Proto), {
+		[TypeId]: TypeId,
 		name: options.name,
 		examples: options.examples ?? [],
 		annotations,
@@ -8317,7 +8466,7 @@ var scanCommandLevel = (tokens, context) => {
 * @category guards
 * @since 4.0.0
 */
-var isCommand = (u) => hasProperty(u, TypeId$1);
+var isCommand = (u) => hasProperty(u, TypeId);
 /**
 * Creates a `Command` from a name, an optional configuration, and an optional
 * handler.
@@ -8375,7 +8524,7 @@ var isCommand = (u) => hasProperty(u, TypeId$1);
 * @category constructors
 * @since 4.0.0
 */
-var make$5 = (name, config, handler) => {
+var make = (name, config, handler) => {
 	return makeCommand({
 		name,
 		config: parseConfig(config ?? {}),
@@ -8668,1483 +8817,12 @@ var runWith = (command, config) => {
 		program = provideService(program, LogLevel, logLevel);
 		const services = match$2(logLevel, {
 			onNone: () => empty(),
-			onSome: (level) => make$6(MinimumLogLevel, level)
+			onSome: (level) => make$1(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.
@@ -10259,7 +8937,7 @@ var LoomTangler = class extends Service()("LoomTangler", { make: gen(function* (
 	const batchLimit = 1e3;
 	const isLoomEvent = (event) => event.path.endsWith(".loom") && !isStorePath(event.path);
 	const watchRoot = (path) => fs.stat(path).pipe(orDie, flatMap((info) => info.type === "Directory" ? succeed(path) : config.resolve(path).pipe(map$2(({ corpusDir }) => getOrElse(fromNullishOr(corpusDir), () => dirname(path))))));
-	const watch = (path) => unwrap(watchRoot(path).pipe(map$2((root) => concat(fromEffect(result(tangle(path))), fs.watch(root).pipe(filter$1(isLoomEvent), groupedWithin(batchLimit, batchWindow), mapEffect((events) => forEach(dedupe(map$3(events, (event) => resolve(root, event.path))), (changed) => compiler.invalidate(changed), { discard: true }).pipe(andThen(result(tangle(path))))), orDie$1)))));
+	const watch = (path) => unwrap(watchRoot(path).pipe(map$2((root) => concat(fromEffect(result(tangle(path))), fs.watch(root).pipe(filter$1(isLoomEvent), groupedWithin(batchLimit, batchWindow), mapEffect$1((events) => forEach(dedupe(map$3(events, (event) => resolve(root, event.path))), (changed) => compiler.invalidate(changed), { discard: true }).pipe(andThen(result(tangle(path))))), orDie$1)))));
 	return {
 		tangle,
 		orphans,
@@ -10317,7 +8995,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$1) => error(error$1.message)
+		onFailure: (error$2) => error(error$2.message)
 	}));
 });
 var tangle = (file, watch) => watch ? tangleWatch(file) : tangleOnce(file);
@@ -10392,7 +9070,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$2) => error(`loom: could not install ${servicePackage(error$2.id)} — ${String(error$2.cause)}`).pipe(andThen(sync(() => void (process.exitCode = 1))))));
+}).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))))));
 var remove = (language) => gen(function* () {
 	const config = yield* LoomConfig;
 	const dir = process.cwd();
@@ -10437,25 +9115,71 @@ 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 tangleCommand = make$5("tangle", {
+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", {
 	path: string("path"),
 	watch: boolean("watch")
 }, ({ path, watch }) => tangle(path, watch));
-var orphansCommand = make$5("orphans", { prune: boolean("prune") }, ({ prune }) => orphans(prune));
-var weaveCommand = make$5("weave", {
+var orphansCommand = make("orphans", { prune: boolean("prune") }, ({ prune }) => orphans(prune));
+var weaveCommand = make("weave", {
 	path: string("path"),
 	out: string("out")
 }, ({ path, out }) => weave(path, out));
-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", {
+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", {
 	name: string("name"),
 	value: string("value")
 }, ({ name, value }) => set(name, value));
-var program = run(make$5("loom").pipe(withSubcommands([
+var designCommand = make("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([
 	tangleCommand,
 	orphansCommand,
 	weaveCommand,
@@ -10464,12 +9188,13 @@ var program = run(make$5("loom").pipe(withSubcommands([
 	addCommand,
 	removeCommand,
 	statusCommand,
-	setCommand
-])), { version: "0.0.8" }).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));
+	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));
 if (process.argv[2] === "lsp") {
 	const { createRequire } = await import("node:module");
 	globalThis.require = createRequire(import.meta.url);
-	const { startLanguageServer } = await import("./LoomServer-CxdKR04b.js");
+	const { startLanguageServer } = await import("./LoomServer-JbCtLtxV.js");
 	startLanguageServer();
 } else runMain(program);
 //#endregion