@effected/cli 0.22.2 → 0.24.0

package/internal/HelpRouting.js

@@ -2,88 +2,34 @@ import { Console, Effect } from "effect";
 import { CliOutput } from "effect/cli";
 
 // src/internal/HelpRouting.ts
-const OTHER_METHODS = Object.keys({
-	assert: true,
-	clear: true,
-	count: true,
-	countReset: true,
-	debug: true,
-	dir: true,
-	dirxml: true,
-	group: true,
-	groupCollapsed: true,
-	groupEnd: true,
-	info: true,
-	table: true,
-	time: true,
-	timeEnd: true,
-	timeLog: true,
-	trace: true,
-	warn: true
-});
+/**
+* Core's presenter, with an invalid invocation's help written to stderr beside
+* its errors instead of stdout.
+*
+* @remarks
+* Core's `defaultPresenter` writes an invalid invocation's help with
+* `Console.log` and its errors with `Console.error`. Here it runs under a
+* `Console` whose `log` is the ambient one's `error`, so the help and errors
+* keep core's rendering, Formatter resolution included, and only the stream
+* moves. An explicit `--help`, a bare group invocation and `--version` are
+* other events, presented by core unchanged on stdout.
+*/
+const usageErrorsToStderr = { present: (event) => event._tag !== "InvalidInvocation" ? CliOutput.defaultPresenter.present(event) : Effect.gen(function* () {
+	const sink = yield* Console.Console;
+	const toStderr = Object.assign(Object.create(sink), { log: (...args) => sink.error(...args) });
+	yield* CliOutput.defaultPresenter.present(event).pipe(Effect.provideService(Console.Console, toStderr));
+}) };
 /**
 * Run `program` so a help document printed together with parse errors goes to
 * stderr, beside the errors, instead of stdout.
 *
 * @remarks
-* Core's `Command.runWith` prints a usage error as `Console.log(help)` then
-* `Console.error(errors)`, and an explicit `--help` or a bare group
-* invocation as the same `Console.log(help)` with nothing after it. The two
-* only differ in what follows, so the help is held: the Formatter records
-* every string its `formatHelpDoc` and `formatErrors` return, and a `log` of
-* a recorded help string waits for the next console call. An `error` of a
-* recorded errors string moves it to stderr; anything else, or the program
-* ending, releases it to stdout. At most one document is held, and output
-* order is kept.
-*
-* A Formatter or Console provided inside `program` is not wrapped, so help
-* stays on stdout there: core's own behaviour.
+* Provides core's `CliOutput.Presenter`, which `Command.runWith` hands each
+* help, invalid-invocation and version event to. A Presenter provided inside
+* `program` replaces this one.
 *
 * @internal
 */
-const routeHelpOnUsageError = (program) => Effect.gen(function* () {
-	const formatter = yield* CliOutput.Formatter;
-	const sink = yield* Console.Console;
-	const helps = /* @__PURE__ */ new Set();
-	const errors = /* @__PURE__ */ new Set();
-	let held;
-	const release = () => {
-		if (held === void 0) return;
-		const help = held;
-		held = void 0;
-		sink.log(...help);
-	};
-	const recording = Object.assign(Object.create(formatter), {
-		formatHelpDoc: (doc) => {
-			const text = formatter.formatHelpDoc(doc);
-			helps.add(text);
-			return text;
-		},
-		formatErrors: (list) => {
-			const text = formatter.formatErrors(list);
-			errors.add(text);
-			return text;
-		}
-	});
-	const routing = Object.create(sink);
-	for (const method of OTHER_METHODS) routing[method] = (...args) => {
-		release();
-		return sink[method](...args);
-	};
-	routing.log = (...args) => {
-		release();
-		if (args.length === 1 && typeof args[0] === "string" && helps.has(args[0])) held = args;
-		else sink.log(...args);
-	};
-	routing.error = (...args) => {
-		if (held !== void 0 && args.length === 1 && typeof args[0] === "string" && errors.has(args[0])) {
-			const help = held;
-			held = void 0;
-			sink.error(...help);
-		} else release();
-		sink.error(...args);
-	};
-	return yield* program.pipe(Effect.provideService(CliOutput.Formatter, recording), Effect.provideService(Console.Console, routing), Effect.ensuring(Effect.sync(release)));
-});
+const routeHelpOnUsageError = (program) => Effect.provideService(program, CliOutput.Presenter, usageErrorsToStderr);
 
 export { routeHelpOnUsageError };

package/internal/displayPath.js

@@ -0,0 +1,46 @@
+import { Context, Effect, Layer, Option, Path } from "effect";
+
+// src/internal/displayPath.ts
+/**
+* The display that shows every path as it is.
+*
+* @internal
+*/
+const identity = (absolute) => absolute;
+/**
+* The path display in effect: the identity unless `CliEnv.layer` was given a `displayPath`.
+*
+* @internal
+*/
+const CurrentDisplayPath = Context.Reference("@effected/cli/CurrentDisplayPath", { defaultValue: () => identity });
+/**
+* A path relative to `root` when it lies under it, and the path unchanged when it is `root` itself or lies outside it
+* (a `../..` chain says less than the absolute path). With a `Path` service its `relative` decides; without one, a
+* plain prefix test on `/` and `\` does.
+*
+* @internal
+*/
+const relativeTo = (root, path) => Option.match(path, {
+	onSome: (p) => (absolute) => {
+		const rel = p.relative(root, absolute);
+		return rel === "" || rel === ".." || rel.startsWith(`..${p.sep}`) || rel.startsWith("../") || p.isAbsolute(rel) ? absolute : rel;
+	},
+	onNone: () => {
+		let end = root.length;
+		while (end > 0 && (root[end - 1] === "/" || root[end - 1] === "\\")) end -= 1;
+		const base = root.slice(0, end);
+		return (absolute) => {
+			const next = absolute.charAt(base.length);
+			return absolute.startsWith(base) && (next === "/" || next === "\\") && absolute.length > base.length + 1 ? absolute.slice(base.length + 1) : absolute;
+		};
+	}
+});
+/**
+* Sets {@link CurrentDisplayPath} from the option, reading `Path` from the context when it is there. No option sets
+* nothing.
+*
+* @internal
+*/
+const displayPathLayer = (option) => option === void 0 ? Layer.empty : Layer.effect(CurrentDisplayPath)(typeof option === "function" ? Effect.succeed(option) : Effect.map(Effect.serviceOption(Path.Path), (path) => relativeTo(option.relativeTo, path)));
+
+export { CurrentDisplayPath, displayPathLayer, identity, relativeTo };

package/internal/displayWidth.js

@@ -1,16 +1,24 @@
 // src/internal/displayWidth.ts
 const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-const ANSI = /\u001B\][^\u0007\u001B]*(?:\u0007|\u001B\\)|\u001B\[[0-?]*[ -/]*[@-~]/g;
+const ANSI = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007\u001B]*(?:\u0007|\u001B\\)|[PX^_][^\u001B]*\u001B\\|[()*+\-./][0-~]|\$[()*+\-./]?[@-~]|#[3-68]| [FGLMN]|[0-?@-Z\\^_c])/g;
 const EMOJI = /^\p{RGI_Emoji}$/v;
 const WIDE2 = /[\p{Emoji_Presentation}\u1100-\u115E\u2329\u232A\u2630-\u2637\u268A-\u268F\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u303E\u3041-\u3096\u3099-\u30FF\u3105-\u312F\u3131-\u3163\u3165-\u318E\u3190-\u31E5\u31EF-\u321E\u3220-\u3247\u3250-\u4DBF\u4DC0-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFF01-\uFF60\uFFE0-\uFFE6\u{16FE0}-\u{16FF6}\u{17000}-\u{191FF}\u{1AFF0}-\u{1AFFF}\u{1B000}-\u{1B2FF}\u{1D300}-\u{1D376}\u{1F200}-\u{1F265}\u{20000}-\u{3FFFD}]/u;
 const ZERO2 = /^[\p{Mn}\p{Me}\p{Cf}\p{Cc}\u115F\u1160\u3164\uFFA0]+$/u;
 /**
-* The text without its ANSI escape sequences: CSI (including SGR colour) and OSC (including OSC-8 hyperlinks).
+* The text without its escape sequences: CSI (including SGR colour), OSC (including OSC-8 hyperlinks), the DCS, SOS,
+* PM and APC strings, and every other escape (`ESC c`, `ESC 7`, `ESC ( B`).
 *
 * @internal
 */
 const stripAnsi = (input) => input.replace(ANSI, "");
 /**
+* Whether `input` is nothing but escape sequences, as {@link stripAnsi} reads them; empty text is not. Every sequence
+* starts with ESC, so text that does not is answered without running the strip.
+*
+* @internal
+*/
+const isEscapeOnly = (input) => input.charCodeAt(0) === 27 && stripAnsi(input) === "";
+/**
 * The display width of `input` in terminal columns: graphemes, wide East Asian characters and emoji count two,
 * combining marks, control characters and ANSI escapes count none.
 *
@@ -31,4 +39,4 @@ const displayWidth = (input) => {
 */
 const graphemes = (input) => Array.from(segmenter.segment(input), (s) => s.segment);
 
-export { displayWidth, graphemes, stripAnsi };
+export { displayWidth, graphemes, isEscapeOnly, stripAnsi };

package/internal/failureTarget.js

@@ -3,6 +3,7 @@ import { sanitize } from "../Fmt.js";
 import { CliLinks } from "../CliLinks.js";
 import { Glyphs } from "../Glyphs.js";
 import { CliTheme } from "../CliTheme.js";
+import { identity } from "./displayPath.js";
 import { Render } from "../Render.js";
 import { CliFailure } from "../CliFailure.js";
 import { Config, Context, Effect, MutableRef, Option } from "effect";
@@ -31,7 +32,7 @@ const fallbackTarget = {
 		paint: (_token, text) => text,
 		glyphs: Glyphs.ascii,
 		link: (_target, label) => label,
-		displayPath: (absolute) => absolute,
+		displayPath: identity,
 		neutralizeWorkflowCommands: true
 	},
 	format: "plain",

package/internal/format.js

@@ -1,6 +1,9 @@
-import { SchemaIssue } from "effect";
+import { Fmt } from "../Fmt.js";
+import { SchemaAST, SchemaIssue } from "effect";
 
 // src/internal/format.ts
+/** The message an unknown key renders as: the leaf hook below writes it and the "did you mean" hint reads it. */
+const UNKNOWN_KEY = "unknown key";
 /**
 * Core's structured formatter, with one phrasing override.
 *
@@ -16,7 +19,7 @@ import { SchemaIssue } from "effect";
 *
 * @internal
 */
-const formatter = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (issue) => issue._tag === "UnexpectedKey" ? "unknown key" : SchemaIssue.defaultLeafHook(issue) });
+const formatter = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (issue) => issue._tag === "UnexpectedKey" ? UNKNOWN_KEY : SchemaIssue.defaultLeafHook(issue) });
 /**
 * Flatten an issue tree to one line per rejected value.
 *
@@ -39,6 +42,74 @@ const formatter = SchemaIssue.makeFormatterStandardSchemaV1({ leafHook: (issue)
 */
 const formatIssue = (issue) => issueEntries(issue).map((entry) => entry.path.length === 0 ? entry.message : `${entry.message} at ${entry.path.join(".")}`);
 /**
+* {@link formatIssue}, with a "did you mean" hint on an unknown key the schema has a near match for.
+*
+* @remarks
+* Used by `ConfigIssueRenderer` only. The declared keys come from the issue tree itself: core's `UnexpectedKey` leaf
+* carries the AST of the struct being decoded, whose property signatures are the keys the schema accepts at that
+* path, so no schema is passed in and no `@effected/config-file` value is needed. The hint is `Fmt.suggest`'s list,
+* each key sanitised, and a line with no near match is exactly the line {@link formatIssue} draws.
+*
+* @internal
+*/
+const formatIssueWithHints = (issue) => {
+	const declared = declaredKeys(issue);
+	return issueEntries(issue).map((entry) => {
+		if (entry.path.length === 0) return entry.message;
+		const line = `${entry.message} at ${entry.path.join(".")}`;
+		if (entry.message !== UNKNOWN_KEY) return line;
+		const candidates = declared.get(pathKey(entry.path));
+		const input = entry.path[entry.path.length - 1];
+		if (candidates === void 0 || input === void 0) return line;
+		const near = Fmt.suggest(input, candidates);
+		if (near.length === 0) return line;
+		return `${line} (did you mean ${orList(near.map((key) => `"${Fmt.sanitize(key)}"`))}?)`;
+	});
+};
+/** A path as a map key: `JSON.stringify` keeps `["a.b"]` and `["a", "b"]` apart, which joining on `.` would not. */
+const pathKey = (path) => JSON.stringify(path);
+/** `"a"`, `"a" or "b"`, `"a", "b" or "c"`. */
+const orList = (items) => items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`;
+/**
+* The keys each unknown key's struct declares, by the unknown key's own path.
+*
+* @remarks
+* Walks the tree the way core's formatter does (a `Pointer` extends the path; a `Filter`, `Encoding`, `Composite` or
+* `AnyOf` passes it through), so a path here is the path the formatter gives the same leaf. A union reports one
+* `UnexpectedKey` per branch at one path, and every branch's keys are candidates. Only string keys are offered: a
+* symbol key is never something a person typed into a config file.
+*/
+const declaredKeys = (issue) => {
+	const found = /* @__PURE__ */ new Map();
+	if (!SchemaIssue.isIssue(issue)) return found;
+	const walk = (node, path) => {
+		switch (node._tag) {
+			case "Filter":
+			case "Encoding":
+				walk(node.issue, path);
+				return;
+			case "Pointer":
+				walk(node.issue, [...path, ...node.path.map(String)]);
+				return;
+			case "Composite":
+			case "AnyOf":
+				for (const child of node.issues) walk(child, path);
+				return;
+			case "UnexpectedKey": {
+				if (!SchemaAST.isObjects(node.ast)) return;
+				const key = pathKey(path);
+				const keys = found.get(key) ?? /* @__PURE__ */ new Set();
+				for (const signature of node.ast.propertySignatures) if (typeof signature.name === "string") keys.add(signature.name);
+				found.set(key, keys);
+				return;
+			}
+			default: return;
+		}
+	};
+	walk(issue, []);
+	return found;
+};
+/**
 * The rejected values of an issue tree, once each: what both the lines and the tree are built from.
 *
 * @remarks
@@ -101,4 +172,4 @@ const issueTreeChildren = (entries) => {
 	return [...leaves(root), ...[...root.children].map(([name, child]) => named(name, child))];
 };
 
-export { formatIssue, issueEntries, issueTreeChildren };
+export { formatIssue, formatIssueWithHints, issueEntries, issueTreeChildren };

package/internal/inspect.js

@@ -0,0 +1,40 @@
+// src/internal/inspect.ts
+/** The value's `_tag` when it is a string; `undefined` otherwise, and when reading it throws. */
+const tagOf = (value) => {
+	if (typeof value !== "object" || value === null) return void 0;
+	try {
+		const tag = value._tag;
+		return typeof tag === "string" ? tag : void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* A failure value as report text: `String(value)`, except that a plain object whose `String` says only
+* `[object Object]` is its string `message` when it has one. `String(value)` throws for an object with no prototype or
+* a hostile `toString`: that value is `unprintable`.
+*/
+const failureText = (value, unprintable = "[unprintable value]") => {
+	try {
+		const text = String(value);
+		if (text !== "[object Object]") return text;
+		const message = value?.message;
+		return typeof message === "string" ? message : text;
+	} catch {
+		return unprintable;
+	}
+};
+/**
+* A property of a failure value, or `undefined` when it has none or reading it throws: a report must never fail on a
+* hostile getter. An `Error`'s `stack` counts, since V8 formats it on first read and the formatting reads `message`.
+*/
+const readProperty = (value, key) => {
+	if (typeof value !== "object" || value === null) return void 0;
+	try {
+		return value[key];
+	} catch {
+		return;
+	}
+};
+
+export { failureText, readProperty, tagOf };

package/internal/logSafety.js

@@ -36,7 +36,7 @@ const sanitizeParts = (message) => {
 };
 /**
 * Neutralize the `##[` the runner's legacy parser finds anywhere in a line, inside an NDJSON record, as the JSON escape
-* `##[`: it decodes to the identical text, so the record loses nothing. A `##[` can only sit in a string there.
+* `#\u0023[`: it decodes to the identical text, so the record loses nothing. A `##[` can only sit in a string there.
 *
 * @internal
 */

package/internal/terminalCapabilities.js

@@ -0,0 +1,23 @@
+import { Config, Effect, Layer, Option } from "effect";
+import { TerminalEnv } from "@effected/env";
+import { TerminalCapabilities } from "effect/cli";
+
+// src/internal/terminalCapabilities.ts
+/**
+* Installs core's `TerminalCapabilities` from the ambient `TerminalEnv`, through `TerminalEnv.capabilities`, so core's
+* own colour decision follows the kit's rule. `TERM` is read through `Config`, and a read that fails counts as unset.
+*
+* @remarks
+* It lives here rather than in `@effected/env` because `effect/cli` exports the reference only through its barrel,
+* and a value import there would load that barrel for every env consumer. `CliInteractive.layer`, built over it,
+* then holds `canPrompt` at `true`.
+*
+* @internal
+*/
+const capabilitiesLayer = Layer.effect(TerminalCapabilities.TerminalCapabilities, Effect.gen(function* () {
+	const terminal = yield* TerminalEnv;
+	const term = yield* Config.option(Config.String("TERM")).pipe(Effect.orElseSucceed(() => Option.none()));
+	return TerminalEnv.capabilities(terminal, Option.getOrUndefined(term));
+}));
+
+export { capabilitiesLayer };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.22.2",
+	"version": "0.24.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",
 	"keywords": [
@@ -57,13 +57,15 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/github-commands": "^0.6.2"
+		"@effected/commands": "^0.18.0",
+		"@effected/engine": "^0.10.0",
+		"@effected/github-commands": "^0.7.0"
 	},
 	"peerDependencies": {
-		"@effected/config-file": "^0.20.1",
-		"@effected/env": "^0.5.0",
-		"@effected/glob": "^0.14.0",
-		"@effected/walker": "^0.20.1",
+		"@effected/config-file": "^0.22.0",
+		"@effected/env": "^0.7.0",
+		"@effected/glob": "^0.16.0",
+		"@effected/walker": "^0.22.0",
 		"@types/react": "^19.3.0",
 		"effect": "^4.0.0",
 		"ink": "^8.0.0",

package/testing.d.ts

@@ -1,5 +1,5 @@
-import { Effect, FileSystem, Layer, Path, PlatformError, Scope, Terminal } from "effect";
-import { ChildProcessSpawner } from "effect/process";
+import { Duration, Effect, FileSystem, Layer, Path, PlatformError, Scope, Stream, Terminal } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
 /**
  * A hermetic temp directory minted by {@link CliTest.sandbox}, removed when its
  * scope closes.
@@ -39,6 +39,12 @@ interface RunOptions {
    * the child gets an already-ended empty input, never an open pipe.
    */
   readonly stdin?: string | undefined;
+  /**
+   * How long a child has to exit after `SIGTERM` (or the signal `kill` sends), when its scope closes or
+   * {@link SpawnedBin.kill} is called, before it is sent `SIGKILL`; `2 seconds` by default. A finite duration: a
+   * child that ignores the signal would otherwise keep the scope from closing forever, and leave the process behind.
+   */
+  readonly forceKillAfter?: Duration.Input | undefined;
 }
 /**
  * What a spawned bin did, as data: a non-zero exit is a result, not a failure.
@@ -46,13 +52,46 @@ interface RunOptions {
  * @public
  */
 interface RunResult {
-  /** The child's exit code. */
-  readonly exitCode: number;
+  /** The child's exit code, or `null` when a signal ended it. */
+  readonly exitCode: number | null;
+  /** The signal that ended the child, or `null` when it exited with a code. */
+  readonly signal: ChildProcess.Signal | null;
   /** Everything the child wrote to stdout, decoded as UTF-8. */
   readonly stdout: string;
   /** Everything the child wrote to stderr, decoded as UTF-8. */
   readonly stderr: string;
 }
+/**
+ * A bin {@link CliTest.spawn} started and has not waited for: its output as it arrives, a way to signal it, and its
+ * exit.
+ *
+ * @public
+ */
+interface SpawnedBin {
+  /**
+   * The child's stdout as lines, each without its line break (`\r\n` included), from the first byte it wrote,
+   * ending when the child closes stdout; a last line with no line break comes when it does. Every subscription replays
+   * from the start, so a test may read it more than once, and output a test never reads is still drained, so the
+   * child never blocks on a full pipe.
+   */
+  readonly stdout: Stream.Stream<string>;
+  /** The child's stderr as lines, as `stdout` gives stdout. */
+  readonly stderr: Stream.Stream<string>;
+  /**
+   * Send `signal` (`SIGTERM` by default) and wait for the child to exit. A child still running after
+   * {@link RunOptions.forceKillAfter} is sent `SIGKILL`, so this always ends. A child that has already exited, on its
+   * own or at the same moment, is not an error: this returns normally, and `exitCode` and `result` keep reporting how
+   * it ended. A kill that fails on a child still running fails with that `PlatformError`.
+   */
+  readonly kill: (signal?: ChildProcess.Signal) => Effect.Effect<void, PlatformError.PlatformError>;
+  /**
+   * The child's exit code once it exits, or `null` when a signal ended it (the default `kill` included): `result`
+   * names the signal. Re-reading it after the exit answers at once.
+   */
+  readonly exitCode: Effect.Effect<number | null, PlatformError.PlatformError>;
+  /** Wait for the exit and the end of both streams, and read everything, as {@link CliTest.run} returns it. */
+  readonly result: Effect.Effect<RunResult, PlatformError.PlatformError>;
+}
 /**
  * Spawn a built CLI bin hermetically and read its exit code and streams as data.
  *
@@ -103,6 +142,30 @@ export declare class CliTest {
    * ends it.
    */
   static readonly run: (bin: string, args: ReadonlyArray<string>, options: RunOptions) => Effect.Effect<RunResult, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
+  /**
+   * Start `execPath bin ...args` and return at once with a handle on it: its output as lines while it runs, a signal,
+   * and its exit, for a long-running command (a `--follow`, a watch mode, a server) that {@link CliTest.run} would wait
+   * on forever.
+   *
+   * @remarks
+   * The child lives in the caller's scope: when the scope closes first, the child is sent `SIGTERM`, then `SIGKILL`
+   * after `forceKillAfter` (`2 seconds` by default), so a test that ends early leaves nothing running and never waits
+   * on a child that ignores the signal. A child a signal ended reports `exitCode: null` and the signal in `result`. Both streams are drained from the start whether or not the test reads them, so a
+   * chatty child never blocks on a full pipe, and each stream replays from its first line to every reader. The
+   * options are {@link CliTest.run}'s, `stdin` included: the child gets that text, then an ended input.
+   *
+   * ```ts
+   * const child = yield* CliTest.spawn("dist/bin.js", ["logs", "--follow"], { sandbox, execPath: process.execPath })
+   * yield* Stream.runHead(child.stdout) // the first line: it is following
+   * yield* child.kill("SIGINT")
+   * assert.strictEqual(yield* child.exitCode, 0)
+   * ```
+   *
+   * @param bin - the built bin to run
+   * @param args - its arguments
+   * @param options - the sandbox, the node binary, and the working directory, environment and stdin
+   */
+  static readonly spawn: (bin: string, args: ReadonlyArray<string>, options: RunOptions) => Effect.Effect<SpawnedBin, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner | Scope.Scope>;
 }
 /**
  * One key press for {@link TestTerminal}.
@@ -172,5 +235,5 @@ export declare class TestTerminal {
     readonly rows?: number | undefined;
   }) => Effect.Effect<TestTerminalHandle>;
 }
-export type { KeyInput, RunOptions, RunResult, Sandbox, TestTerminalHandle };
+export type { KeyInput, RunOptions, RunResult, Sandbox, SpawnedBin, TestTerminalHandle };
 //# sourceMappingURL=testing.d.ts.map