t3code-cli 0.12.0 → 0.14.0

package/dist/bin.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { a as __toESM, i as __require, t as __commonJSMin } from "./rolldown-runtime.js";
-import { $_ as fromNullishOr, $g as fail, $h as FileSystem, $m as getGlobalFlagsForCommandPath, $p as layer$12, A_ as effect, Ag as endUnsafe, Ah as InvalidValue, Am as selfActionForceFlag, B_ as make$13, Bg as nominal, Bh as Struct, Bm as isAgentEnvironment, C_ as tapError, Cg as tap, Ch as string$1, Cm as envNameFlag, D_ as uninterruptible, Dg as make$9, Dh as isBoolean, Dm as projectFlag, E_ as try_, Eg as get$1, Eh as run$2, Em as modelFlags, F_ as sync$1, Fg as shutdown, Fh as Terminal, Fm as yesFlag, G_ as isResult, Gg as as, Gh as optionalKey, Gp as T3Auth, H_ as succeed$4, Hg as acquireRelease, Hh as decodeUnknownEffect, Hm as resolveOutputFormat, I_ as MinimumLogLevel, Ig as unbounded, Ih as isQuitError, Im as canRenderLiveTerminal, J_ as Service, Jg as catchFilter, Jh as fromReadable, Jp as resolveThreadId, K_ as isSuccess, Kg as asVoid, Kh as Crypto, Km as T3Application, Kp as resolveCommandProjectRef, L_ as _await, Lg as BadArgument, Lh as make$11, M_ as provide, Mg as make$10, Mh as UnknownSubcommand, Mm as threadFormatFlag, N_ as provideMerge, Ng as offer, Nh as UnrecognizedOption, Nm as waitFormatFlag, O_ as void_, Og as drain, Oh as isFalseValue, Om as projectPathFlag, P_ as succeed$2, Pg as offerUnsafe, Ph as isCliError, Pm as worktreeFlag, Q_ as flatMap$1, Qg as effectify, Qh as FileDescriptor, Qm as LogLevel, Qp as CliRuntime, R_ as doneUnsafe, Rg as badArgument, Rh as Literal, S_ as sync, Sg as succeed$5, Sh as optional$1, T_ as tryPromise, Tg as unwrap, Th as confirm, Tm as formatFlag, U_ as succeed$1, Ug as addFinalizer, Uh as decodeUnknownSync, Up as CliPath, V_ as makeUnsafe, Vg as makeRunMain, Vh as TaggedErrorClass, Vm as isInteractiveHumanTerminal, W_ as fail$2, Wg as andThen, Wh as fromJsonString, Wm as loadT3CliEnv, Wp as cliEnvironmentSetting, X_ as getUnsafe, Xg as catchTags, Xh as Path$1, Xp as ProjectLookupError, Y_ as empty$1, Yg as catchTag, Yh as fromWritable, Yp as resolveWorktreePath, Z_ as make$12, Zg as catch_, Zh as TypeId$3, Zm as BuiltIns, Zp as ThreadSessionError, __ as runFork, _g as runFold, _h as argumentKind, _v as pipe, a as BaseAppLayer, a_ as gen, ag as decodeText, ah as toImpl, av as match, b_ as succeed, bg as runLast, bh as isParam, c_ as map, cg as fromIterable, ch as choice, ct as layerNode$1, cv as Prototype, d_ as matchEffect, dg as map$1, dh as string$2, dt as layerNode, dv as isNotNull, e_ as flatMap, eg as FileTypeId, eh as getGlobalFlagsForCommandTree, em as T3Config, ev as fromUndefinedOr, f_ as orDie, fg as merge, fh as withDefault, fv as isNotUndefined, g_ as result$1, gg as runDrain, gh as Formatter, gt as threadStatus, gv as identity$1, h_ as provideService, hg as runCollect, hh as log, ht as latestAssistantMessage, hv as dual, i_ as forkScoped, ig as callback$1, ih as makeCommand, iv as isSome, j_ as mergeAll, jg as failCauseUnsafe, jh as ShowHelp, jm as threadFlag, k_ as fail$1, kg as isSink, kh as isTrueValue, km as replaceFlag, l_ as mapError, lg as fromQueue, lh as integer, lv as BaseProto, m_ as provideContext, mg as run$1, mh as error, mv as isUndefined, n_ as fnUntraced, ng as WatchBackend, nh as TypeId$4, nv as getOrUndefined, o_ as ignore, og as empty, oh as parseConfig, ov as none, p_ as provide$1, pg as mkString, ph as withDescription$1, pt as layer$13, pv as isNullish, q_ as succeed$3, qg as callback, qh as make$7, r_ as forEach, rg as make$8, rh as checkForDuplicateFlags, rv as isNone, s_ as interrupt, sg as filter, sh as boolean, sv as some, t_ as fn, tg as Size, th as getHelpForCommandPath, tv as getOrElse, u_ as match$1, ug as isStream, uh as optional$2, uv as hasProperty, v_ as scoped, vg as runForEach, vh as extractSingleParams, vv as pipeArguments, w_ as timeoutOrElse, wd as ProviderUserInputAnswers, wg as transduce, wh as variadic$1, wm as forceFlag, x_ as suspend, xg as splitLines, xh as mapEffect$1, y_ as serviceOption, yg as runHead, yh as isFlagParam, z_ as isDone, zg as systemError, zh as String$1 } from "./shared.js";
+import { $D as flatMap, $E as runDrain, $O as mergeAll, $T as Struct, $k as hasProperty, $w as extractSingleParams, AE as Size, AO as tapError, AT as isTrueValue, Ak as empty$1, BD as andThen, BE as filter, Bk as isSome, Bw as toImpl, CC as T3Config, CD as BadArgument, CE as make$6, CO as scoped, CT as magenta, Ck as isSuccess, DE as FileDescriptor, DO as suspend, DT as getTypeName, EE as TypeId$2, EO as succeed, ET as getChoiceKeys, Es as layerNode$1, Ew as T3Application, FD as value$2, FT as UnrecognizedOption, Fk as getOrElse, Fn as BaseAppLayer, Fw as getGlobalFlagsForCommandTree, GE as isStream, Gw as optional$2, HD as as, HT as isQuitError, Hk as match, Hw as boolean, ID as makeRunMain, IT as isCliError, Iw as getHelpForCommandPath, JD as catchTags, Jw as withDescription$1, KD as catchFilter, KE as map$1, Kw as string$2, LD as acquireRelease, LE as decodeText, LO as uninterruptible, Lw as TypeId$3, ME as make$8, MO as timeoutOrElse, MT as InvalidValue, Mk as flatMap$1, Mw as LogLevel, NE as callback$1, NO as tryPromise, NT as ShowHelp, Nb as ProviderUserInputAnswers, Nk as fromNullishOr, Ns as latestAssistantMessage, Nw as Wizard, OE as FileSystem, OO as sync, OT as isBoolean, Ok as Reference, PO as try_, PT as UnknownSubcommand, Pk as fromUndefinedOr, Ps as threadStatus, Pw as getGlobalFlagsForCommandPath, QD as fail, QE as run$2, QO as effect, QT as String$1, Qw as argumentKind, RD as addFinalizer, RO as void_, Rk as getOrUndefined, Rw as checkForDuplicateFlags, SC as layer$12, SD as unbounded, SE as ProcessId, SO as runFork, ST as green, Sk as isResult, Sw as resolveOutputFormat, TD as systemError, TE as Path$1, TT as white, UD as asVoid, UE as fromIterable, UT as make$11, Uk as none, Uw as choice, VT as Terminal, Vw as parseConfig, WD as callback, WE as fromQueue, Wk as some, Ww as integer$1, XD as effectify, Xw as error, YD as catch_, YE as merge, Yw as Formatter, Zw as log, _C as resolveThreadId, _D as make$10, _E as fdName, _T as toggle, aA as isUndefined, aD as succeed$5, aO as gen, aT as mapEffect$1, ak as _await, aw as formatFlag, bC as ThreadSessionError, bD as shutdown, bE as ChildProcessSpawner, bO as provideService, bT as bold, bw as isAgentEnvironment, cA as pipe, cD as transduce, cT as variadic$1, ck as make$13, cw as projectPathFlag, dD as make$9, dE as optionalKey, dO as mapError, dT as float, dw as threadFlag, eA as isNotNull, eD as runFold, eE as TaggedErrorClass, eO as fn, ek as provide, fC as CliPath, fD as drain, fO as match$1, fT as integer, fk as succeed$1, fw as threadFormatFlag, gD as failCauseUnsafe, gE as fromWritable, gO as orDie, gT as text, gw as canRenderLiveTerminal, hC as resolveCommandProjectRef, hD as endUnsafe, hE as fromReadable, hT as select, hw as yesFlag, iE as decodeUnknownEffect, iO as forkScoped, iT as isParam, ik as MinimumLogLevel, iw as forceFlag, jE as WatchBackend, jk as make$12, js as layer$13, jw as BuiltIns, kE as FileTypeId, kT as isFalseValue, kk as Service, ks as layerNode, lA as pipeArguments, lD as unwrap, lT as confirm, lk as makeUnsafe, lw as replaceFlag, mC as T3Auth, mE as make$7, mT as run$3, mw as worktreeFlag, nA as isNullish, nD as runHead, nO as forEach, nT as getUnderlyingSingleOrThrow, nk as succeed$2, oA as dual, oE as decodeUnknownSync, oO as ignore, oT as optional$1, ok as doneUnsafe, ow as modelFlags, pC as cliEnvironmentSetting, pD as isSink, pE as Crypto, pO as matchEffect, pT as password, pw as waitFormatFlag, qD as catchTag, qO as fail$1, qT as Literal, qw as withDefault, rD as runLast, rT as isFlagParam, rk as sync$1, rw as envNameFlag, sA as identity$1, sD as tap, sE as fromJsonString, sO as interrupt, sT as string$1, sk as isDone, sw as projectFlag, tA as isNotUndefined, tD as runForEach, tO as fnUntraced, tT as getParamMetadata, tk as provideMerge, uD as get$1, uO as map, uT as date, uk as succeed$4, uw as selfActionForceFlag, vC as resolveWorktreePath, vD as offer, vE as make$5, vO as provide$1, vT as annotate, wD as badArgument, wE as makeHandle, wO as serviceOption, wT as red, wk as succeed$3, ww as loadT3CliEnv, xC as CliRuntime, xE as ExitCode, xO as result$1, xT as cyanBright, xw as isInteractiveHumanTerminal, yC as ProjectLookupError, yD as offerUnsafe, yE as parseFdName, yO as provideContext, yT as blackBright, yk as fail$2, zE as empty, zk as isNone, zw as makeCommand } from "./shared.js";
 import * as OS from "node:os";
 import os, { homedir } from "node:os";
 import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
 import * as NodeCrypto from "node:crypto";
 import * as NFS from "node:fs";
 import * as Path from "node:path";
@@ -13,35 +14,14 @@ import * as readline from "node:readline";
 import process$1 from "node:process";
 import tty from "node:tty";
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodeRuntime.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/node_modules/@effect/platform-node/dist/NodeRuntime.js
 /**
-* Node.js process runner for starting an Effect program at the application
-* edge.
+* Node.js process runner for Effect programs.
 *
-* This module exposes `runMain`, the launcher used by Node CLIs, scripts,
-* servers, and workers when a single Effect should become the process root. It
-* handles runtime error reporting, Node process signals, and teardown so the
-* rest of the program can stay inside Effect.
-*
-* **Mental model**
-*
-* `runMain` is the last call in `main.ts`: build the effect, provide the layers
-* it needs, then hand the self-contained program to this module. The function
-* does not provide Node services itself; use `NodeServices.layer` or narrower
-* platform layers before launching.
-*
-* **Common tasks**
-*
-* - Run a CLI command or script and let failures become process failures.
-* - Keep a server or worker fiber alive as the process main program.
-* - Override teardown or disable automatic error reporting at the boundary.
-*
-* **Gotchas**
-*
-* `SIGINT` and `SIGTERM` interrupt the main fiber so scoped finalizers can run.
-* Clean success lets the event loop drain naturally, while signal-triggered
-* interruption or a non-zero teardown code exits the process. Keep long-lived
-* resources in Effect scopes and avoid finalizers that never complete.
+* This module exports `runMain`, which runs one Effect as the main process
+* fiber in Node.js. It reuses the shared Node runtime runner, including its
+* error reporting, `SIGINT` / `SIGTERM` interruption, and optional teardown
+* behavior.
 *
 * @since 4.0.0
 */
@@ -86,325 +66,7 @@ const runMain = /* @__PURE__ */ makeRunMain(({ fiber, teardown }) => {
 	process.on("SIGTERM", onSigint);
 });
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/process/ChildProcessSpawner.js
-/**
-* Service contract and helpers for running child processes through Effect.
-*
-* This module defines the {@link ChildProcessSpawner} service used by child
-* process commands to start operating-system processes. A spawner turns a
-* command description into a {@link ChildProcessHandle}, which exposes scoped
-* lifecycle operations: write to stdin, stream stdout and stderr, wait for the
-* exit code, kill the process, inspect whether it is still running, and
-* temporarily unreference it from the parent process.
-*
-* Use this module when implementing a platform-specific process backend or
-* when code needs direct access to the process service. Most applications build
-* commands with the `ChildProcess` module; this service is the lower-level
-* execution boundary and also provides convenience methods for collecting exit
-* codes, strings, and output lines. The {@link make} constructor derives those
-* helpers from one primitive `spawn` implementation, so adapters only need to
-* supply process creation.
-*
-* @since 4.0.0
-*/
-/**
-* Constructs branded child process `ExitCode` values.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const ExitCode = /*#__PURE__*/ nominal();
-/**
-* Constructs branded child process `ProcessId` values.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const ProcessId = /*#__PURE__*/ nominal();
-const HandleTypeId = "~effect/ChildProcessSpawner/ChildProcessHandle";
-const HandleProto = {
-	[HandleTypeId]: HandleTypeId,
-	...BaseProto,
-	toJSON() {
-		return {
-			_id: "ChildProcessHandle",
-			pid: this.pid
-		};
-	}
-};
-/**
-* Constructs a new `ChildProcessHandle`.
-*
-* @category constructors
-* @since 4.0.0
-*/
-const makeHandle = (params) => Object.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
-*/
-const make$6 = (spawn) => {
-	const streamString = (command, options) => spawn(command).pipe(map((handle) => decodeText(options?.includeStderr === true ? handle.all : handle.stdout)), unwrap);
-	const streamLines = (command, options) => splitLines(streamString(command, options));
-	return ChildProcessSpawner.of({
-		spawn,
-		exitCode: (command) => scoped(flatMap(spawn(command), (handle) => handle.exitCode)),
-		streamString,
-		streamLines,
-		lines: (command, options) => runCollect(streamLines(command, options)),
-		string: (command, options) => mkString(streamString(command, options))
-	});
-};
-/**
-* Service tag for child process spawning.
-*
-* @category services
-* @since 4.0.0
-*/
-var ChildProcessSpawner = class extends Service()("effect/process/ChildProcessSpawner") {};
-//#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/process/ChildProcess.js
-/**
-* An Effect-native module for working with child processes.
-*
-* This module uses an AST-based approach where commands are built first
-* using `make` and `pipeTo`, then executed using `spawn`.
-*
-* **Example** (Spawning and piping commands)
-*
-* ```ts
-* import { Effect, Stream } from "effect"
-* import { NodeServices } from "@effect/platform-node"
-* import { ChildProcess } from "effect/unstable/process"
-*
-* // Build a command
-* const command = ChildProcess.make`echo "hello world"`
-*
-* // Spawn and collect output
-* const program = Effect.gen(function*() {
-*   // You can `yield*` a command, which calls `ChildProcess.spawn`
-*   const handle = yield* command
-*   const chunks = yield* Stream.runCollect(handle.stdout)
-*   const exitCode = yield* handle.exitCode
-*   return { chunks, exitCode }
-* }).pipe(Effect.scoped, Effect.provide(NodeServices.layer))
-*
-* // With options
-* const withOptions = ChildProcess.make({ cwd: "/tmp" })`ls -la`
-*
-* // Piping commands
-* const pipeline = ChildProcess.make`cat package.json`.pipe(
-*   ChildProcess.pipeTo(ChildProcess.make`grep name`)
-* )
-*
-* // Spawn the pipeline
-* const pipelineProgram = Effect.gen(function*() {
-*   const handle = yield* pipeline
-*   const chunks = yield* Stream.runCollect(handle.stdout)
-*   return chunks
-* }).pipe(Effect.scoped, Effect.provide(NodeServices.layer))
-* ```
-*
-* @since 4.0.0
-*/
-const TypeId$2 = "~effect/unstable/process/ChildProcess";
-const Proto = {
-	.../*#__PURE__*/ Prototype({
-		label: "Command",
-		evaluate(fiber) {
-			return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
-		}
-	}),
-	[TypeId$2]: TypeId$2
-};
-const makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto), {
-	_tag: "StandardCommand",
-	command,
-	args,
-	options
-});
-/**
-* Create a command from a template literal, options + template, or array form.
-*
-* **Details**
-*
-* This function supports three calling conventions:
-* 1. Template literal: `make\`npm run build\``
-* 2. Options + template literal: `make({ cwd: "/app" })\`npm run build\``
-* 3. Array form: `make("npm", ["run", "build"], options?)`
-*
-* Template literals are not parsed until execution time, allowing parsing
-* errors to flow through Effect's error channel.
-*
-* **Example** (Creating commands)
-*
-* ```ts
-* import { ChildProcess } from "effect/unstable/process"
-*
-* // Template literal form
-* const cmd1 = ChildProcess.make`echo "hello"`
-*
-* // With options
-* const cmd2 = ChildProcess.make({ cwd: "/tmp" })`ls -la`
-*
-* // Array form
-* const cmd3 = ChildProcess.make("git", ["status"])
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const make$5 = function make(...args) {
-	if (isTemplateString(args[0])) {
-		const [templates, ...expressions] = args;
-		const tokens = parseTemplates(templates, expressions);
-		return makeStandardCommand(tokens[0] ?? "", tokens.slice(1), {});
-	}
-	if (typeof args[0] === "object" && !Array.isArray(args[0]) && !isTemplateString(args[0])) {
-		const options = args[0];
-		return function(templates, ...expressions) {
-			const tokens = parseTemplates(templates, expressions);
-			return makeStandardCommand(tokens[0] ?? "", tokens.slice(1), options);
-		};
-	}
-	if (typeof args[0] === "string" && !Array.isArray(args[1])) {
-		const [command, options = {}] = args;
-		return makeStandardCommand(command, [], options);
-	}
-	const [command, cmdArgs = [], options = {}] = args;
-	return makeStandardCommand(command, cmdArgs, options);
-};
-const isTemplateString = (u) => Array.isArray(u) && "raw" in u && Array.isArray(u.raw);
-/**
-* Parses an fd name like "fd3" to its numeric index.
-* Returns undefined if the name is invalid.
-*
-* @category converting
-* @since 4.0.0
-*/
-const parseFdName = (name) => {
-	const match = /^fd(\d+)$/.exec(name);
-	if (match === null) return void 0;
-	const fd = parseInt(match[1], 10);
-	return fd >= 3 ? fd : void 0;
-};
-/**
-* Create an fd name from its numeric index.
-*
-* @category converting
-* @since 4.0.0
-*/
-const fdName = (fd) => `fd${fd}`;
-const parseTemplates = (templates, expressions) => {
-	let tokens = [];
-	for (const [index, template] of templates.entries()) tokens = parseTemplate(templates, expressions, tokens, template, index);
-	return tokens;
-};
-const parseTemplate = (templates, expressions, prevTokens, template, index) => {
-	const rawTemplate = templates.raw[index];
-	if (rawTemplate === void 0) throw new Error(`Invalid backslash sequence: ${templates.raw[index]}`);
-	const { hasLeadingWhitespace, hasTrailingWhitespace, tokens } = splitByWhitespaces(template, rawTemplate);
-	const nextTokens = concatTokens(prevTokens, tokens, hasLeadingWhitespace);
-	if (index === expressions.length) return nextTokens;
-	const expression = expressions[index];
-	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.
-*/
-const parseExpression = (expression) => {
-	if (typeof expression === "string") return expression;
-	return String(expression);
-};
-const DELIMITERS = /*#__PURE__*/ new Set([
-	" ",
-	"	",
-	"\r",
-	"\n"
-]);
-/**
-* Number of characters in backslash escape sequences: \0 \xXX or \uXXXX
-* \cX is allowed in RegExps but not in strings
-* Octal sequences are not allowed in strict mode
-*/
-const ESCAPE_LENGTH = {
-	x: 3,
-	u: 5
-};
-/**
-* Splits a template string by whitespace while also properly handling escape
-* sequences.
-*
-* As an example, let's review the following valid commands:
-*
-* ```ts
-* ChildProcess.exec`echo foo\n bar`
-* // We should run `["echo", "foo\n", "bar"]`
-*
-* ChildProcess.exec`echo foo
-*  bar`
-* // We should run `["echo", "foo", "bar]`
-* ```
-*
-* The problem is that when we evaluate the template string for both of the above
-* commands, we will end up with the same string "echo foo\n bar".
-*
-* What we really want is to include the escaped character in the arguments for
-* the first command, since it was written explicitly by the user.
-*
-* This is why also having access to the raw template string is useful - in a
-* template string, there are two representations of the same string:
-* 1. `template`     - The processed string (escape sequences are evaluated).
-* 2. `template.raw` - The raw string (escape sequences are literal).
-*/
-const splitByWhitespaces = (template, rawTemplate) => {
-	if (rawTemplate.length === 0) return {
-		tokens: [],
-		hasLeadingWhitespace: false,
-		hasTrailingWhitespace: false
-	};
-	const hasLeadingWhitespace = DELIMITERS.has(rawTemplate[0]);
-	const tokens = [];
-	let templateCursor = 0;
-	for (let templateIndex = 0, rawIndex = 0; templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
-		const rawCharacter = rawTemplate[rawIndex];
-		if (DELIMITERS.has(rawCharacter)) {
-			if (templateCursor !== templateIndex) tokens.push(template.slice(templateCursor, templateIndex));
-			templateCursor = templateIndex + 1;
-		} else if (rawCharacter === "\\") {
-			const nextRawCharacter = rawTemplate[rawIndex + 1];
-			if (nextRawCharacter === "\n") {
-				templateIndex -= 1;
-				rawIndex += 1;
-			} else if (nextRawCharacter === "u" && rawTemplate[rawIndex + 2] === "{") rawIndex = rawTemplate.indexOf("}", rawIndex + 3);
-			else rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
-		}
-	}
-	const hasTrailingWhitespace = templateCursor === template.length;
-	if (!hasTrailingWhitespace) tokens.push(template.slice(templateCursor));
-	return {
-		tokens,
-		hasLeadingWhitespace,
-		hasTrailingWhitespace
-	};
-};
-/**
-* Concatenates two separate sets of string tokens together.
-*
-* If either set is empty or `isSeparated=false`, the last element of `prevTokens`
-* and the first element of `nextTokens` will be joined into a single token.
-*/
-const concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || prevTokens.length === 0 || nextTokens.length === 0 ? [...prevTokens, ...nextTokens] : [
-	...prevTokens.slice(0, -1),
-	`${prevTokens.at(-1)}${nextTokens.at(0)}`,
-	...nextTokens.slice(1)
-];
-//#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/internal/utils.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.102_effect@4.0.0-beta.102_patch_hash=71215759e1_3273714b76c575f5c82a5a72c5bb5418/node_modules/@effect/platform-node-shared/dist/internal/utils.js
 /** @internal */
 const handleErrnoException = (module, method) => (err, [path]) => {
 	let reason = "Unknown";
@@ -441,7 +103,7 @@ const handleErrnoException = (module, method) => (err, [path]) => {
 	});
 };
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.102_effect@4.0.0-beta.102_patch_hash=71215759e1_3273714b76c575f5c82a5a72c5bb5418/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.js
 const toError = (error) => error instanceof globalThis.Error ? error : new globalThis.Error(String(error));
 const toPlatformError = (method, error, command) => {
 	const { commands } = flattenCommand(command);
@@ -541,16 +203,21 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 						evaluate: () => nodeStream,
 						onError: (error) => toPlatformError(`fromWritable(fd${fd})`, toError(error), command)
 					});
-					if (config.stream) yield* forkScoped(run$1(config.stream, sink));
+					if (config.stream) yield* forkScoped(run$2(config.stream, sink));
 					inputSinks.set(fd, sink);
 					break;
 				}
 				case "output": {
 					let stream = empty;
-					if (nodeStream && "read" in nodeStream) stream = fromReadable({
-						evaluate: () => nodeStream,
-						onError: (error) => toPlatformError(`fromReadable(fd${fd})`, toError(error), command)
-					});
+					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;
@@ -570,18 +237,28 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 			endOnDone: config.endOnDone,
 			encoding: config.encoding
 		});
-		if (isStream(config.stream)) return as(forkScoped(run$1(config.stream, sink)), sink);
+		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 ? fromReadable({
-			evaluate: () => childProcess.stdout,
-			onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
-		}) : empty;
-		let stderr = childProcess.stderr ? fromReadable({
-			evaluate: () => childProcess.stderr,
-			onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
-		}) : empty;
+		let stdout = childProcess.stdout ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stdout.on("error", (error) => passThrough.destroy(error));
+			childProcess.stdout.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stdout)", toError(error), command)
+			});
+		})() : empty;
+		let stderr = childProcess.stderr ? (() => {
+			const passThrough = new PassThrough();
+			childProcess.stderr.on("error", (error) => passThrough.destroy(error));
+			childProcess.stderr.pipe(passThrough);
+			return fromReadable({
+				evaluate: () => passThrough,
+				onError: (error) => toPlatformError("fromReadable(stderr)", toError(error), command)
+			});
+		})() : empty;
 		if (isSink(stdoutConfig.stream)) stdout = transduce(stdout, stdoutConfig.stream);
 		if (isSink(stderrConfig.stream)) stderr = transduce(stderr, stderrConfig.stream);
 		const all = merge(stdout, stderr);
@@ -631,7 +308,10 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 		} catch {}
 	};
 	const killProcess = (command, childProcess, signal) => suspend(() => {
-		if (!childProcess.kill(signal)) return fail(toPlatformError("kill", new globalThis.Error("Failed to kill child process"), command));
+		if (!childProcess.kill(signal)) {
+			const error = new globalThis.Error("Failed to kill child process");
+			return fail(toPlatformError("kill", error, command));
+		}
 		return void_;
 	});
 	const withTimeout = (childProcess, command, options) => (kill) => {
@@ -666,11 +346,13 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 				const stderrConfig = resolveOutputOption(cmd.options, "stderr");
 				const resolvedAdditionalFds = resolveAdditionalFds(cmd.options);
 				let isReferenced = true;
-				let cleanupOnNonZeroExit = false;
+				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: yield* resolveWorkingDirectory(cmd.options),
-					env: resolveEnvironment(cmd.options),
-					stdio: buildStdioArray(stdinConfig, stdoutConfig, stderrConfig, resolvedAdditionalFds),
+					cwd,
+					env,
+					stdio,
 					detached: cmd.options.detached ?? process.platform !== "win32",
 					shell: cmd.options.shell
 				}), fnUntraced(function* ([childProcess, exitSignal]) {
@@ -682,24 +364,22 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 						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);
+					return yield* killWithTimeout((command, childProcess, signal) => killProcessGroup(command, childProcess, signal).pipe(catch_(() => killProcess(command, childProcess, signal)), andThen(_await(exitSignal)))).pipe(ignore);
 				}));
 				const pid = ProcessId(childProcess.pid);
 				childProcess.on("exit", (code) => {
-					if (cleanupOnNonZeroExit && code !== 0 && isNotNull(code)) killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? "SIGTERM");
+					if (code !== 0 && isNotNull(code)) killProcessGroupOnExit(childProcess, cmd.options.killSignal ?? "SIGTERM");
 				});
 				const reref = sync(() => {
 					if (!isReferenced) {
 						childProcess.ref();
 						isReferenced = true;
-						cleanupOnNonZeroExit = false;
 					}
 				});
 				const unref = sync(() => {
 					if (isReferenced) {
 						childProcess.unref();
 						isReferenced = false;
-						cleanupOnNonZeroExit = true;
 					}
 					return reref;
 				});
@@ -709,10 +389,11 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 				const isRunning = map(isDone(exitSignal), (done) => !done);
 				const exitCode = flatMap(_await(exitSignal), ([code, signal]) => {
 					if (isNotNull(code)) return succeed(ExitCode(code));
-					return fail(toPlatformError("exitCode", new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`), cmd));
+					const error = new globalThis.Error(`Process interrupted due to receipt of signal: '${signal}'`);
+					return fail(toPlatformError("exitCode", error, cmd));
 				});
 				const kill = (options) => {
-					return withTimeout(childProcess, cmd, options)((command, childProcess, signal) => catch_(killProcessGroup(command, childProcess, signal), () => killProcess(command, childProcess, signal))).pipe(andThen(_await(exitSignal)), asVoid);
+					return withTimeout(childProcess, cmd, options)((command, childProcess, signal) => killProcessGroup(command, childProcess, signal).pipe(catch_(() => killProcess(command, childProcess, signal)), andThen(_await(exitSignal)))).pipe(asVoid);
 				};
 				return makeHandle({
 					pid,
@@ -824,29 +505,14 @@ const flattenCommand = (command) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/NodeCrypto.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.102_effect@4.0.0-beta.102_patch_hash=71215759e1_3273714b76c575f5c82a5a72c5bb5418/node_modules/@effect/platform-node-shared/dist/NodeCrypto.js
 /**
-* The `NodeCrypto` module implements Effect's `Crypto` service with
-* Node-compatible `node:crypto` APIs. It exports {@link make} as the concrete
-* service value and {@link layer} for providing that service to programs that
-* need cryptographic random bytes, UUID generation, random values, or SHA
-* digests over `Uint8Array` input.
+* Node-compatible implementation of Effect's `Crypto` service.
 *
-* **Common tasks**
-*
-* - Provide {@link layer} in Node-compatible platform packages and tests
-* - Reuse {@link make} when a surrounding layer already manages service
-*   construction
-* - Compute SHA-1, SHA-256, SHA-384, or SHA-512 digests through
-*   `effect/Crypto` after the layer is provided
-*
-* **Gotchas**
-*
-* - Random bytes come from `node:crypto.randomBytes`
-* - Digests use `node:crypto.createHash`; hash failures become platform
-*   errors
-* - SHA-1 is included for interoperability with existing protocols, not for
-*   new security-sensitive designs
+* 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
 */
@@ -869,7 +535,7 @@ const digest = (algorithm, data) => try_({
 	})
 });
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodeCrypto.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/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,
@@ -894,7 +560,7 @@ const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$7({
 	digest
 }));
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.102_effect@4.0.0-beta.102_patch_hash=71215759e1_3273714b76c575f5c82a5a72c5bb5418/node_modules/@effect/platform-node-shared/dist/NodeFileSystem.js
 /**
 * Shared Node-compatible implementation of Effect's `FileSystem` service.
 *
@@ -904,29 +570,6 @@ const layer$9 = /* @__PURE__ */ succeed$2(Crypto, /* @__PURE__ */ make$7({
 * links, metadata, temporary files and directories, and file watching through
 * the shared `FileSystem` service.
 *
-* **Mental model**
-*
-* {@link layer} installs a process-backed `FileSystem` service. Each operation
-* delegates to the corresponding Node filesystem API, then maps Node failures
-* into `PlatformError` values and invalid arguments into `BadArgument` failures.
-* Paths keep Node's normal behavior: relative paths resolve from the current
-* working directory and platform path rules still apply.
-*
-* **Common tasks**
-*
-* Provide {@link layer} at the Node runtime boundary, then depend on the
-* `FileSystem` service from application code. Use the service for ordinary
-* reads and writes, directory management, metadata inspection, links, temporary
-* resources, and file watching without importing Node's `fs` APIs directly.
-*
-* **Gotchas**
-*
-* Open files are scoped resources with tracked read and write positions; append
-* mode lets the operating system choose the write offset. File watching follows
-* `node:fs.watch` semantics unless a custom watch backend is supplied, so
-* recursive support, event coalescing, and reported paths vary by runtime and
-* platform.
-*
 * @since 4.0.0
 */
 const handleBadArgument = (method) => (err) => badArgument({
@@ -963,6 +606,13 @@ const chown = /*#__PURE__*/ (() => {
 	const nodeChown = /*#__PURE__*/ effectify(NFS.chown, /*#__PURE__*/ handleErrnoException("FileSystem", "chown"), /*#__PURE__*/ handleBadArgument("chown"));
 	return (path, uid, gid) => nodeChown(path, uid, gid);
 })();
+const glob = /*#__PURE__*/ (() => {
+	const nodeGlob = /*#__PURE__*/ effectify(NFS.glob, /*#__PURE__*/ handleErrnoException("FileSystem", "glob"), /*#__PURE__*/ handleBadArgument("glob"));
+	return (pattern, options) => nodeGlob(pattern, {
+		cwd: options?.root,
+		exclude: options?.exclude
+	});
+})();
 const link$2 = /*#__PURE__*/ (() => {
 	const nodeLink = /*#__PURE__*/ effectify(NFS.link, /*#__PURE__*/ handleErrnoException("FileSystem", "link"), /*#__PURE__*/ handleBadArgument("link"));
 	return (existingPath, newPath) => nodeLink(existingPath, newPath);
@@ -1113,7 +763,7 @@ const makeTempFileFactory = (method) => {
 		const directory = yield* makeDirectory(options);
 		const random = NodeCrypto.randomBytes(6).toString("hex");
 		const name = Path.join(directory, options?.suffix ? `${random}${options.suffix}` : random);
-		yield* writeFile(name, new Uint8Array(0));
+		yield* writeFile(name, /* @__PURE__ */ new Uint8Array(0));
 		return name;
 	});
 };
@@ -1240,6 +890,7 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 	chown,
 	copy,
 	copyFile,
+	glob,
 	link: link$2,
 	makeDirectory,
 	makeTempDirectory,
@@ -1263,7 +914,7 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 	writeFile
 }));
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodeFileSystem.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/node_modules/@effect/platform-node/dist/NodeFileSystem.js
 /**
 * Node.js `FileSystem` layer for programs that perform real filesystem I/O.
 *
@@ -1272,24 +923,6 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 * links, temporary paths, and path watching. Effects still call the service from
 * `effect/FileSystem`; this module only chooses the Node implementation.
 *
-* **Mental model**
-*
-* Provide `NodeFileSystem.layer` at the process boundary when filesystem
-* effects should touch the host filesystem. Use `NodeServices.layer` instead
-* when the same program also needs the standard Node path, stdio, terminal,
-* crypto, and child process services. Tests that need isolation can provide a
-* different `FileSystem` layer without changing the code that performs the
-* reads and writes.
-*
-* **Gotchas**
-*
-* Paths are interpreted by Node, so relative paths resolve against the current
-* working directory and platform-specific path rules apply. Filesystem failures
-* are reported through Effect platform errors rather than thrown exceptions.
-* File watching uses `FileSystem.WatchBackend` when one is available; otherwise
-* it follows `node:fs.watch`, whose recursive support, event batching, and
-* reported path names vary across operating systems.
-*
 * @since 4.0.0
 */
 /**
@@ -1300,30 +933,14 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 */
 const layer$7 = /* @__PURE__ */ effect(FileSystem)(makeFileSystem);
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.78_effect@4.0.0-beta.78/node_modules/@effect/platform-node-shared/dist/NodePath.js
+//#region node_modules/.pnpm/@effect+platform-node-shared@4.0.0-beta.102_effect@4.0.0-beta.102_patch_hash=71215759e1_3273714b76c575f5c82a5a72c5bb5418/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 `Layer`s for
-* programs that depend on `Path`. Use it when code should receive path
-* operations from the Effect environment instead of importing `node:path`
-* directly, including configuration loading, filesystem composition, and file
-* URL conversion.
-*
-* **Mental model**
-*
-* `layer` follows the platform semantics of the current Node runtime. The
-* `layerPosix` and `layerWin32` variants pin the syntax rules to POSIX or
-* Windows, which is useful for deterministic parsing, formatting, and tests.
-* All three layers include `fromFileUrl` and `toFileUrl` behavior backed by
-* Node's URL conversion functions.
-*
-* **Gotchas**
-*
-* Path operations are syntactic: they normalize separators, roots, drive
-* letters, UNC segments, extensions, and relative segments without checking the
-* filesystem. File URL conversion follows Node's validation and encoding
-* rules, and invalid conversions fail with `BadArgument`.
+* 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
 */
@@ -1346,34 +963,14 @@ const toFileUrl = (path) => try_({
 ({ ...Path.posix });
 ({ ...Path.win32 });
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodePath.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/node_modules/@effect/platform-node/dist/NodePath.js
 /**
 * Node.js layers for Effect's `Path` service.
 *
-* This module adapts Node's path and file URL behavior to the
-* platform-independent `Path` service. Provide one of its layers when a Node
-* program needs to build, normalize, parse, resolve, or convert paths without
-* depending directly on `node:path`.
-*
-* **Mental model**
-*
-* `Path` is a syntactic service: it manipulates strings and `file:` URLs. It
-* does not read the filesystem, check permissions, or validate that paths
-* exist. The selected layer decides which separator, drive-letter, UNC, and URL
-* conversion rules are used.
-*
-* **Common tasks**
-*
-* Use `layer` for host-platform Node semantics, `layerPosix` for stable POSIX
-* behavior, and `layerWin32` for stable Windows behavior. `NodeServices.layer`
-* already includes `layer`, so import this module directly when a program wants
-* only path support or a platform-specific variant.
-*
-* **Gotchas**
-*
-* Results that are correct on one platform may not be portable to another.
-* `fromFileUrl` and `toFileUrl` use Node's `node:url` conversion rules and
-* report invalid conversions as `BadArgument` failures.
+* 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
 */
@@ -1385,42 +982,23 @@ const toFileUrl = (path) => try_({
 * @since 4.0.0
 */
 const layer$5 = /* @__PURE__ */ succeed$2(Path$1)({
-	[TypeId$3]: TypeId$3,
+	[TypeId$2]: TypeId$2,
 	...Path,
 	fromFileUrl,
 	toFileUrl
 });
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Stdio.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/Stdio.js
 /**
-* Service contract for process standard input, output, error output, and
-* command-line arguments.
-*
-* `Stdio` lets command-line programs depend on standard I/O through the Effect
+* Service contract for command-line arguments and standard input, output, and
+* error output. It lets programs depend on standard I/O through the Effect
 * environment instead of reading from or writing to global process handles
-* directly. The service exposes arguments as an `Effect`, stdout and stderr as
-* `Sink`s that accept strings or bytes, and stdin as a byte `Stream`.
+* directly.
 *
-* **Mental model**
-*
-* Application code describes what it needs from standard I/O, and a runtime
-* layer supplies the concrete streams. Platform packages provide real process
-* implementations, while tests can use `Stdio.layerTest` to replace only the
-* fields that matter for a scenario and keep the rest inert.
-*
-* **Common tasks**
-*
-* - Read command-line arguments from the service's `args` effect.
-* - Write text or bytes by running values into the service's `stdout()` or
-*   `stderr()` sinks.
-* - Consume `stdin` as a stream of `Uint8Array` chunks.
-* - Build deterministic tests with `Stdio.layerTest`.
-*
-* **Gotchas**
-*
-* Standard I/O is a platform capability. Reads and writes can fail with
-* `PlatformError`, so handle failures in the Effect error channel instead of
-* assuming the process streams are always available.
+* The service exposes arguments as an `Effect`, stdout and stderr as `Sink`s
+* that accept strings or bytes, and stdin as a byte `Stream`. This module also
+* provides a constructor for service values and a small test layer with
+* overridable defaults.
 *
 * @since 4.0.0
 */
@@ -1475,31 +1053,14 @@ const make$2 = (options) => ({
 	...options
 });
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodeStdio.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/node_modules/@effect/platform-node/dist/NodeStdio.js
 /**
 * Node.js `Stdio` layer for the current process.
 *
-* The exported layer 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`. It is the stdio bridge used by CLIs, scripts, command
-* runners, and tests that intentionally communicate through the host process.
-*
-* **Mental model**
-*
-* Effects should depend on `Stdio`; this module decides that the backing
-* streams are the global Node process handles. Provide `NodeStdio.layer` when a
-* program only needs standard input and output, or `NodeServices.layer` when the
-* same entrypoint also needs the other default Node services.
-*
-* **Gotchas**
-*
-* The process stdio streams are shared resources. The layer leaves stdin open
-* and does not end stdout or stderr by default, avoiding accidental closure of
-* handles that other code in the same process may still use. Stdio might be a
-* pipe, file, or TTY; terminal-specific behavior such as raw mode, echo, color
-* detection, and cursor movement belongs with terminal APIs rather than this
-* service.
+* 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
 */
@@ -1612,7 +1173,7 @@ function defaultShouldQuit(input) {
 	return input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
 }
 //#endregion
-//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.78_effect@4.0.0-beta.78_ioredis@5.10.1/node_modules/@effect/platform-node/dist/NodeServices.js
+//#region node_modules/.pnpm/@effect+platform-node@4.0.0-beta.102_patch_hash=cae7efcda6fd29f4db2efd357cb7dc6c41cb6ad_5ec7f92fdb36a12db81428ea9ead6984/node_modules/@effect/platform-node/dist/NodeServices.js
 /**
 * Provides the default Node implementations for child process spawning,
 * filesystem, path, stdio, and terminal services.
@@ -1622,7 +1183,7 @@ function defaultShouldQuit(input) {
 */
 const layer = /*#__PURE__*/ provideMerge(layer$11, /*#__PURE__*/ mergeAll(layer$7, layer$9, layer$5, layer$3, layer$2));
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/cli/Argument.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/Argument.js
 /**
 * Creates a positional string argument.
 *
@@ -1706,7 +1267,34 @@ const variadic = /*#__PURE__*/ dual((args) => isParam(args[0]), (self, options)
 */
 const mapEffect = /*#__PURE__*/ dual(2, (self, f) => mapEffect$1(self, f));
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/cli/internal/lexer.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/CliConfig.js
+/**
+* Configuration for Effect CLI command execution.
+*
+* @since 4.0.0
+*/
+/**
+* Context reference for configuration shared by CLI parsing, help generation,
+* and command execution.
+*
+* **When to use**
+*
+* Use when you need to customize runner-wide CLI behavior, such as which
+* built-in global flags are available.
+*
+* @category services
+* @since 4.0.0
+*/
+var CliConfig = class extends Reference("effect/unstable/cli/CliConfig", { defaultValue: () => defaults }) {};
+/**
+* Default CLI configuration containing every built-in global flag.
+*
+* @category defaults
+* @since 4.0.0
+*/
+const defaults = { builtIns: BuiltIns };
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/internal/lexer.js
 /** @internal */
 function lex(argv) {
 	const endIndex = argv.indexOf("--");
@@ -1757,7 +1345,7 @@ const lexTokens = (args) => {
 	return tokens;
 };
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/cli/internal/auto-suggest.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/internal/auto-suggest.js
 /**
 * Simple Levenshtein distance implementation (small N, no perf worries)
 */
@@ -1785,7 +1373,7 @@ const suggest = (input, candidates) => {
 	return distances.filter(([d]) => d === minDistance).map(([, c]) => c);
 };
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/cli/internal/parser.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/internal/parser.js
 /**
 * Parsing Pipeline for CLI Commands
 * ==================================
@@ -1827,23 +1415,25 @@ const parseArgs = (lexResult, command, commandPath = []) => gen(function* () {
 	const inheritedFlagParams = commandImpl.contextConfig.flags.flatMap(extractSingleParams).filter(isFlagParam);
 	const inheritedFlagRegistry = createFlagRegistry(inheritedFlagParams);
 	const inheritedNames = new Set(inheritedFlagParams.map((param) => param.name));
-	const result = scanCommandLevel(tokens, {
+	const context = {
 		command,
 		commandPath: newCommandPath,
 		flagRegistry,
 		inheritedFlagRegistry,
 		localFlagNames: flagParams.filter((param) => !inheritedNames.has(param.name)).map((param) => param.name)
-	});
+	};
+	const result = scanCommandLevel(tokens, context);
 	if (result._tag === "Leaf") return {
 		flags: result.flags,
 		arguments: [...result.arguments, ...afterEndOfOptions],
 		subcommand: none(),
 		...result.errors.length > 0 && { errors: result.errors }
 	};
-	const subParsed = yield* parseArgs({
+	const subLex = {
 		tokens: result.childTokens,
 		trailingOperands: []
-	}, result.sub, newCommandPath);
+	};
+	const subParsed = yield* parseArgs(subLex, result.sub, newCommandPath);
 	const allErrors = [...result.errors, ...subParsed.errors ?? []];
 	return {
 		flags: result.flags,
@@ -1946,6 +1536,15 @@ const invalidNegatedFlagValue = (token, spec, value) => new InvalidValue({
 	expected: `omit the value and use ${token.raw} by itself to set --${spec.name} to false`,
 	kind: "flag"
 });
+const missingFlagValue = (spec) => {
+	const choices = getChoiceKeys(spec.primitiveType);
+	return new InvalidValue({
+		option: spec.name,
+		value: "",
+		expected: choices === void 0 ? spec.typeName ?? getTypeName(spec.primitiveType) : choices.join(" | "),
+		kind: "flag"
+	});
+};
 /**
 * Checks whether a token is a boolean literal value.
 * Recognizes: true/false, yes/no, on/off, 1/0
@@ -2018,8 +1617,8 @@ const consumeFlagValueWithTokens = (cursor, token, spec, negated = false) => {
 		};
 	}
 	return {
-		_tag: "Value",
-		value: void 0,
+		_tag: "Error",
+		error: missingFlagValue(spec),
 		tokens: []
 	};
 };
@@ -2302,7 +1901,167 @@ const scanCommandLevel = (tokens, context) => {
 	return toLeafResult(state);
 };
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/unstable/cli/Command.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/internal/wizard.js
+const run$1 = /*#__PURE__*/ fnUntraced(function* (command, options) {
+	const commandPath = options?.commandPath ?? [command.name];
+	const selected = getCommandAtPath(command, commandPath);
+	const commandLine = [...options?.prefix ?? commandPath];
+	yield* logCurrentCommand(commandLine);
+	yield* promptCommand(selected, commandLine, selected === command ? "ROOT" : selected.name);
+	return commandLine;
+});
+const getCommandAtPath = (command, commandPath) => {
+	let current = command;
+	for (const name of commandPath.slice(1)) {
+		const child = current.subcommands.flatMap((group) => group.commands).find((candidate) => candidate.name === name || candidate.alias === name);
+		if (child === void 0) break;
+		current = child;
+	}
+	return current;
+};
+const promptCommand = /*#__PURE__*/ fnUntraced(function* (command, commandLine, sectionName) {
+	const impl = toImpl(command);
+	const visibleSubcommands = command.subcommands.flatMap((group) => group.commands.filter((child) => !child.hidden));
+	const config = visibleSubcommands.length === 0 ? impl.config : impl.contextConfig;
+	if (config.flags.length > 0) {
+		yield* log(renderSection(sectionName, "FLAGS"));
+		for (const param of config.flags) commandLine.push(...yield* promptParam(param));
+		if (config.arguments.length > 0 || visibleSubcommands.length > 0) yield* logCurrentCommand(commandLine);
+	}
+	if (config.arguments.length > 0) {
+		yield* log(renderSection(sectionName, "ARGUMENTS"));
+		for (const param of config.arguments) commandLine.push(...yield* promptParam(param));
+		if (visibleSubcommands.length > 0) yield* logCurrentCommand(commandLine);
+	}
+	if (visibleSubcommands.length === 0) return;
+	const child = yield* run$3(select({
+		message: "Command",
+		choices: visibleSubcommands.map((command) => ({
+			title: command.name,
+			value: command,
+			...command.shortDescription !== void 0 ? { description: command.shortDescription } : command.description !== void 0 ? { description: command.description } : {}
+		}))
+	}));
+	yield* log();
+	commandLine.push(child.name);
+	if (hasWizardSteps(child)) yield* logCurrentCommand(commandLine);
+	yield* promptCommand(child, commandLine, child.name);
+});
+const hasWizardSteps = (command) => {
+	return command.subcommands.some((group) => group.commands.some((child) => !child.hidden)) || toImpl(command).config.orderedParams.length > 0;
+};
+const promptParam = /*#__PURE__*/ fnUntraced(function* (param) {
+	const single = getUnderlyingSingleOrThrow(param);
+	const metadata = getParamMetadata(param);
+	if (metadata.isOptional) {
+		if (!(yield* run$3(confirm({
+			message: `Set ${renderParamLabel(single)}?`,
+			initial: false
+		})))) {
+			yield* log();
+			return [];
+		}
+	}
+	const count = !metadata.isVariadic ? 1 : yield* run$3(integer({
+		message: `${renderParamLabel(single)} count`,
+		default: getOrElse(metadata.variadicMin, () => 0),
+		min: getOrElse(metadata.variadicMin, () => 0),
+		...isSome(metadata.variadicMax) ? { max: metadata.variadicMax.value } : {}
+	}));
+	const values = [];
+	for (let i = 0; i < count; i++) values.push(yield* promptSingle(single));
+	const parsed = single.kind === "flag" ? {
+		flags: { [single.name]: values },
+		arguments: []
+	} : {
+		flags: {},
+		arguments: values
+	};
+	yield* param.parse(parsed);
+	yield* log();
+	if (single.kind === "argument") return values;
+	return values.flatMap((value) => [`--${single.name}`, value]);
+});
+const promptSingle = (single) => {
+	const message = renderParamMessage(single);
+	switch (single.primitiveType._tag) {
+		case "Boolean": return map(run$3(confirm({
+			message,
+			label: {
+				confirm: "true",
+				deny: "false"
+			},
+			placeholder: {
+				defaultConfirm: "(T/f)",
+				defaultDeny: "(t/F)"
+			}
+		})), String);
+		case "Choice": return run$3(select({
+			message,
+			choices: (getChoiceKeys(single.primitiveType) ?? []).map((choice) => ({
+				title: choice,
+				value: choice
+			}))
+		}));
+		case "Date": return map(run$3(date({ message })), (date) => date.toISOString());
+		case "Float": return map(run$3(float({ message })), String);
+		case "Integer": return map(run$3(integer({ message })), String);
+		case "Redacted": return map(run$3(password({ message })), value$2);
+		default: return run$3(text({ message }));
+	}
+};
+const formatName = (single) => single.kind === "flag" ? `--${single.name}` : single.name;
+const renderParamMessage = (single) => renderParamLabel(single);
+const renderParamLabel = (single) => {
+	const description = getOrUndefined(single.description)?.trim();
+	const label = single.kind === "flag" && description !== void 0 && description.length <= 32 ? description : humanize(single.name);
+	return single.kind === "flag" ? `${label} (${formatName(single)})` : label;
+};
+const humanize = (name) => {
+	const words = name.split(/[-_]+/).filter((word) => word.length > 0);
+	if (words.length === 0) return name;
+	return [words[0][0].toUpperCase() + words[0].slice(1), ...words.slice(1)].join(" ");
+};
+const logCurrentCommand = (commandLine) => log(renderCommandBlock("Current command", commandLine, magenta));
+const renderSection = (commandName, section) => `${annotate(commandName.toUpperCase(), bold, cyanBright)} ${annotate("·", blackBright)} ${annotate(section, bold, white)}`;
+const renderIntroduction = (name, version, summary) => {
+	return [
+		`${annotate(name, bold, cyanBright)} ${annotate(`v${version}`, white)} ${annotate("· Command wizard", bold, white)}`,
+		...summary === void 0 || summary.length === 0 ? [] : [summary],
+		annotate("Build a command interactively. Press Ctrl+C to cancel.", blackBright),
+		""
+	].join("\n");
+};
+const renderCompletion = (commandLine) => renderCommandBlock("Command ready", commandLine, cyanBright, green);
+const renderQuit = () => `\n${annotate("Wizard cancelled.", red)}`;
+const renderCommandBlock = (label, commandLine, commandColor, labelColor = white) => {
+	const lines = wrapCommand(commandLine);
+	return [
+		annotate(label, bold, labelColor),
+		...lines.map((line) => annotate(line, commandColor)),
+		""
+	].join("\n");
+};
+const wrapCommand = (commandLine) => {
+	const width = 88;
+	const firstIndent = "  $ ";
+	const continuationIndent = "    ";
+	const args = commandLine.map(formatShellArg);
+	const lines = [];
+	let current = firstIndent;
+	for (const arg of args) {
+		const separator = current === firstIndent || current === continuationIndent ? "" : " ";
+		if (current.length + separator.length + arg.length > width && current !== firstIndent) {
+			lines.push(`${current} \\`);
+			current = `${continuationIndent}${arg}`;
+		} else current += `${separator}${arg}`;
+	}
+	if (current !== firstIndent) lines.push(current);
+	return lines;
+};
+const formatShellArg = (arg) => /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`;
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/unstable/cli/Command.js
 /**
 * Returns `true` if the provided value is a `Command`.
 *
@@ -2314,7 +2073,7 @@ const scanCommandLevel = (tokens, context) => {
 * @category guards
 * @since 4.0.0
 */
-const isCommand = (u) => hasProperty(u, TypeId$4);
+const isCommand = (u) => hasProperty(u, TypeId$3);
 /**
 * Creates a `Command` from a name, an optional configuration, and an optional
 * handler.
@@ -2466,10 +2225,13 @@ const withSubcommands = /*#__PURE__*/ dual(2, (self, subcommands) => {
 		if (!sub) return yield* impl.parse(raw);
 		const context = yield* impl.parseContext(raw);
 		const result = yield* sub.parse(raw.subcommand.value.parsedInput);
-		return Object.assign({}, context, { [SubcommandStateSymbol]: {
-			name: sub.name,
-			result
-		} });
+		return {
+			...context,
+			[SubcommandStateSymbol]: {
+				name: sub.name,
+				result
+			}
+		};
 	});
 	const handle = fnUntraced(function* (input, path) {
 		const selectedSubcommand = input[SubcommandStateSymbol];
@@ -2512,7 +2274,7 @@ const withSubcommands = /*#__PURE__*/ dual(2, (self, subcommands) => {
 */
 const withGlobalFlags = /*#__PURE__*/ dual(2, (self, globalFlags) => {
 	const impl = toImpl(self);
-	const next = Array.from(new Set([...impl.globalFlags, ...globalFlags]));
+	const next = Array.from(/* @__PURE__ */ new Set([...impl.globalFlags, ...globalFlags]));
 	return makeCommand({
 		...impl,
 		globalFlags: next
@@ -2572,8 +2334,9 @@ const getOutOfScopeGlobalFlagErrors = (allFlags, activeFlags, flagMap, commandPa
 	return errors;
 };
 const showHelp = (command, error$1) => gen(function* () {
+	const { builtIns } = yield* CliConfig;
 	const formatter = yield* Formatter;
-	const helpDoc = yield* getHelpForCommandPath(command, error$1.commandPath, BuiltIns);
+	const helpDoc = yield* getHelpForCommandPath(command, error$1.commandPath, builtIns);
 	yield* log(formatter.formatHelpDoc(helpDoc));
 	if (error$1.errors.length > 0) yield* error(formatter.formatErrors(error$1.errors));
 });
@@ -2655,9 +2418,12 @@ const run = /*#__PURE__*/ dual(2, (command, config) => Stdio.use(({ args }) => f
 const runWith = (command, config) => {
 	const commandImpl = toImpl(command);
 	return fnUntraced(function* (args) {
+		const { builtIns } = yield* CliConfig;
 		const { tokens, trailingOperands } = lex(args);
-		const allFlags = getGlobalFlagsForCommandTree(command, BuiltIns);
-		const { flagMap, remainder, errors: globalFlagErrors } = consumeGlobalFlags(tokens, command, createFlagRegistry(allFlags.flatMap((f) => extractSingleParams(f.flag)).filter(isFlagParam)));
+		const allFlags = getGlobalFlagsForCommandTree(command, builtIns);
+		const allFlagParams = allFlags.flatMap((f) => extractSingleParams(f.flag));
+		const globalRegistry = createFlagRegistry(allFlagParams.filter(isFlagParam));
+		const { flagMap, remainder, errors: globalFlagErrors } = consumeGlobalFlags(tokens, command, globalRegistry);
 		const emptyArgs = {
 			flags: flagMap,
 			arguments: []
@@ -2668,11 +2434,12 @@ const runWith = (command, config) => {
 		}, command);
 		const commandPath = [command.name, ...getCommandPath(parsedArgs)];
 		const handlerCtx = {
+			builtIns,
 			command,
 			commandPath,
 			version: config.version
 		};
-		const activeFlags = getGlobalFlagsForCommandPath(command, commandPath, BuiltIns);
+		const activeFlags = getGlobalFlagsForCommandPath(command, commandPath, builtIns);
 		const outOfScopeErrors = getOutOfScopeGlobalFlagErrors(allFlags, activeFlags, flagMap, commandPath);
 		if (outOfScopeErrors.length > 0 || globalFlagErrors.length > 0) {
 			const parseErrors = parsedArgs.errors ?? [];
@@ -2692,6 +2459,24 @@ const runWith = (command, config) => {
 				return entries !== void 0 && entries.length > 0;
 			})) continue;
 			const [, value] = yield* flag.flag.parse(emptyArgs);
+			if (flag === Wizard) return yield* gen(function* () {
+				yield* log(renderIntroduction(command.name, config.version, command.description));
+				const prefix = [command.name, ...args.filter((arg) => arg !== "--wizard" && !arg.startsWith("--wizard="))];
+				const wizardArgs = yield* run$1(command, {
+					commandPath,
+					prefix
+				});
+				yield* log(renderCompletion(wizardArgs));
+				if (yield* run$3(toggle({
+					message: "Run this command?",
+					initial: true,
+					active: "yes",
+					inactive: "no"
+				}))) {
+					yield* log();
+					yield* runWith(command, config)(wizardArgs.slice(1));
+				}
+			}).pipe(catchTag("QuitError", () => log(renderQuit())));
 			yield* flag.run(value, handlerCtx);
 			return;
 		}
@@ -2705,13 +2490,13 @@ const runWith = (command, config) => {
 			errors: [parseResult.failure]
 		});
 		let program = commandImpl.handle(parseResult.success, [command.name]);
+		const logLevel = activeFlags.includes(LogLevel) ? (yield* LogLevel.flag.parse(emptyArgs))[1] : none();
+		program = provideService(program, LogLevel, logLevel);
 		for (const flag of activeFlags) {
-			if (flag._tag !== "Setting") continue;
+			if (flag._tag !== "Setting" || flag === LogLevel) continue;
 			const [, value] = yield* flag.flag.parse(emptyArgs);
 			program = provideService(program, flag, value);
 		}
-		const [, logLevel] = yield* LogLevel.flag.parse(emptyArgs);
-		program = provideService(program, LogLevel, logLevel);
 		const services = match(logLevel, {
 			onNone: () => empty$1(),
 			onSome: (level) => make$12(MinimumLogLevel, level)
@@ -65042,7 +64827,7 @@ var require_templates = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
 	const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
 	const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
-	const ESCAPES = new Map([
+	const ESCAPES = /* @__PURE__ */ new Map([
 		["n", "\n"],
 		["r", "\r"],
 		["t", "	"],
@@ -84241,7 +84026,7 @@ var require_char_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/.pnpm/unicode-emoji-modifier-base@1.0.0/node_modules/unicode-emoji-modifier-base/index.js
 var require_unicode_emoji_modifier_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	module.exports = new Set([
+	module.exports = /* @__PURE__ */ new Set([
 		9757,
 		9977,
 		9994,
@@ -84331,7 +84116,7 @@ var require_unicode_emoji_modifier_base = /* @__PURE__ */ __commonJSMin(((export
 //#region node_modules/.pnpm/skin-tone@2.0.0/node_modules/skin-tone/index.js
 var require_skin_tone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const emojiModifierBase = require_unicode_emoji_modifier_base();
-	const skinTones = new Map([
+	const skinTones = /* @__PURE__ */ new Map([
 		["none", ""],
 		["white", "🏻"],
 		["creamWhite", "🏼"],
@@ -84493,7 +84278,9 @@ var COLON_REPLACER = "*#COLON|*";
 var COLON_REPLACER_REGEXP = new RegExp(escapeRegExp(COLON_REPLACER), "g");
 var TAB_ALLOWED_CHARACTERS = ["	"];
 var ANSI_REGEXP = ansiRegex();
-var HARD_RETURN = "\r", HARD_RETURN_RE = new RegExp(HARD_RETURN), HARD_RETURN_GFM_RE = new RegExp(HARD_RETURN + "|<br />");
+var HARD_RETURN = "\r";
+var HARD_RETURN_RE = new RegExp(HARD_RETURN);
+var HARD_RETURN_GFM_RE = new RegExp(HARD_RETURN + "|<br />");
 var defaultOptions = {
 	code: chalk.yellow,
 	blockquote: chalk.gray.italic,
@@ -85609,21 +85396,22 @@ function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
 	return 1;
 }
 //#endregion
-//#region node_modules/.pnpm/string-width@8.2.1/node_modules/string-width/index.js
+//#region node_modules/.pnpm/string-width@8.2.2/node_modules/string-width/index.js
 /**
 Logic:
 - Segment graphemes to match how terminals render clusters.
 - Width rules:
-1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates). Tabs are ignored by design.
+1. Skip non-printing clusters (Default_Ignorable, Control, pure nonspacing/enclosing Mark, lone Surrogates). Tabs are ignored by design.
 2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
 3. Minimally-qualified/unqualified emoji clusters (ZWJ sequences with 2+ Extended_Pictographic, or keycap sequences) are double-width.
 4. Hangul jamo collapse each standard modern Hangul L+V or L+V+T syllable piece to width 2.
 Unmatched repeated leading/vowel/trailing jamo stay additive because that matches how the terminals we target render them.
-5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing spacing marks and Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
 */
 const segmenter$1 = new Intl.Segmenter();
-const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
-const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
+const spacingMarkRegex = /\p{Spacing_Mark}/v;
 const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
 const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
 const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
@@ -85678,7 +85466,7 @@ function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
 	}
 	return width;
 }
-function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
 	let extra = 0;
 	let first = true;
 	for (const character of visibleSegment) {
@@ -85686,7 +85474,7 @@ function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
 			first = false;
 			continue;
 		}
-		if (character >= "＀" && character <= "￯") extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+		if (spacingMarkRegex.test(character) || character >= "＀" && character <= "￯") extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
 	}
 	return extra;
 }
@@ -85713,7 +85501,7 @@ function stringWidth(input, options = {}) {
 		}
 		const codePoint = visibleSegment.codePointAt(0);
 		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-		width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+		width += trailingWidth(visibleSegment, eastAsianWidthOptions);
 	}
 	return width;
 }
@@ -85885,7 +85673,7 @@ const ansiStyles = assembleStyles();
 //#region node_modules/.pnpm/wrap-ansi@10.0.0/node_modules/wrap-ansi/index.js
 const ANSI_ESCAPE = "\x1B";
 const ANSI_ESCAPE_CSI = "›";
-const ESCAPES = new Set([ANSI_ESCAPE, ANSI_ESCAPE_CSI]);
+const ESCAPES = /* @__PURE__ */ new Set([ANSI_ESCAPE, ANSI_ESCAPE_CSI]);
 const ANSI_ESCAPE_BELL = "\x07";
 const ANSI_CSI = "[";
 const ANSI_OSC = "]";
@@ -86379,7 +86167,7 @@ const requireDestructiveConfirmation = fn("requireDestructiveConfirmation")(func
 		yield* fail(new DestructiveConfirmationRequiredError({ message: "destructive action requires --yes in non-interactive mode" }));
 		return;
 	}
-	if (yield* run$2(confirm({
+	if (yield* run$3(confirm({
 		message: input.message,
 		initial: false
 	}))) return;
@@ -86391,7 +86179,7 @@ const requireEnvironmentReplaceConfirmation = fn("requireEnvironmentReplaceConfi
 		yield* fail(new DestructiveConfirmationRequiredError({ message: `environment '${input.name}' already exists: pass --replace` }));
 		return;
 	}
-	if (yield* run$2(confirm({
+	if (yield* run$3(confirm({
 		message: `Environment '${input.name}' already exists. Replace?`,
 		initial: false
 	}))) return;
@@ -86532,50 +86320,16 @@ const result = (self) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/effect@4.0.0-beta.78/node_modules/effect/dist/Match.js
+//#region node_modules/.pnpm/effect@4.0.0-beta.102_patch_hash=71215759e1ac0a7f65d7b75d816986687ae6c3a6cba02d928d184ca71790d488/node_modules/effect/dist/Match.js
 /**
-* Pattern matching for TypeScript values, predicates, and tagged unions.
-*
-* `Match` turns branching logic into a matcher that is built from ordered
-* cases and finished with an explicit finalizer. Use `Match.type` to define a
-* reusable matcher for a type, or `Match.value` to classify one value
-* immediately. Cases can match literal values, predicates, object patterns,
-* discriminators, tags, or negated patterns.
+* Builds pattern matchers for TypeScript values.
 *
-* **Mental model**
-*
-* A matcher checks cases in the order they are added and evaluates the handler
-* for the first match. Type matchers produce a function that can be reused with
-* different inputs, while value matchers already contain the input value. As
-* cases are added, the type system tracks which inputs remain unmatched, so
-* `Match.exhaustive` is only available when every remaining case has been
-* handled.
-*
-* **Common tasks**
-*
-* - Use `Match.type<Union>()` when a branch table should be reusable and
-*   exhaustiveness-checked.
-* - Use `Match.value(value)` when a single value should be matched immediately.
-* - Use `Match.tag`, `Match.tags`, or `Match.discriminator` for discriminated
-*   unions and domain objects with tag fields.
-* - Use `Match.orElse`, `Match.option`, or `Match.result` when unmatched input
-*   should be handled explicitly instead of requiring full exhaustiveness.
-*
-* **Example** (Matching a tagged union)
-*
-* ```ts
-* import { Match } from "effect"
-*
-* type Event =
-*   | { readonly _tag: "UserCreated"; readonly id: string }
-*   | { readonly _tag: "UserDeleted"; readonly id: string }
-*
-* const describe = Match.type<Event>().pipe(
-*   Match.tag("UserCreated", (event) => `created ${event.id}`),
-*   Match.tag("UserDeleted", (event) => `deleted ${event.id}`),
-*   Match.exhaustive
-* )
-* ```
+* `Match` lets you add ordered cases and then finish them with a result,
+* fallback, `Option`, or exhaustive check. Use `Match.type` to define a
+* reusable matcher for a type, or `Match.value` to match one value immediately.
+* Cases can match literal values, predicates, object shapes, tags, negated
+* patterns, and common checks such as strings, numbers, records, and class
+* instances.
 *
 * @since 4.0.0
 */
@@ -86639,7 +86393,7 @@ const value = value$1;
 * pattern matches, the associated function is executed and the matched input is
 * removed from the remaining cases tracked by the matcher.
 *
-* **Example** (Matching with Values and Predicates)
+* **Example** (Matching with values and predicates)
 *
 * ```ts
 * import { Match } from "effect"
@@ -86689,7 +86443,7 @@ const when = when$1;
 * `"_tag"` as their discriminator field. Use {@link discriminator} for a
 * different discriminator field.
 *
-* **Example** (Matching a Discriminated Union by Tag)
+* **Example** (Matching a discriminated union by tag)
 *
 * ```ts
 * import { Match } from "effect"
@@ -86735,7 +86489,7 @@ const tag = tag$1;
 * `default` clause in a `switch` statement or the final `else` in an `if-else`
 * chain.
 *
-* **Example** (Providing a Default Value When No Patterns Match)
+* **Example** (Providing a default value when no patterns match)
 *
 * ```ts
 * import { Match } from "effect"
@@ -87321,10 +87075,17 @@ const pairCommand = make("pair", {
 	const t3CliEnv = yield* loadT3CliEnv;
 	const output = yield* T3Output;
 	const resolvedFormat = resolveOutputFormat(format, cliRuntime, t3CliEnv, "json");
-	const result = yield* auth.pair(url);
+	const result = yield* auth.pair({
+		pairingUrl: url,
+		clientMetadata: {
+			label: "t3cli",
+			deviceType: "bot"
+		}
+	});
+	const fallbackName = yield* auth.defaultNameFromUrl(result.url);
 	const environmentName = yield* persistAuthEnvironment({
 		explicitName: name,
-		fallbackName: yield* auth.defaultNameFromUrl(result.url),
+		fallbackName,
 		url: result.url,
 		token: result.token,
 		local,
@@ -87360,9 +87121,10 @@ const localCommand = make("local", {
 		...isSome(baseDir) ? { baseDir: baseDir.value } : {},
 		...isSome(origin) ? { origin: origin.value } : {}
 	});
+	const fallbackName = yield* auth.defaultNameForLocal();
 	const environmentName = yield* persistAuthEnvironment({
 		explicitName: name,
-		fallbackName: yield* auth.defaultNameForLocal(),
+		fallbackName,
 		url: result.url,
 		token: result.token,
 		local: true,
@@ -87628,7 +87390,7 @@ const readTerminalCommand = make("read", {
 	terminalId: string("terminal-id"),
 	history: boolean("history"),
 	follow: boolean("follow"),
-	fromSequence: integer("from-sequence").pipe(optional$2),
+	fromSequence: integer$1("from-sequence").pipe(optional$2),
 	format: choice("format", ["json", "ndjson"]).pipe(withDefault("json")),
 	...extraArgsConfig
 }, ({ thread, terminalId, history, follow, fromSequence, format }) => gen(function* () {
@@ -87666,7 +87428,7 @@ const readTerminalCommand = make("read", {
 const streamTerminalCommand = make("stream", {
 	thread: threadFlag,
 	terminalId: string("terminal-id"),
-	fromSequence: integer("from-sequence").pipe(optional$2),
+	fromSequence: integer$1("from-sequence").pipe(optional$2),
 	format: choice("format", ["ndjson"]).pipe(withDefault("ndjson")),
 	...extraArgsConfig
 }, ({ thread, terminalId, fromSequence }) => gen(function* () {
@@ -88935,7 +88697,7 @@ const startThreadCommand = make("start", {
 //#region src/cli/threads/messages.ts
 const getThreadTranscriptCommand = make("transcript", {
 	thread: threadFlag,
-	limit: integer("limit").pipe(withDefault(20)),
+	limit: integer$1("limit").pipe(withDefault(20)),
 	full: boolean("full"),
 	format: formatFlag,
 	...extraArgsConfig
@@ -89019,7 +88781,7 @@ const T3InputLive = effect(T3Input, fn("makeT3Input")(function* () {
 			})) }));
 		}),
 		readStdinBinary: fn("T3InputLive.readStdinBinary")(function* () {
-			return yield* stdio.stdin.pipe(runFold(() => new Uint8Array(0), (acc, chunk) => {
+			return yield* stdio.stdin.pipe(runFold(() => /* @__PURE__ */ new Uint8Array(0), (acc, chunk) => {
 				const merged = new Uint8Array(acc.length + chunk.length);
 				merged.set(acc);
 				merged.set(chunk, acc.length);
@@ -89044,7 +88806,7 @@ var OutputError = class extends TaggedErrorClass()("OutputError", {
 const T3OutputLive = effect(T3Output, fn("makeT3Output")(function* () {
 	const stdio = yield* Stdio;
 	const writeStdout = fn("T3OutputLive.writeStdout")(function* (text) {
-		yield* succeed$5(text).pipe(run$1(stdio.stdout()), catchTags({ PlatformError: (error) => fail(new OutputError({
+		yield* succeed$5(text).pipe(run$2(stdio.stdout()), catchTags({ PlatformError: (error) => fail(new OutputError({
 			message: "failed to write output",
 			cause: error
 		})) }));
@@ -89052,7 +88814,7 @@ const T3OutputLive = effect(T3Output, fn("makeT3Output")(function* () {
 	return {
 		writeStdout,
 		writeStderr: fn("T3OutputLive.writeStderr")(function* (text) {
-			yield* succeed$5(text).pipe(run$1(stdio.stderr()), catchTags({ PlatformError: (error) => fail(new OutputError({
+			yield* succeed$5(text).pipe(run$2(stdio.stderr()), catchTags({ PlatformError: (error) => fail(new OutputError({
 				message: "failed to write output",
 				cause: error
 			})) }));
@@ -89131,7 +88893,7 @@ var T3Version = class extends Service()("t3cli/T3Version") {};
 //#endregion
 //#region src/version/layer.ts
 const PackageJsonSchema = fromJsonString(Struct({ version: String$1 }));
-const T3VersionBundledLive = sync$1(T3Version, () => ({ version: "0.12.0" }));
+const T3VersionBundledLive = sync$1(T3Version, () => ({ version: "0.14.0" }));
 effect(T3Version, gen(function* () {
 	const packageJson = yield* (yield* FileSystem).readFileString(fileURLToPath(new URL("../../package.json", import.meta.url)));
 	return { version: (yield* decodeUnknownEffect(PackageJsonSchema)(packageJson)).version };