@effected/cli 0.25.0 → 0.27.0

package/index.js

@@ -1,27 +1,5 @@
-import { Cancelled } from "./Cancelled.js";
-import { CliInteractive } from "./CliInteractive.js";
-import { Fmt } from "./Fmt.js";
-import { CliLinks } from "./CliLinks.js";
-import { Glyphs } from "./Glyphs.js";
-import { Token } from "./Token.js";
-import { CliTheme } from "./CliTheme.js";
-import { Render } from "./Render.js";
-import { Doc } from "./Doc.js";
-import { NotInteractive } from "./NotInteractive.js";
-import { Status } from "./Status.js";
-import { CliDoc, CliFailure } from "./CliFailure.js";
-import { CliAudience } from "./CliAudience.js";
-import { CliColor } from "./CliColor.js";
-import { CliPrompt } from "./CliPrompt.js";
-import { CliEnv } from "./CliEnv.js";
-import { CliExit } from "./CliExit.js";
-import { CliFormat } from "./CliFormat.js";
-import { CliLogger } from "./CliLogger.js";
-import { CliLog } from "./CliLog.js";
-import { CliMessage } from "./CliMessage.js";
-import { CliRuntime } from "./CliRuntime.js";
-import { ConfigIssueRenderer } from "./ConfigIssueRenderer.js";
-import { GithubAnnotation } from "./GithubAnnotation.js";
-import { SchemaIssueRenderer } from "./SchemaIssueRenderer.js";
+import { makeRootCommand } from "./commands/root.js";
+import { CatalogMergeError, DriftError, GateError, NoConfigError, StaleError, ValidationFailedError } from "./commands/schema/errors.js";
+import { CLI_VERSION } from "./version.js";
 
-export { Cancelled, CliAudience, CliColor, CliDoc, CliEnv, CliExit, CliFailure, CliFormat, CliInteractive, CliLinks, CliLog, CliLogger, CliMessage, CliPrompt, CliRuntime, CliTheme, ConfigIssueRenderer, Doc, Fmt, GithubAnnotation, Glyphs, NotInteractive, Render, SchemaIssueRenderer, Status, Token };
+export { CLI_VERSION, CatalogMergeError, DriftError, GateError, NoConfigError, StaleError, ValidationFailedError, makeRootCommand };

package/main.d.ts

@@ -0,0 +1,51 @@
+import { Distribution } from "@effected/kit";
+import { Layer } from "effect";
+import { SchemaRunDeps } from "@effected/engine/schema";
+import "@effected/env";
+/**
+ * What `effected schema` is given by the process boundary, and the test seams: the engine's dependencies, less the
+ * progress callback the command supplies itself. `main` reads `cwd`, and nothing else reads the process.
+ *
+ * @public
+ */
+type SchemaCommandDeps = Omit<SchemaRunDeps, "onProgress">;
+/**
+ * Options a carrier's bin shim passes to {@link main}. `distribution` names
+ * the package the `effected` bin was installed through; omitted for a direct
+ * install of `@effected/cli`.
+ *
+ * @public
+ */
+export interface MainOptions {
+  readonly distribution?: Distribution;
+}
+/**
+ * How `CliRuntime.main` runs the command: exit `3` for a typed error that carries no code of its own, the infrastructure
+ * tier, and this module as the program's own, so the failure report's span trail keeps the command's spans when it is
+ * installed under `node_modules/@effected/` and leaves out the kit's.
+ *
+ * @public
+ */
+export declare const mainOptions: {
+  readonly exitCode: 3;
+  readonly env: {
+    readonly appModule: string;
+  };
+};
+/**
+ * The `effected` program under `CliRuntime.main`, over `platform`: what
+ * {@link main} runs with the Node services, and what a test runs over a test
+ * environment.
+ *
+ * @public
+ */
+export declare const run: <RP, EP>(options: MainOptions, deps: SchemaCommandDeps, platform: Layer.Layer<RP, EP>) => import("effect/Effect").Effect<void, Error, Exclude<import("effect/process/ChildProcessSpawner").ChildProcessSpawner, RP> | Exclude<import("effect/FileSystem").FileSystem, RP> | Exclude<import("effect/Path").Path, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Stdio").Stdio, RP> | Exclude<import("effect/Terminal").Terminal, RP>>;
+/**
+ * Run the `effected` command. Owns the process: installs the runtime teardown
+ * and sets the exit code.
+ *
+ * @public
+ */
+export declare const main: (options?: MainOptions) => void;
+export type { SchemaCommandDeps };
+//# sourceMappingURL=main.d.ts.map

package/main.js

@@ -0,0 +1,61 @@
+import { makeRootCommand } from "./commands/root.js";
+import { CLI_VERSION } from "./version.js";
+import { CliAudience, CliLogger, CliRuntime } from "@effected/cli-kit";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+
+// src/main.ts
+/**
+* The assembled `effected` program.
+*
+* @packageDocumentation
+*/
+/**
+* `effected --version` prints `effected <version>`; a carrier's
+* ` via <name> <version>` is appended by `CliRuntime.main`'s `distribution`
+* option, not here.
+*/
+const versionFormatter = { formatVersion: (name, version) => `${name} ${version}` };
+/**
+* How `CliRuntime.main` runs the command: exit `3` for a typed error that carries no code of its own, the infrastructure
+* tier, and this module as the program's own, so the failure report's span trail keeps the command's spans when it is
+* installed under `node_modules/@effected/` and leaves out the kit's.
+*
+* @public
+*/
+const mainOptions = {
+	exitCode: 3,
+	env: { appModule: import.meta.url }
+};
+/** stdout is the report and nothing else, so every log level goes to stderr. */
+const logger = CliLogger.layer({ stderrFrom: "All" });
+/**
+* The `effected` program under `CliRuntime.main`, over `platform`: what
+* {@link main} runs with the Node services, and what a test runs over a test
+* environment.
+*
+* @public
+*/
+const run = (options, deps, platform) => CliRuntime.main(CliAudience.run(makeRootCommand(deps), { version: CLI_VERSION }), {
+	platform,
+	logger,
+	distribution: options.distribution ?? null,
+	exitCode: mainOptions.exitCode,
+	helpOnUsageError: "stderr",
+	env: {
+		...mainOptions.env,
+		formatter: versionFormatter,
+		helpFlags: { inheritedFlags: "summary" }
+	}
+});
+/**
+* Run the `effected` command. Owns the process: installs the runtime teardown
+* and sets the exit code.
+*
+* @public
+*/
+const main = (options = {}) => {
+	NodeRuntime.runMain(run(options, { cwd: process.cwd() }, NodeServices.layer));
+};
+
+export { main, mainOptions, run };

package/package.json

@@ -1,15 +1,12 @@
 {
 	"name": "@effected/cli",
-	"version": "0.25.0",
+	"version": "0.27.0",
 	"private": false,
-	"description": "The presentation boundary of an effect/cli program: audience-aware output, a document IR and renderers, editor links, failure reports and logging, plus opt-in Ink screens, widgets and a live view",
+	"description": "The effected command: the tool's command tree on the kit's front-end runtime",
 	"keywords": [
 		"effect",
 		"cli",
-		"logger",
-		"terminal",
-		"ink",
-		"tui"
+		"effected"
 	],
 	"homepage": "https://github.com/spencerbeggs/effected/tree/main/packages/cli#readme",
 	"bugs": {
@@ -34,57 +31,28 @@
 			"import": "./index.js",
 			"default": "./index.js"
 		},
-		"./testing": {
-			"types": "./testing.d.ts",
-			"import": "./testing.js",
-			"default": "./testing.js"
-		},
-		"./ui": {
-			"types": "./ui.d.ts",
-			"import": "./ui.js",
-			"default": "./ui.js"
-		},
-		"./ui/testing": {
-			"types": "./ui-testing.d.ts",
-			"import": "./ui-testing.js",
-			"default": "./ui-testing.js"
-		},
-		"./ui/testing/serializer": {
-			"types": "./ui-testing-serializer.d.ts",
-			"import": "./ui-testing-serializer.js",
-			"default": "./ui-testing-serializer.js"
+		"./main": {
+			"types": "./main.d.ts",
+			"import": "./main.js",
+			"default": "./main.js"
 		},
 		"./package.json": "./package.json"
 	},
-	"dependencies": {
-		"@effected/commands": "^0.19.0",
-		"@effected/engine": "^0.11.0",
-		"@effected/github-commands": "^0.8.0"
+	"bin": {
+		"effected": "bin/effected.js"
 	},
-	"peerDependencies": {
-		"@effected/config-file": "^0.23.0",
-		"@effected/env": "^0.9.0",
-		"@effected/glob": "^0.17.0",
-		"@effected/walker": "^0.24.0",
-		"@types/react": "^19.3.0",
-		"effect": "~4.1.0",
+	"dependencies": {
+		"@effect/platform-node": "~4.1.2",
+		"@effected/cli-kit": "^0.27.0",
+		"@effected/engine": "0.13.0",
+		"@effected/env": "^0.11.0",
+		"@effected/glob": "^0.19.0",
+		"@effected/kit": "^0.13.0",
+		"@effected/walker": "^0.25.1",
+		"effect": "~4.1.2",
 		"ink": "^8.0.0",
 		"react": "^19.3.0"
 	},
-	"peerDependenciesMeta": {
-		"@effected/config-file": {
-			"optional": true
-		},
-		"@types/react": {
-			"optional": true
-		},
-		"ink": {
-			"optional": true
-		},
-		"react": {
-			"optional": true
-		}
-	},
 	"engines": {
 		"node": ">=24.11.0"
 	}

package/render/DiffDoc.js

@@ -0,0 +1,51 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/DiffDoc.ts
+/**
+* How many diff rows `DiffDoc.render` shows per schema before it cuts the rest with a "… N more lines" tail: a
+* screenful of context that keeps a many-schema report readable.
+*
+* @public
+*/
+const DEFAULT_MAX_DIFF_LINES = 40;
+const expandTabs = (text) => text.replaceAll("	", "  ");
+/**
+* A schema's line diff as a `Doc`, in git's shape: an `@@ path @@` header, context lines as they are, removes in the
+* `error` token and adds in the `success` token.
+*
+* @remarks
+* Each tab in a line's text is expanded to two spaces, so a tab-indented document keeps its shape. Every line's text
+* goes into the document as a `Doc.text` run, which is data: the renderers remove escape and control characters from it
+* and never read it as markup, so a diff of untrusted text cannot repaint the terminal.
+* A document with more than one hunk separates them with a muted `@@ -a,b +c,d @@` range row. The cap counts every
+* row after the header (diff lines, range rows and `` markers) and the tail names exactly
+* how many were cut. Nothing here loads Ink or React.
+*
+* @public
+*/
+var DiffDoc = class {
+	constructor() {}
+	/**
+	* @param path - the schema file the diff is for, shown in the header
+	* @param diff - the diff
+	* @param options - `maxLines`, the cap on shown rows
+	*/
+	static render(path, diff, options) {
+		const cap = Math.max(0, Math.floor(options?.maxLines ?? 40));
+		const rows = [];
+		diff.hunks.forEach((hunk) => {
+			if (diff.hunks.length > 1) rows.push(Doc.text(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, "muted"));
+			for (const line of hunk.lines) {
+				const text = expandTabs(line.text);
+				rows.push(line.kind === "add" ? Doc.text(`+${text}`, "success") : line.kind === "remove" ? Doc.text(`-${text}`, "error") : Doc.text(` ${text}`));
+				if (line.noNewline === true) rows.push(Doc.text("\", "muted"));
+			}
+		});
+		const hidden = rows.length - cap;
+		const shown = hidden > 0 ? rows.slice(0, cap) : rows;
+		if (hidden > 0) shown.push(Doc.text(`… ${hidden} more ${hidden === 1 ? "line" : "lines"}`, "muted"));
+		return Doc.lines([Doc.text(`@@ ${path} @@`, "accent"), ...shown], { wrap: false });
+	}
+};
+
+export { DiffDoc };

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.60.0"
+      "packageVersion": "7.60.1"
     }
   ]
 }

package/version.js

@@ -0,0 +1,11 @@
+// src/version.ts
+/**
+* The `effected` command's version. The bundler replaces the exact expression
+* `process.env.__PACKAGE_VERSION__` with the package version at build time, so
+* it must stay spelled this way.
+*
+* @public
+*/
+const CLI_VERSION = "0.27.0";
+
+export { CLI_VERSION };

package/Cancelled.js

@@ -1,43 +0,0 @@
-import { Runtime, Schema } from "effect";
-
-// src/Cancelled.ts
-/**
-* A person backed out of an interactive prompt: they pressed escape, or the
-* prompt was interrupted.
-*
-* @remarks
-* Exits `130`, the conventional status for a run ended by the user, through
-* core's own `Runtime.errorExitCode` marker, so `CliRuntime.reportFailures`
-* keeps it. Its default rendering is one line, `cancelled; nothing written`,
-* because nothing has been written by the time a prompt is cancelled and a
-* stack trace would only alarm. A consumer `render` still overrides the line, and can hand off to it: the line is
-* the error's `message`, so `error.message` and `String(error)` carry it.
-*
-* @public
-*/
-var Cancelled = class extends Schema.TaggedError()("Cancelled", { reason: Schema.Literals(["escape", "interrupt"]) }) {
-	/**
-	* The one line, `cancelled; nothing written`.
-	*
-	* @remarks
-	* A prototype getter, not a field, so it is not part of the encoded form, equality or a JSON dump. Assigning to
-	* it is ignored: a library that rewrites `error.message` (to prefix a context, say) must not make this error throw,
-	* which a getter-only property does in strict mode. The line is fixed.
-	*/
-	get message() {
-		return "cancelled; nothing written";
-	}
-	set message(_value) {}
-	/**
-	* The process exit code: `130`.
-	*
-	* @remarks
-	* A prototype getter rather than an own field, so a JSON or logger dump of the error does not carry the
-	* runtime marker.
-	*/
-	get [Runtime.errorExitCode]() {
-		return 130;
-	}
-};
-
-export { Cancelled };

package/CliAudience.js

@@ -1,177 +0,0 @@
-import { canPrompt } from "./internal/canPrompt.js";
-import { CliInteractive } from "./CliInteractive.js";
-import { refreshFailureTarget } from "./internal/failureTarget.js";
-import { scanAudience, tallyAudience } from "./internal/scanAudience.js";
-import { WizardDropped } from "./internal/wizardGate.js";
-import { Effect, Option, Stdio } from "effect";
-import { Audience, TerminalEnv } from "@effected/env";
-import { CliConfig, CliError, Command, Flag, GlobalFlag } from "effect/cli";
-
-// src/CliAudience.ts
-const KINDS = [
-	"human",
-	"agent",
-	"ci"
-];
-/**
-* Whether the run may prompt once a flag has named the audience.
-*
-* Only a `human` audience prompts, and only with a terminal on both standard input and standard output and a `TERM`
-* that is not `dumb` (`canPrompt`, the decision `CliInteractive.layer` makes). With the
-* terminal facts in the environment (`TerminalEnv`) that is decided from them, not from the ambient value, so a
-* flag can WIDEN: `--human` under a detected agent on real terminals prompts, and in a pipe it still cannot. With no
-* `TerminalEnv` there is nothing to decide from and the flag only narrows.
-*/
-const interactiveWhenFlagged = (kind, current) => Effect.flatMap(Effect.serviceOption(TerminalEnv), (terminal) => {
-	if (kind !== "human") return Effect.succeed(false);
-	return Option.isSome(terminal) ? canPrompt(terminal.value) : Effect.succeed(current);
-});
-const CONFLICT = "Give at most one of --audience, --human, --agent, --ci (once).";
-/** Resolve the four flags into the audience to provide, failing when more than one occurrence was given. */
-const resolve = (input) => {
-	const { given: named, conflict } = tallyAudience(input);
-	if (conflict) return Effect.fail(new CliError.UserError({
-		cause: /* @__PURE__ */ new Error(CONFLICT),
-		userMessage: CONFLICT
-	}));
-	const [kind] = named;
-	return kind === void 0 ? Audience : Effect.succeed({
-		kind,
-		source: "flag"
-	});
-};
-/**
-* The audience flags of a CLI: `--audience <human|agent|ci>` and the shorthands `--human`, `--agent`, `--ci`,
-* resolved into `@effected/env`'s `Audience`.
-*
-* @remarks
-* The one wiring: share the flags on the root command and hand the root to {@link CliAudience.run} (or
-* {@link CliAudience.runWith}), which resolves the flags from argv before core parses and applies
-* {@link CliAudience.provide} itself:
-*
-* ```ts
-* const root = Command.make("tool").pipe(
-*   Command.withSharedFlags(CliAudience.flags()),
-*   Command.withSubcommands([verify]),
-* )
-* NodeRuntime.runMain(
-*   CliRuntime.main(CliAudience.run(root, { version }), { platform: NodeServices.layer, env: {} }),
-* )
-* ```
-*
-* Core lists a shared flag in the help of every subcommand, not only at the root: that is upstream (Effect-TS/effect
-* issue 8642), and `flags({ hidden: true })` is the way to keep them out of help altogether.
-*
-* A root that forgot `Command.withSharedFlags(CliAudience.flags())` does not compile. Giving more than one
-* occurrence across the four flags is a usage error even when they agree; a boolean set to false (`--no-agent`,
-* `--agent=false`) counts as not given. A bad `--audience` value is core's own parse error. Both exit `64` under
-* `CliRuntime.main`. A conflicting audience together with `--help` exits `0` and prints help, because core handles
-* its action flags before the resolver runs.
-*
-* A flag decides `CliInteractive` from the audience it names and the terminal facts: `--human` is interactive when
-* `TerminalEnv` says there is a terminal on stdin and on stdout, even where the environment detected an agent, so a
-* person running the tool inside an agent can ask for the human experience; in a pipe it still cannot prompt. A
-* non-human flag (`--agent`, `--ci`, `--audience agent|ci`) turns it off and drops `--wizard`, and switches
-* diagnostics to NDJSON, for the whole run including the parse step where a fallback prompt fires. Without
-* `TerminalEnv` in the environment a flag only narrows. `--wizard` follows the decision: a run a flag makes
-* interactive gets it back where the environment's gate had dropped it, and only there: a consumer's own `builtIns`
-* without it stay without it.
-* {@link CliAudience.provide} on its own, the path for a bare `Command.run`, acts only on the subcommand handler,
-* because core parses the root flags into a local context before any of it is visible.
-*
-* @public
-*/
-var CliAudience = class CliAudience {
-	constructor() {}
-	/**
-	* The four flags, for `Command.withSharedFlags` on the root command.
-	*
-	* @remarks
-	* Each is repeatable, so every occurrence is counted; a boolean given as `false` (`--agent=false`,
-	* `--no-agent`) is not an occurrence. Core lists shared flags in every command's help; pass
-	* `hidden` to remove them from all of them.
-	*/
-	static flags = (options) => {
-		const hide = options?.hidden === true;
-		const maybeHide = (flag) => hide ? Flag.withHidden(flag) : flag;
-		return {
-			audience: maybeHide(Flag.Literals("audience", KINDS).pipe(Flag.atLeast(0), Flag.withDescription("Who the output is for"))),
-			human: maybeHide(Flag.Boolean("human").pipe(Flag.atLeast(0), Flag.withDescription("Shorthand for --audience human"))),
-			agent: maybeHide(Flag.Boolean("agent").pipe(Flag.atLeast(0), Flag.withDescription("Shorthand for --audience agent"))),
-			ci: maybeHide(Flag.Boolean("ci").pipe(Flag.atLeast(0), Flag.withDescription("Shorthand for --audience ci")))
-		};
-	};
-	/**
-	* Resolve the flags before every subcommand handler and re-provide `Audience`.
-	*
-	* @remarks
-	* `CliAudience.run` and `runWith` apply this themselves, so a program run through them never needs it. Use it
-	* directly only with a bare `Command.run`, which leaves a fallback prompt blind to the flags (see the class
-	* remarks).
-	*
-	* A failure report is written outside the run, where the flag is not in force, so only `runWith` and `run` carry
-	* the flag's audience to it; with this on its own the report follows the environment's audience.
-	*
-	* Pipe it onto the composite root, after `withSubcommands`, since a parent's handler does not run when a
-	* subcommand is selected. With exactly one flag the audience is `{ kind, source: "flag" }`; with none the
-	* ambient `Audience` is read and provided back unchanged, so `Audience` stays in the requirement a handler
-	* reading it already has, and is added to a program whose handlers do not read it.
-	*/
-	static provide = (command) => Command.provideEffect(command, Audience, (input) => resolve(input)).pipe(Command.provideEffect(CliInteractive, (input) => Effect.gen(function* () {
-		const current = yield* CliInteractive;
-		const [flagged] = tallyAudience(input).given;
-		return flagged === void 0 ? current : yield* interactiveWhenFlagged(flagged, current);
-	})));
-	/**
-	* Run a command the way `Command.runWith` does, with the audience flag resolved BEFORE core parses.
-	*
-	* @remarks
-	* It scans `argv` for the four audience flags first, then runs core around a provided `Audience` (when exactly
-	* one is given: `{ kind, source: "flag" }`) and a `CliInteractive` decided from it: `--human` is interactive when
-	* `TerminalEnv` reports a terminal on stdin and stdout and `TERM` is not `dumb` (it can turn prompting on under a detected agent), a
-	* non-human flag or a conflict makes it false. A fallback prompt fires while core parses, earlier than
-	* anything `CliAudience.provide` can reach, so `--agent init` on a terminal would otherwise still prompt. No
-	* flag leaves the ambient values untouched. A conflict still gets core's own usage error, exit `64`, from
-	* `CliAudience.provide`'s resolver.
-	*
-	* @param command - the composite root, with the flags shared and `CliAudience.provide` piped on
-	* @param config - the same `version` and `renderErrors` as core's
-	*/
-	static runWith = (command, config) => {
-		const core = Command.runWith(CliAudience.provide(command), config);
-		return (argv) => {
-			const run = core(argv);
-			const { given, conflict } = scanAudience(argv);
-			const [kind] = given;
-			if (kind === void 0) return run;
-			const withAudience = conflict ? run : Effect.provideService(run, Audience, {
-				kind,
-				source: "flag"
-			});
-			return Effect.gen(function* () {
-				const current = yield* CliInteractive;
-				const ambient = yield* CliConfig.CliConfig;
-				if (!conflict) yield* refreshFailureTarget({
-					kind,
-					source: "flag"
-				});
-				const interactive = !conflict && (yield* interactiveWhenFlagged(kind, current));
-				const decided = Effect.provideService(withAudience, CliInteractive, interactive);
-				const hasWizard = ambient.builtIns.includes(GlobalFlag.Wizard);
-				if (!(interactive && !hasWizard && (yield* WizardDropped) === ambient) && !(!interactive && hasWizard)) return yield* decided;
-				const builtIns = interactive ? [...ambient.builtIns, GlobalFlag.Wizard] : ambient.builtIns.filter((flag) => flag !== GlobalFlag.Wizard);
-				return yield* Effect.provideService(decided, CliConfig.CliConfig, CliConfig.make({ builtIns }));
-			});
-		};
-	};
-	/**
-	* `Command.run` with the audience flag resolved before parsing: reads `Stdio.args` and calls
-	* {@link CliAudience.runWith}.
-	*
-	* @param command - the composite root
-	* @param config - the same `version` and `renderErrors` as core's
-	*/
-	static run = (command, config) => Stdio.Stdio.use(({ args }) => Effect.flatMap(args, (argv) => CliAudience.runWith(command, config)(argv)));
-};
-
-export { CliAudience };

package/CliColor.js

@@ -1,59 +0,0 @@
-import { Effect, Layer } from "effect";
-import { TerminalEnv } from "@effected/env";
-import { CliOutput } from "effect/cli";
-
-// src/CliColor.ts
-/**
-* Whether a CLI's output should carry ANSI colour, decided once and shared by
-* everything that renders — help text, error output, and any rendered result.
-*
-* @remarks
-* The decision is `@effected/env`'s `TerminalEnv.colorLevel("stdout")`, which
-* follows Node's `getColorDepth` precedence: `FORCE_COLOR` first (`0` or an
-* unrecognised value forces colour off; an empty value, `1` or `true` force basic colour, `2` 256 colours and
-* `3` truecolor, even without a terminal), then a non-empty `NO_COLOR` or `NODE_DISABLE_COLORS` and
-* `TERM=dumb`, then the TTY gate. `FORCE_COLOR` therefore beats `NO_COLOR`.
-* The environment
-* is read through the ambient `ConfigProvider`, never `process`, so a test
-* swaps it with `Effect.provideService(ConfigProvider.ConfigProvider, ...)`;
-* an ambient `TerminalEnv`, such as `TerminalEnv.layerTest`, answers instead
-* when one is provided.
-*
-* @public
-*/
-var CliColor = class CliColor {
-	constructor() {}
-	/**
-	* The decision, for passing to a pure renderer as a plain boolean.
-	*
-	* @public
-	*/
-	static enabled = TerminalEnv.colorLevel("stdout").pipe(Effect.map((level) => level !== "none"));
-	/**
-	* Core's default `CliOutput.Formatter`, coloured by the same decision as
-	* {@link CliColor.enabled}, so help text, parse errors and rendered
-	* output never disagree on whether colour is on.
-	*
-	* @remarks
-	* `overrides` replaces individual methods of the default formatter — for
-	* example `formatVersion`, to append a "via `<carrier>`" line without
-	* losing the other defaults. Each call mints a fresh layer; bind the
-	* result to a `const` or the decision is re-read every time it is
-	* provided.
-	*
-	* The `never` in its output does not mean it installs nothing.
-	* `CliOutput.Formatter` is a `Context.Reference`, whose key type is
-	* `never`, so this layer sets the formatter reference rather than
-	* providing a service. Every command it is provided to renders with the
-	* formatter it sets, and without it they fall back to core's default
-	* formatter.
-	*
-	* @public
-	*/
-	static formatterLayer = (overrides = {}) => Layer.unwrap(Effect.map(CliColor.enabled, (colors) => CliOutput.layer({
-		...CliOutput.defaultFormatter({ colors }),
-		...overrides
-	})));
-};
-
-export { CliColor };