t3code-cli 0.13.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 integer, $b as BaseProto, $v as fromQueue, $y as mapError, A_ as isAgentEnvironment, Ab as make$13, Av as Struct, Ay as nominal, Bb as getUnsafe, Bg as ProjectLookupError, Bv as Path$1, By as catchTags, C_ as waitFormatFlag, Cb as provideMerge, Cv as UnrecognizedOption, Cy as offer, Db as _await, Dv as make$11, Dy as BadArgument, E_ as canRenderLiveTerminal, Eb as MinimumLogLevel, Ev as isQuitError, Ey as unbounded, Fb as isResult, Fg as T3Auth, Fv as optionalKey, Fy as as, G_ as getHelpForCommandPath, Gb as getOrElse, Gv as Size, Gy as fn, H_ as LogLevel, Hb as flatMap$1, Hg as CliRuntime, Hv as FileDescriptor, Hy as effectify, I_ as T3Application, Ib as isSuccess, Ig as resolveCommandProjectRef, Iv as Crypto, Iy as asVoid, J_ as makeCommand, Jb as isSome, Jv as callback$1, Jy as forkScoped, K_ as TypeId$4, Kb as getOrUndefined, Kv as WatchBackend, Ky as fnUntraced, Lb as succeed$3, Lv as make$7, Ly as callback, M_ as resolveOutputFormat, Mb as succeed$4, Mv as decodeUnknownEffect, My as acquireRelease, Nb as succeed$1, Ng as CliPath, Nv as decodeUnknownSync, Ny as addFinalizer, Ob as doneUnsafe, Ov as Literal, Oy as badArgument, P_ as loadT3CliEnv, Pb as fail$2, Pg as cliEnvironmentSetting, Pv as fromJsonString, Py as andThen, Q_ as choice, Qb as Prototype, Qv as fromIterable, Qy as map, Rb as Service, Rg as resolveThreadId, Rv as fromReadable, Ry as catchFilter, S_ as threadFormatFlag, Sb as provide, Sv as UnknownSubcommand, Sy as make$10, T_ as yesFlag, Tb as sync$1, Tv as Terminal, Ty as shutdown, U_ as getGlobalFlagsForCommandPath, Ub as fromNullishOr, Ug as layer$12, Uv as FileSystem, Uy as fail, V_ as BuiltIns, Vb as make$12, Vg as ThreadSessionError, Vv as TypeId$3, Vy as catch_, W_ as getGlobalFlagsForCommandTree, Wb as fromUndefinedOr, Wg as T3Config, Wv as FileTypeId, Wy as flatMap, X_ as parseConfig, Xb as none, Xv as empty, Xy as ignore, Y_ as toImpl, Yb as match, Yv as decodeText, Yy as gen, Z_ as boolean, Zb as some, Zv as filter, Zy as interrupt, __ as projectFlag, _b as uninterruptible, _v as isBoolean, _y as make$9, a as BaseAppLayer, ab as provideService, av as log, ax as dual, ay as runCollect, b_ as selfActionForceFlag, bb as effect, bv as InvalidValue, by as endUnsafe, cb as scoped, ct as layerNode$1, cv as extractSingleParams, cx as pipeArguments, cy as runForEach, db as suspend, dt as layerNode, dv as mapEffect$1, dy as splitLines, eb as match$1, em as ProviderUserInputAnswers, ev as optional$2, ex as hasProperty, ey as isStream, fb as sync, fv as optional$1, fy as succeed$5, g_ as modelFlags, gb as try_, gt as threadStatus, gv as run$2, gy as get$1, h_ as formatFlag, hb as tryPromise, ht as latestAssistantMessage, hv as confirm, hy as unwrap, ib as provideContext, iv as error, ix as isUndefined, iy as run$1, j_ as isInteractiveHumanTerminal, jb as makeUnsafe, jv as TaggedErrorClass, jy as makeRunMain, kb as isDone, kv as String$1, ky as systemError, lb as serviceOption, lv as isFlagParam, ly as runHead, m_ as forceFlag, mb as timeoutOrElse, mv as variadic$1, my as transduce, nb as orDie, nv as withDefault, nx as isNotUndefined, ny as merge, ob as result$1, ov as Formatter, ox as identity$1, oy as runDrain, p_ as envNameFlag, pb as tapError, pt as layer$13, pv as string$1, py as tap, q_ as checkForDuplicateFlags, qb as isNone, qv as make$8, qy as forEach, rb as provide$1, rv as withDescription$1, rx as isNullish, ry as mkString, sb as runFork, sv as argumentKind, sx as pipe, sy as runFold, tb as matchEffect, tv as string$2, tx as isNotNull, ty as map$1, ub as succeed, uv as isParam, uy as runLast, v_ as projectPathFlag, vb as void_, vv as isFalseValue, vy as drain, w_ as worktreeFlag, wb as succeed$2, wv as isCliError, wy as offerUnsafe, x_ as threadFlag, xb as mergeAll, xv as ShowHelp, xy as failCauseUnsafe, y_ as replaceFlag, yb as fail$1, yv as isTrueValue, yy as isSink, zb as empty$1, zg as resolveWorktreePath, zv as fromWritable, zy as catchTag } 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,326 +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];
-	const expressionTokens = Array.isArray(expression) ? expression.map((expression) => parseExpression(expression)) : [parseExpression(expression)];
-	return concatTokens(nextTokens, expressionTokens, hasTrailingWhitespace);
-};
-/**
-* Convert valid expressions defined in a template string command (i.e. using
-* `${expression}` into strings.
-*/
-const parseExpression = (expression) => {
-	if (typeof expression === "string") return expression;
-	return String(expression);
-};
-const DELIMITERS = /*#__PURE__*/ new Set([
-	" ",
-	"	",
-	"\r",
-	"\n"
-]);
-/**
-* Number of characters in backslash escape sequences: \0 \xXX or \uXXXX
-* \cX is allowed in RegExps but not in strings
-* Octal sequences are not allowed in strict mode
-*/
-const ESCAPE_LENGTH = {
-	x: 3,
-	u: 5
-};
-/**
-* Splits a template string by whitespace while also properly handling escape
-* sequences.
-*
-* As an example, let's review the following valid commands:
-*
-* ```ts
-* ChildProcess.exec`echo foo\n bar`
-* // We should run `["echo", "foo\n", "bar"]`
-*
-* ChildProcess.exec`echo foo
-*  bar`
-* // We should run `["echo", "foo", "bar]`
-* ```
-*
-* The problem is that when we evaluate the template string for both of the above
-* commands, we will end up with the same string "echo foo\n bar".
-*
-* What we really want is to include the escaped character in the arguments for
-* the first command, since it was written explicitly by the user.
-*
-* This is why also having access to the raw template string is useful - in a
-* template string, there are two representations of the same string:
-* 1. `template`     - The processed string (escape sequences are evaluated).
-* 2. `template.raw` - The raw string (escape sequences are literal).
-*/
-const splitByWhitespaces = (template, rawTemplate) => {
-	if (rawTemplate.length === 0) return {
-		tokens: [],
-		hasLeadingWhitespace: false,
-		hasTrailingWhitespace: false
-	};
-	const hasLeadingWhitespace = DELIMITERS.has(rawTemplate[0]);
-	const tokens = [];
-	let templateCursor = 0;
-	for (let templateIndex = 0, rawIndex = 0; templateIndex < template.length; templateIndex += 1, rawIndex += 1) {
-		const rawCharacter = rawTemplate[rawIndex];
-		if (DELIMITERS.has(rawCharacter)) {
-			if (templateCursor !== templateIndex) tokens.push(template.slice(templateCursor, templateIndex));
-			templateCursor = templateIndex + 1;
-		} else if (rawCharacter === "\\") {
-			const nextRawCharacter = rawTemplate[rawIndex + 1];
-			if (nextRawCharacter === "\n") {
-				templateIndex -= 1;
-				rawIndex += 1;
-			} else if (nextRawCharacter === "u" && rawTemplate[rawIndex + 2] === "{") rawIndex = rawTemplate.indexOf("}", rawIndex + 3);
-			else rawIndex += ESCAPE_LENGTH[nextRawCharacter] ?? 1;
-		}
-	}
-	const hasTrailingWhitespace = templateCursor === template.length;
-	if (!hasTrailingWhitespace) tokens.push(template.slice(templateCursor));
-	return {
-		tokens,
-		hasLeadingWhitespace,
-		hasTrailingWhitespace
-	};
-};
-/**
-* Concatenates two separate sets of string tokens together.
-*
-* If either set is empty or `isSeparated=false`, the last element of `prevTokens`
-* and the first element of `nextTokens` will be joined into a single token.
-*/
-const concatTokens = (prevTokens, nextTokens, isSeparated) => isSeparated || prevTokens.length === 0 || nextTokens.length === 0 ? [...prevTokens, ...nextTokens] : [
-	...prevTokens.slice(0, -1),
-	`${prevTokens.at(-1)}${nextTokens.at(0)}`,
-	...nextTokens.slice(1)
-];
-//#endregion
-//#region node_modules/.pnpm/@effect+platform-node-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";
@@ -442,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);
@@ -542,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;
@@ -571,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);
@@ -670,7 +346,6 @@ 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);
@@ -689,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;
 				});
@@ -720,7 +393,7 @@ const layer$11 = /*#__PURE__*/ effect(ChildProcessSpawner, /* @__PURE__ */ gen(f
 					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,
@@ -832,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.
-*
-* **Common tasks**
+* Node-compatible implementation of Effect's `Crypto` service.
 *
-* - 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
 */
@@ -877,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,
@@ -902,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.
 *
@@ -912,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({
@@ -971,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);
@@ -1248,6 +890,7 @@ const makeFileSystem = /*#__PURE__*/ map(/*#__PURE__*/ serviceOption(WatchBacken
 	chown,
 	copy,
 	copyFile,
+	glob,
 	link: link$2,
 	makeDirectory,
 	makeTempDirectory,
@@ -1271,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.
 *
@@ -1280,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
 */
 /**
@@ -1308,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
 */
@@ -1354,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
 */
@@ -1393,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`.
-*
-* **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**
+* directly.
 *
-* 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
 */
@@ -1483,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
 */
@@ -1620,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.
@@ -1630,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.
 *
@@ -1714,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("--");
@@ -1765,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)
 */
@@ -1793,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
 * ==================================
@@ -1956,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
@@ -2028,8 +1617,8 @@ const consumeFlagValueWithTokens = (cursor, token, spec, negated = false) => {
 		};
 	}
 	return {
-		_tag: "Value",
-		value: void 0,
+		_tag: "Error",
+		error: missingFlagValue(spec),
 		tokens: []
 	};
 };
@@ -2312,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`.
 *
@@ -2324,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.
@@ -2476,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];
@@ -2582,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));
 });
@@ -2665,8 +2418,9 @@ 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 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);
@@ -2680,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 ?? [];
@@ -2704,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;
 		}
@@ -2717,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)
@@ -86394,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;
@@ -86406,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;
@@ -86547,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.
-*
-* **Mental model**
+* Builds pattern matchers for TypeScript values.
 *
-* 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
 */
@@ -86654,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"
@@ -86704,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"
@@ -86750,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"
@@ -87336,7 +87075,13 @@ 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,
@@ -87645,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* () {
@@ -87683,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* () {
@@ -88952,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
@@ -89061,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
 		})) }));
@@ -89069,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
 			})) }));
@@ -89148,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.13.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 };