@effected/cli 0.22.2 → 0.24.0

package/ui/CliUi.js

@@ -1,6 +1,5 @@
 import { Cancelled } from "../Cancelled.js";
 import { CliInteractive } from "../CliInteractive.js";
-import { underGithubActions } from "../internal/autoFormat.js";
 import { CliTheme } from "../CliTheme.js";
 import { NotInteractive } from "../NotInteractive.js";
 import { answerWithoutPerson } from "../internal/fallbackAnswer.js";
@@ -11,8 +10,10 @@ import { lazyView } from "./internal/lazyView.js";
 import { mountPermit } from "./internal/mountPermit.js";
 import { UiRenderOptions } from "./internal/renderOptions.js";
 import { useScreenGuard } from "./internal/ScreenContext.js";
-import { uiProviders } from "./internal/UiProviders.js";
+import { treeBase, uiProviders } from "./internal/UiProviders.js";
 import { live } from "./CliUiLive.js";
+import { liveDetached } from "./CliUiDetached.js";
+import { routeStream } from "./CliUiRouteStream.js";
 import { KeyTable, useKeys } from "./KeyTable.js";
 import { Cause, Deferred, Effect, Exit, Option, Semaphore } from "effect";
 import { Audience } from "@effected/env";
@@ -36,8 +37,9 @@ const RootKeys = (props) => {
 	return props.children;
 };
 const SCREEN_EXITED = "@effected/cli/ui: the screen exited without resolving or cancelling";
-const mount = (screen, theme, clear, crash, neutralize) => Effect.gen(function* () {
+const mount = (screen, theme, clear, crash) => Effect.gen(function* () {
 	const overrides = yield* UiRenderOptions;
+	const base = yield* treeBase(theme);
 	yield* Effect.acquireRelease(Effect.sync(() => overrides.onMount?.("screen")), (_, exit) => Effect.sync(() => {
 		const died = Exit.isFailure(exit) ? exit.cause.reasons.find(Cause.isDieReason) : void 0;
 		const interrupted = Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause);
@@ -63,11 +65,9 @@ const mount = (screen, theme, clear, crash, neutralize) => Effect.gen(function*
 	const tree = react.createElement(errorBoundary(), {
 		onError: die,
 		children: uiProviders({
+			...base,
 			cancel: control.cancel,
-			die,
-			theme,
-			glyphs: theme.glyphs,
-			...neutralize ? { neutralizeWorkflowCommands: true } : {}
+			die
 		}, react.createElement(RootKeys, {
 			cancel: control.cancel,
 			children: element
@@ -153,9 +153,8 @@ var CliUi = class CliUi {
 	static run = (screen, options) => Effect.gen(function* () {
 		if (!(yield* CliInteractive)) return yield* Effect.fail(new NotInteractive());
 		const theme = yield* audienceTheme;
-		const neutralize = yield* underGithubActions;
 		const crash = { current: void 0 };
-		const exit = yield* Effect.exit(Semaphore.withPermit(mountPermit, Effect.scoped(mount(screen, theme, options?.clear === true, crash, neutralize))));
+		const exit = yield* Effect.exit(Semaphore.withPermit(mountPermit, Effect.scoped(mount(screen, theme, options?.clear === true, crash))));
 		const crashed = crash.current;
 		const interrupted = Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause);
 		if (crashed === void 0 || interrupted) return yield* exit;
@@ -184,14 +183,11 @@ var CliUi = class CliUi {
 	* ```
 	*/
 	static context = Effect.gen(function* () {
-		const theme = yield* audienceTheme;
-		const neutralize = yield* underGithubActions;
+		const base = yield* treeBase(yield* audienceTheme);
 		yield* loadInk;
 		return {
 			"~@effected/cli/ui/UiContextValue": true,
-			theme,
-			glyphs: theme.glyphs,
-			...neutralize ? { neutralizeWorkflowCommands: true } : {}
+			...base
 		};
 	});
 	/**
@@ -272,6 +268,82 @@ var CliUi = class CliUi {
 	*/
 	static live = live;
 	/**
+	* A live view hosted by code that is not built on Effect: a test runner's reporter, a bundler plugin, a build hook.
+	*
+	* @remarks
+	* It runs `CliUi.live` in a fiber of its own, under `env` and in a scope of its own, and returns at once. A `PubSub`
+	* given as `events` is subscribed before it returns, so the first event published after the call is not lost.
+	* `env` is the environment the view reads, built by the host, which owns the platform: under Node,
+	* `CliEnv.layer().pipe(Layer.provide(NodeServices.layer))`; a test gives `CliEnv.layerTest` with a session's layer.
+	*
+	* End it with `close`, and only then shut the `PubSub` down: `close` folds the subscription's queued tail, commits
+	* the last run and releases the scope, and a shutdown before it drops that tail. `close` never rejects; `exit`
+	* says how the view ended. Forward output the host did not write through `printAbove`, or hand
+	* `CliUi.routeStream` the detached view's `printAbove` as its printer.
+	*
+	* A render that needs an environment service is given as an effect that makes the render function: it runs once
+	* under `env`, before the view is set up, so `CliLinks` or `TerminalEnv` come from the same build the view reads and
+	* the layer is not built a second time to resolve them. `env` must provide what that effect reads.
+	*
+	* Inside an Effect program, use `CliUi.live` in a scope instead.
+	*
+	* @example
+	* ```ts
+	* const view = CliUi.liveDetached(
+	* 	{
+	* 		...options,
+	* 		render: Effect.gen(function* () {
+	* 			const links = yield* CliLinks
+	* 			return (state: State, frame: number) => drawWith(links, state, frame)
+	* 		}),
+	* 	},
+	* 	CliEnv.layer().pipe(Layer.provide(NodeServices.layer)),
+	* )
+	* ```
+	*
+	* @param options - the live view's options, with the events as a `PubSub` or a stream and the render given directly
+	*   or as an effect that makes it
+	* @param env - the environment the view runs under, providing what a render effect reads
+	*/
+	static liveDetached = liveDetached;
+	/**
+	* A stream to hand to a writer in place of a terminal stream, which routes what it writes line by line through
+	* `printer`, usually a live view's `printAbove`, and writes whatever the printer declines to `original`.
+	*
+	* @remarks
+	* For output the program does not write itself: a child process's stderr, or the streams of a test runner or a
+	* bundler running in-process. Each complete line is offered to `printer`; a `false` (no frame mounted) writes it,
+	* with its line break, to `original`. Text without a line break yet is held until one comes, until `flush`, or
+	* until it passes `maxHeld` characters, when it is offered as a line of its own. Bytes are decoded as UTF-8 across
+	* writes, so a character split between two writes arrives whole.
+	*
+	* Everything written to `original` is the decoded text, so a character split across two writes, by whichever path,
+	* arrives once and whole. A write that is nothing but escape sequences (a cursor hide, a clear-screen) goes
+	* straight to `original` when no partial line is held, since there is nothing to print above a frame. Ending
+	* `writable` flushes the held text, so a writer's last line with no line break is printed, not lost. A line's own cursor
+	* movements still tear the frame; `carriageReturn: "last"` keeps only what a progress bar redrawn with `\r` would
+	* have shown.
+	*
+	* The returned `writable` reports the original's `isTTY`, `columns`, `rows`, `getColorDepth`, `hasColors` and
+	* `getWindowSize` where the original has them. A printer that throws fails the write. Node only, as `./ui` is.
+	*
+	* @example
+	* ```ts
+	* const view = CliUi.liveDetached(options, env)
+	* const routed = CliUi.routeStream(process.stderr, view.printAbove, { stream: "stderr" })
+	* runner.errorStream = routed.writable
+	* // ...at the end
+	* routed.flush()
+	* await view.close()
+	* ```
+	*
+	* @param original - the stream the writer would have written to
+	* @param printer - where each line is offered first: `true` when it printed it, `false` with nothing written
+	* @param options - the printer's stream, the hold limit, carriage returns and a text tap
+	* @throws RangeError when `maxHeld` is not a non-negative integer
+	*/
+	static routeStream = routeStream;
+	/**
 	* Run `screen` from a handler when the run is interactive; otherwise answer with `otherwise`, or fail with
 	* `NotInteractive` when there is none.
 	*
@@ -312,7 +384,10 @@ var CliUi = class CliUi {
 	* It runs during parsing, whose environment is core's alone, so it reads `CliTheme` if one is there: with
 	* `CliRuntime.main`'s `env` (`CliEnv.layer`), or provided around the program. With no theme it treats the run as
 	* not interactive, and when `CliInteractive` is on it says so once, at debug level. Interactivity is
-	* `CliInteractive`, which an audience flag can set before parsing under `CliAudience`.
+	* `CliInteractive`, which an audience flag can set before parsing under `CliAudience`. Core calls a fallback only
+	* when its `TerminalCapabilities.canPrompt` is `true`; `CliInteractive.layer` and `layerTest` hold it there so that
+	* `otherwise` survives a piped run, and a `canPrompt: false` provided inside the program bypasses this fallback,
+	* as it does `CliPrompt.fallback`.
 	*
 	* As with `CliPrompt.fallback`, the screen runs here rather than being handed to core, whose fallback runner
 	* turns a quit into the missing-parameter error, which would exit `64`. A cancel (Esc, Ctrl-C) is `Cancelled`,

package/ui/CliUiDetached.js

@@ -0,0 +1,36 @@
+import { live } from "./CliUiLive.js";
+import { Deferred, Effect, Exit, Fiber, PubSub, Scope } from "effect";
+
+// src/ui/CliUiDetached.ts
+/** @internal */
+const liveDetached = (options, env) => {
+	const scope = Effect.runSync(Scope.make());
+	const { events: source, render: drawing, ...rest } = options;
+	const render = Effect.isEffect(drawing) ? drawing : Effect.succeed(drawing);
+	const events = PubSub.isPubSub(source) ? Effect.runSync(PubSub.subscribe(source).pipe(Scope.provide(scope))) : source;
+	const mounted = Effect.runSync(Deferred.make());
+	const program = Effect.flatMap(render, (draw) => live({
+		...rest,
+		render: draw,
+		events
+	})).pipe(Effect.tap((handle) => Deferred.succeed(mounted, handle)), Effect.flatMap((handle) => handle.done), Scope.provide(scope), Effect.provide(env), Effect.onExit((exit) => Deferred.done(mounted, Exit.isFailure(exit) ? Exit.failCause(exit.cause) : Exit.die(/* @__PURE__ */ new Error("CliUi.liveDetached: the view ended")))));
+	const fiber = Effect.runFork(program);
+	const exit = Effect.runPromise(Fiber.await(fiber));
+	const handle = Effect.runPromise(Deferred.await(mounted));
+	let closing;
+	let print;
+	handle.then((mountedHandle) => {
+		print = mountedHandle.printAbove;
+	}, () => void 0);
+	return {
+		handle,
+		exit,
+		printAbove: (stream, line) => closing === void 0 && print !== void 0 ? print(stream, line) : false,
+		close: () => {
+			closing ??= Effect.runPromise(Deferred.await(mounted).pipe(Effect.flatMap((mountedHandle) => mountedHandle.close), Effect.exit, Effect.ensuring(Scope.close(scope, Exit.void)), Effect.asVoid));
+			return closing;
+		}
+	};
+};
+
+export { liveDetached };

package/ui/CliUiLive.js

@@ -1,5 +1,5 @@
 import { CliInteractive } from "../CliInteractive.js";
-import { autoFormat, underGithubActions } from "../internal/autoFormat.js";
+import { autoFormat } from "../internal/autoFormat.js";
 import { CliLinks } from "../CliLinks.js";
 import { CliTheme } from "../CliTheme.js";
 import { Render } from "../Render.js";
@@ -11,7 +11,7 @@ import { makeInkConsole } from "./internal/inkConsole.js";
 import { LazyViewShapeError, loadView } from "./internal/lazyView.js";
 import { mountPermit } from "./internal/mountPermit.js";
 import { UiRenderOptions } from "./internal/renderOptions.js";
-import { uiProviders } from "./internal/UiProviders.js";
+import { treeBase, uiProviders } from "./internal/UiProviders.js";
 import { useTerminalSize } from "./UiTheme.js";
 import { Cause, Clock, Duration, Effect, Exit, Fiber, Option, PubSub, Pull, Queue, Schedule, Scheduler, Scope, Stream } from "effect";
 import { Audience, TerminalEnv } from "@effected/env";
@@ -53,12 +53,8 @@ const live = (options) => Effect.gen(function* () {
 	const cliTheme = yield* CliTheme;
 	const theme = CliTheme.forAudience(cliTheme.forStream("stdout"), Option.isSome(audience) ? audience.value.kind : void 0);
 	const colour = theme.color;
-	const neutralize = yield* underGithubActions;
-	const provided = {
-		theme,
-		glyphs: theme.glyphs,
-		...neutralize ? { neutralizeWorkflowCommands: true } : {}
-	};
+	const provided = yield* treeBase(theme);
+	const neutralize = provided.neutralizeWorkflowCommands === true;
 	const interactive = yield* CliInteractive;
 	const streams = yield* UiStreams;
 	const overrides = yield* UiRenderOptions;
@@ -158,7 +154,8 @@ const live = (options) => Effect.gen(function* () {
 			audience: Option.isSome(audience) ? audience.value.kind : "human",
 			color: theme.color,
 			glyphs: theme.glyphs,
-			...neutralize ? { neutralizeWorkflowCommands: true } : {}
+			...neutralize ? { neutralizeWorkflowCommands: true } : {},
+			displayPath: provided.displayPath
 		});
 	});
 	/** A run's `final` document, printed as `Doc.print` would, to the view's stdout; never Ink. */

package/ui/CliUiRouteStream.js

@@ -0,0 +1,72 @@
+import { makeLineRouter } from "./internal/lineRouter.js";
+import { Writable } from "node:stream";
+
+// src/ui/CliUiRouteStream.ts
+/** The terminal facts a writer reads off its stream, delegated only where the original carries them. */
+const DELEGATED = [
+	"isTTY",
+	"columns",
+	"rows",
+	"getColorDepth",
+	"hasColors",
+	"getWindowSize"
+];
+const DEFAULT_MAX_HELD = 8192;
+/** Run one `Writable` step and settle its callback: with nothing, or with what the step threw, as an `Error`. */
+const guarded = (step, callback) => {
+	try {
+		step();
+		callback();
+	} catch (error) {
+		callback(error instanceof Error ? error : new Error(String(error)));
+	}
+};
+/** @internal */
+const routeStream = (original, printer, options) => {
+	const maxHeld = options.maxHeld ?? DEFAULT_MAX_HELD;
+	if (!Number.isInteger(maxHeld) || maxHeld < 0) throw new RangeError(`CliUi.routeStream: maxHeld must be a non-negative integer, got ${String(maxHeld)}`);
+	const router = makeLineRouter({
+		stream: options.stream,
+		printer,
+		write: (text) => {
+			original.write(text);
+		},
+		maxHeld,
+		carriageReturn: options.carriageReturn ?? "keep",
+		onText: options.onText
+	});
+	const writable = new Writable({
+		decodeStrings: false,
+		write(chunk, _encoding, callback) {
+			guarded(() => router.take(chunk), callback);
+		},
+		final(callback) {
+			guarded(router.flush, callback);
+		}
+	});
+	for (const key of DELEGATED) {
+		if (!(key in original)) continue;
+		let source;
+		let bound;
+		Object.defineProperty(writable, key, {
+			configurable: true,
+			enumerable: true,
+			get: () => {
+				const value = original[key];
+				if (typeof value !== "function") return value;
+				if (value !== source) {
+					source = value;
+					bound = value.bind(original);
+				}
+				return bound;
+			}
+		});
+	}
+	return {
+		writable,
+		route: router.route,
+		flush: router.flush
+	};
+};
+
+export { routeStream };

package/ui/DocView.js

@@ -1,3 +1,4 @@
+import { identity } from "../internal/displayPath.js";
 import { Render } from "../Render.js";
 import { fromReact, inkModules } from "./internal/ink.js";
 import { screenContext } from "./internal/ScreenContext.js";
@@ -6,7 +7,7 @@ import { useTerminalSize } from "./UiTheme.js";
 // src/ui/DocView.ts
 const OUTSIDE = "@effected/cli/ui: DocView was drawn with no ctx outside a screen, a live view or a UiProvider, so it has no theme";
 /** The context a `DocView` builds from its tree's theme: the theme's own paint, so token overrides hold. */
-const contextOf = (theme, width, neutralize) => ({
+const contextOf = (theme, width, neutralize, displayPath) => ({
 	...neutralize ? { neutralizeWorkflowCommands: true } : {},
 	width,
 	audience: "human",
@@ -14,7 +15,7 @@ const contextOf = (theme, width, neutralize) => ({
 	paint: theme.paint,
 	glyphs: theme.glyphs,
 	link: (_target, label) => label,
-	displayPath: (absolute) => absolute
+	displayPath
 });
 /** The document's lines as the kit's own renderer lays them out: plain at colour `none`, painted otherwise. */
 const linesOf = (doc, ctx) => {
@@ -31,12 +32,14 @@ const docView = fromReact((react) => {
 		const given = props.ctx;
 		const theme = screen?.theme;
 		const neutralize = screen?.neutralizeWorkflowCommands === true;
+		const displayPath = screen?.displayPath ?? identity;
 		if (given === void 0 && theme === void 0) throw new Error(OUTSIDE);
-		const ctx = react.useMemo(() => given ?? contextOf(theme, columns, neutralize), [
+		const ctx = react.useMemo(() => given ?? contextOf(theme, columns, neutralize, displayPath), [
 			given,
 			theme,
 			columns,
-			neutralize
+			neutralize,
+			displayPath
 		]);
 		const lines = react.useMemo(() => linesOf(props.doc, ctx), [props.doc, ctx]);
 		return react.createElement(ink.Box, {

package/ui/UiProvider.js

@@ -34,9 +34,11 @@ const UiProvider = (props) => {
 	const cancel = parent?.cancel;
 	const die = parent?.die;
 	const neutralize = props.value.neutralizeWorkflowCommands === true || parent?.neutralizeWorkflowCommands === true;
+	const displayPath = props.value.displayPath ?? parent?.displayPath;
 	const value = react.useMemo(() => ({
 		theme,
 		glyphs,
+		...displayPath === void 0 ? {} : { displayPath },
 		...columns === void 0 || rows === void 0 ? {} : { size: {
 			columns,
 			rows
@@ -51,7 +53,8 @@ const UiProvider = (props) => {
 		rows,
 		cancel,
 		die,
-		neutralize
+		neutralize,
+		displayPath
 	]);
 	return uiProviders(value, props.children);
 };

package/ui/internal/UiProviders.js

@@ -1,5 +1,8 @@
+import { underGithubActions } from "../../internal/autoFormat.js";
+import { CurrentDisplayPath } from "../../internal/displayPath.js";
 import { inkModules } from "./ink.js";
 import { screenContext } from "./ScreenContext.js";
+import { Effect } from "effect";
 
 // src/ui/internal/UiProviders.ts
 /**
@@ -16,5 +19,20 @@ const uiProviders = (value, children) => inkModules().react.createElement(screen
 	value,
 	children
 });
+/**
+* The base of a kit tree drawn with `theme`: its glyphs, `neutralizeWorkflowCommands` under the GitHub Actions
+* runner, and the run's path display. Read once per mount, so a screen, a live view and `CliUi.context` agree.
+*
+* @internal
+*/
+const treeBase = (theme) => Effect.gen(function* () {
+	const neutralize = yield* underGithubActions;
+	return {
+		theme,
+		glyphs: theme.glyphs,
+		...neutralize ? { neutralizeWorkflowCommands: true } : {},
+		displayPath: yield* CurrentDisplayPath
+	};
+});
 
-export { uiProviders };
+export { treeBase, uiProviders };

package/ui/internal/inkChalk.js

@@ -1,57 +1,47 @@
-import { createRequire } from "node:module";
 import { Option } from "effect";
-import { realpathSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
 
 // src/ui/internal/inkChalk.ts
 const isInkChalk = (value) => (typeof value === "function" || typeof value === "object" && value !== null) && typeof value.level === "number";
-/** The runtime's `import.meta.resolve`, when it has one. */
-const esmResolve = typeof import.meta.resolve === "function" ? (specifier) => import.meta.resolve(specifier) : void 0;
 /**
-* The path of Ink's entry: through `resolve` (the runtime's `import.meta.resolve` by default), or, where that is
-* missing or throws, through Node's CommonJS resolution from this module.
-*
-* @remarks
-* Vite's module runner, which evaluates a Vitest reporter loaded by path, has an `import.meta.resolve` that throws
-* ("not supported"); the CommonJS resolution finds the same file, since Ink's `exports` has a `default` condition.
-*
-* @param resolve - an ESM resolver, to stand in for the runtime's in a test
+* The runtime's `import.meta.resolve` for THIS module, when it has one. It resolves relative to the module that owns
+* it, so it has to be the kit's own: `ModuleResolution` cannot supply it.
 *
 * @internal
 */
-const resolveInkEntry = (resolve = esmResolve) => {
-	if (resolve !== void 0) try {
-		return fileURLToPath(resolve("ink"));
-	} catch {}
-	return createRequire(import.meta.url).resolve("ink");
-};
+const esmResolve = typeof import.meta.resolve === "function" ? (specifier) => import.meta.resolve(specifier) : void 0;
 /**
 * The chalk instance Ink itself imports, resolved from Ink's own location; `None` when it cannot be resolved.
 *
 * @remarks
-* One of the three files licensed to touch Node. Ink's `exports` has
-* only `"."` and chalk is its own dependency, so the kit cannot import Ink's chalk by name: a `chalk` of the kit's
-* own could be a different copy, and setting its level would silently change nothing. Resolving `chalk` from Ink's
-* entry ({@link resolveInkEntry}) and importing its realpath yields the very module Ink imports, because Node keys ES
-* modules by realpath. A consumer that bundles Ink leaves nothing
-* to resolve, and the answer is `None`; it never rejects.
+* Ink's `exports` has only `"."` and chalk is its own dependency, so the kit cannot import Ink's chalk by name: a
+* `chalk` of the kit's own could be a different copy, and setting its level would silently change nothing. So Ink's
+* entry is resolved from here (`esm` first, Node's CommonJS resolution where it is missing or throws, as under Vite's
+* module runner, which evaluates a Vitest reporter loaded by path), `chalk` is resolved from that entry to its
+* realpath, and that file is imported: Node keys ES modules by realpath, so it is the very module Ink imports. The
+* resolution is `@effected/commands/node-sync`'s `ModuleResolution`, loaded only when this runs, so importing `./ui`
+* loads none of it. A consumer that bundles Ink leaves nothing to resolve, and the answer is `None`; it never rejects.
 *
-* @param inkEntryOf - how Ink's entry is found; {@link resolveInkEntry} by default
+* @param esm - an ESM resolver relative to this module; the runtime's `import.meta.resolve` by default, and a stand-in
+*   in a test
 *
 * @internal
 */
-const inkChalk = async (inkEntryOf = () => resolveInkEntry()) => {
+const inkChalk = async (esm = esmResolve) => {
 	try {
-		const inkEntry = inkEntryOf();
-		const chalkPath = realpathSync(createRequire(inkEntry).resolve("chalk"));
-		const chalk = await import(
-			/* @vite-ignore */
-			pathToFileURL(chalkPath).href
-);
+		const { ModuleResolution } = await import("@effected/commands/node-sync");
+		const chalkPath = Option.flatMap(ModuleResolution.resolve("ink", {
+			from: import.meta.url,
+			esm
+		}), (entry) => ModuleResolution.resolve("chalk", {
+			from: entry,
+			realPath: true
+		}));
+		if (Option.isNone(chalkPath)) return Option.none();
+		const chalk = await ModuleResolution.load(chalkPath.value);
 		return isInkChalk(chalk.default) ? Option.some(chalk.default) : Option.none();
 	} catch {
 		return Option.none();
 	}
 };
 
-export { inkChalk, resolveInkEntry };
+export { esmResolve, inkChalk };

package/ui/internal/lineRouter.js

@@ -0,0 +1,70 @@
+import { isEscapeOnly } from "../../internal/displayWidth.js";
+
+// src/ui/internal/lineRouter.ts
+/** The text a printer is handed for one line: a CRLF's `\r` dropped, and under `last` only what the line ends on. */
+const printable = (line, carriageReturn) => {
+	const text = line.endsWith("\r") ? line.slice(0, -1) : line;
+	if (carriageReturn === "keep") return text;
+	const cut = text.lastIndexOf("\r");
+	return cut === -1 ? text : text.slice(cut + 1);
+};
+/** @internal */
+const makeLineRouter = (options) => {
+	const decoder = new TextDecoder("utf-8");
+	let held = "";
+	let routing = true;
+	const offer = (line) => {
+		if (!options.printer(options.stream, printable(line, options.carriageReturn))) options.write(`${line}\n`);
+	};
+	const route = (text) => {
+		if (text === "") return;
+		if (!routing) {
+			options.write(text);
+			return;
+		}
+		if (held === "" && isEscapeOnly(text)) {
+			options.write(text);
+			return;
+		}
+		if (!text.includes("\n")) {
+			held += text;
+			if (held.length > options.maxHeld) {
+				const line = held;
+				held = "";
+				offer(line);
+			}
+			return;
+		}
+		const lines = (held + text).split("\n");
+		const rest = lines.pop() ?? "";
+		if (rest.length > options.maxHeld) {
+			lines.push(rest);
+			held = "";
+		} else held = rest;
+		for (const line of lines) offer(line);
+	};
+	return {
+		take: (chunk) => {
+			const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+			if (text !== "") options.onText?.(text);
+			route(text);
+		},
+		route: (on) => {
+			if (!on && held !== "") {
+				options.write(held);
+				held = "";
+			}
+			routing = on;
+		},
+		flush: () => {
+			const pending = decoder.decode();
+			if (pending !== "") options.onText?.(pending);
+			const text = held + pending;
+			held = "";
+			if (text === "") return;
+			if (!routing || !options.printer(options.stream, printable(text, options.carriageReturn))) options.write(text);
+		}
+	};
+};
+
+export { makeLineRouter };

package/ui/testing/CliUiTest.js

@@ -236,7 +236,10 @@ const makeTerminal = (options, settings = { screens: "debug" }) => {
 		if (mode === "debug") return chunk;
 		const text = chunk.replace(FRAME_BRACKETS, "");
 		if (text === "" || CONTROLS_ONLY.test(text)) return void 0;
-		return text.replace(LEADING_MOVES, "").replace(/\n+$/, "");
+		const frame = text.replace(LEADING_MOVES, "");
+		let end = frame.length;
+		while (end > 0 && frame[end - 1] === "\n") end -= 1;
+		return frame.slice(0, end);
 	};
 	const fake = makeFakeStreams({
 		columns,