@effected/cli 0.13.0 → 0.15.0

package/Doc.js

@@ -379,12 +379,19 @@ var Doc = class {
 	/**
 	* Lines, one per entry, in every renderer: markdown joins them with hard breaks so they never collapse into one.
 	*
+	* @remarks
+	* `truncate` and `wrap: false` hold for every entry as they do for {@link Doc.line}: each entry is cut to the width,
+	* or kept whole on one line, rather than wrapped. Markdown keeps every entry whole either way.
+	*
 	* @param lines - the entries; each takes a string, an inline or an array of either
+	* @param options - `truncate`, to cut each entry to the width; `wrap: false`, to keep each whole
 	*/
-	static lines(lines) {
+	static lines(lines, options) {
 		return freeze({
 			_tag: "Lines",
-			lines: frozenArray(lines.map(inlines))
+			lines: frozenArray(lines.map(inlines)),
+			...options?.truncate === void 0 ? {} : { truncate: options.truncate },
+			...options?.wrap === void 0 ? {} : { wrap: options.wrap }
 		});
 	}
 	/**

package/Render.js

@@ -186,7 +186,7 @@ var Render = class {
 	*
 	* Under GitHub Actions (`neutralizeWorkflowCommands`) the same neutralizing applies, since markdown can be printed
 	* to the log. Markdown escapes `[` in text, so `##[` cannot appear outside code and the headings are untouched
-	* (a bare `##` is not a command); code spans and blocks, which are not escaped, get the zero-width space, which can
+	* (a bare `##` is not a command); code spans and blocks, which are not escaped, get the blank marker, which can
 	* also land inside code or table text where it would otherwise have formed a command.
 	*
 	* GitHub also turns `@user`, `@org/team`, `#123` and commit SHAs in rendered markdown into mentions and references.
@@ -238,8 +238,8 @@ var Render = class {
 	*
 	* The runner has two command parsers, and a line is a command if either accepts it: after its leading whitespace it
 	* starts with `::`, or `##[` occurs ANYWHERE in it (a bare `##` is not one). A document's text must not be able to
-	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a zero-width space in front, which
-	* the runner does not treat as whitespace, and every `##[` gets one between the `##` and the `[`. The text is
+	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
+	* front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
 	* otherwise unchanged. A
 	* group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
 	* that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience

package/index.d.ts

@@ -879,6 +879,8 @@ type Block = {
 } | {
   readonly _tag: "Lines";
   readonly lines: ReadonlyArray<ReadonlyArray<Inline>>;
+  readonly truncate?: boolean;
+  readonly wrap?: boolean;
 } | {
   readonly _tag: "Line";
   readonly content: ReadonlyArray<Inline>;
@@ -1312,9 +1314,17 @@ export declare class Doc {
   /**
    * Lines, one per entry, in every renderer: markdown joins them with hard breaks so they never collapse into one.
    *
+   * @remarks
+   * `truncate` and `wrap: false` hold for every entry as they do for {@link Doc.line}: each entry is cut to the width,
+   * or kept whole on one line, rather than wrapped. Markdown keeps every entry whole either way.
+   *
    * @param lines - the entries; each takes a string, an inline or an array of either
+   * @param options - `truncate`, to cut each entry to the width; `wrap: false`, to keep each whole
    */
-  static lines(lines: ReadonlyArray<InlineInput>): BlockOf<"Lines">;
+  static lines(lines: ReadonlyArray<InlineInput>, options?: {
+    readonly truncate?: boolean;
+    readonly wrap?: boolean;
+  }): BlockOf<"Lines">;
   /**
    * One line of content; with `truncate`, it is cut to the width with the glyph set's ellipsis instead of wrapping,
    * and with `wrap: false` it is kept whole on one line whatever the width.
@@ -3224,8 +3234,8 @@ interface RenderContext {
   /**
    * Whether the output will be read by the GitHub Actions runner, which has two command parsers: a line is a command
    * if, after .NET whitespace, it starts with `::`, or if `##[` occurs ANYWHERE in it (a bare `##` is not one). When
-   * `true`, `plain`, `ansi` and `markdown` put a zero-width space in front of such a `::` line and between `##` and
-   * `[` at each `##[`, so a document's text, an error message, say, can never inject a command. Unset or `false`
+   * `true`, `plain`, `ansi` and `markdown` put a braille pattern blank (U+2800, one blank cell) in front of such a
+   * `::` line and before the `[` of each `##[`, so a document's text, an error message, say, can never inject a command. Unset or `false`
    * leaves their text alone. `Render.githubLog` ignores it and always neutralizes: its output is for the runner by
    * definition.
    *
@@ -3418,7 +3428,7 @@ export declare class Render {
    *
    * Under GitHub Actions (`neutralizeWorkflowCommands`) the same neutralizing applies, since markdown can be printed
    * to the log. Markdown escapes `[` in text, so `##[` cannot appear outside code and the headings are untouched
-   * (a bare `##` is not a command); code spans and blocks, which are not escaped, get the zero-width space, which can
+   * (a bare `##` is not a command); code spans and blocks, which are not escaped, get the blank marker, which can
    * also land inside code or table text where it would otherwise have formed a command.
    *
    * GitHub also turns `@user`, `@org/team`, `#123` and commit SHAs in rendered markdown into mentions and references.
@@ -3470,8 +3480,8 @@ export declare class Render {
    *
    * The runner has two command parsers, and a line is a command if either accepts it: after its leading whitespace it
    * starts with `::`, or `##[` occurs ANYWHERE in it (a bare `##` is not one). A document's text must not be able to
-   * do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a zero-width space in front, which
-   * the runner does not treat as whitespace, and every `##[` gets one between the `##` and the `[`. The text is
+   * do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
+   * front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
    * otherwise unchanged. A
    * group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
    * that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience

package/internal/renderDoc.js

@@ -227,6 +227,13 @@ const countsLayout = (walk, block) => {
 		suffix
 	], " "))];
 };
+/** One `Line`, or one entry of a `Lines`: cut with `truncate`, kept whole with `wrap: false`, wrapped otherwise. */
+const lineOf = (walk, content, options, width) => {
+	const spans = oneLine(inline(walk, content));
+	if (options.truncate === true) return [trimLine(truncateSpans(spans, width, walk.ctx.glyphs.ellipsis))];
+	if (options.wrap === false) return [trimLine(spans)];
+	return spans.length === 0 ? [[]] : wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
+};
 /**
 * A block as lines. `compact` is set on a compact list's item: a section there joins its title and children with no
 * blank lines between them.
@@ -275,15 +282,11 @@ const blockLines = (walk, block, width, compact = false) => {
 		case "Annotation": return [];
 		case "CountsTable": return tableLines(walk, countsTableOf(block), width);
 		case "Lines": return block.lines.flatMap((entry) => {
+			if (block.truncate === true || block.wrap === false) return lineOf(walk, entry, block, width);
 			const spans = inline(walk, entry);
 			return spans.length === 0 ? [[]] : wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
 		});
-		case "Line": {
-			const spans = oneLine(inline(walk, block.content));
-			if (block.truncate === true) return [trimLine(truncateSpans(spans, width, walk.ctx.glyphs.ellipsis))];
-			if (block.wrap === false) return [trimLine(spans)];
-			return spans.length === 0 ? [[]] : wrapSpans(spans, width, { hardBreak: false }).map(trimLine);
-		}
+		case "Line": return lineOf(walk, block.content, block, width);
 		case "DiffText": {
 			const cap = capOf(block.cap);
 			const lines = textLines(block.text);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.13.0",
+	"version": "0.15.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,17 +57,17 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/github-commands": "^0.1.0"
+		"@effected/github-commands": "^0.2.0"
 	},
 	"peerDependencies": {
 		"@effected/config-file": "^0.14.2",
 		"@effected/env": "^0.1.0",
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",
-		"@types/react": "^19.2.0",
+		"@types/react": "^19.3.0",
 		"effect": "^4.0.0",
-		"ink": "^7.1.1",
-		"react": "^19.2.0"
+		"ink": "^8.0.0",
+		"react": "^19.3.0"
 	},
 	"peerDependenciesMeta": {
 		"@effected/config-file": {

package/ui/CliUiLive.js

@@ -10,7 +10,6 @@ import { UiStreams } from "./UiStreams.js";
 import { makeInkConsole } from "./internal/inkConsole.js";
 import { LazyViewShapeError, loadView } from "./internal/lazyView.js";
 import { mountPermit } from "./internal/mountPermit.js";
-import { drainPerformance, resolveDrain } from "./internal/perfDrain.js";
 import { UiRenderOptions } from "./internal/renderOptions.js";
 import { uiProviders } from "./internal/UiProviders.js";
 import { useTerminalSize } from "./UiTheme.js";
@@ -63,7 +62,6 @@ const live = (options) => Effect.gen(function* () {
 	const interactive = yield* CliInteractive;
 	const streams = yield* UiStreams;
 	const overrides = yield* UiRenderOptions;
-	const drain = yield* resolveDrain(options.drainPerformance ?? "auto");
 	const bridge = yield* makeInkConsole;
 	const inbox = yield* Queue.unbounded();
 	const source = options.events;
@@ -148,7 +146,6 @@ const live = (options) => Effect.gen(function* () {
 			}, elementOf(state, frame))
 		});
 		const text = yield* Effect.scoped(Effect.andThen(withInkColour(colour), Effect.sync(() => ink.renderToString(tree, { columns }))));
-		drainPerformance(drain);
 		if (failure !== void 0) return yield* warnOnce(current, failure.error);
 		bridge.print(neutralize ? CommandNeutralizer.text(text) : text);
 	});
@@ -220,7 +217,7 @@ const live = (options) => Effect.gen(function* () {
 				}))))
 			});
 			yield* Effect.acquireRelease(Effect.sync(() => {
-				const instance = ink.render(tree, {
+				return ink.render(tree, {
 					stdin: streams.stdin,
 					stdout: streams.stdout,
 					stderr: streams.stderr,
@@ -230,13 +227,10 @@ const live = (options) => Effect.gen(function* () {
 					...overrides.onRender === void 0 ? {} : { onRender: overrides.onRender },
 					...overrides.maxFps === void 0 ? {} : { maxFps: overrides.maxFps }
 				});
-				drainPerformance(drain);
-				return instance;
 			}), (instance) => Effect.promise(async () => {
 				bridge.detach();
 				const exited = instance.waitUntilExit();
 				instance.unmount();
-				drainPerformance(drain);
 				await exited.catch(() => void 0);
 			}));
 			yield* Effect.forkIn(Effect.repeat(Effect.flatMap(frameOf, (at) => Queue.offer(inbox, {
@@ -270,7 +264,6 @@ const live = (options) => Effect.gen(function* () {
 			yield* Effect.callback((resume) => {
 				mounted.slot.swap(elementOf(shown, frame), () => queueMicrotask(() => resume(Effect.void)));
 			});
-			drainPerformance(drain);
 			current.frame = frame;
 			if (current.failed === void 0) {
 				current.painted = true;

package/ui/UiTheme.js

@@ -69,6 +69,37 @@ const Styled = (props) => {
 };
 /** A reported size, or `fallback` when it is unknown: absent, or not positive (a pty `script` opens reports 0x0). */
 const known = (reported, fallback) => reported !== void 0 && reported > 0 ? reported : fallback;
+/** The redraws following each stream's size, and the one `resize` listener that calls them all. */
+const resizeFollowers = /* @__PURE__ */ new WeakMap();
+/**
+* Follow `stdout`'s size with `redraw`, returning the unfollow. However many components follow one stream, it holds
+* one `resize` listener, added with the first and removed with the last: one per component passed Node's default
+* limit of 10 on any list of `DocView` rows and printed a `MaxListenersExceededWarning` into the frame.
+*/
+const followResize = (stdout, redraw) => {
+	let entry = resizeFollowers.get(stdout);
+	if (entry === void 0) {
+		const redraws = /* @__PURE__ */ new Set();
+		const onResize = () => {
+			for (const each of redraws) each();
+		};
+		entry = {
+			redraws,
+			onResize
+		};
+		resizeFollowers.set(stdout, entry);
+		stdout.on("resize", onResize);
+	}
+	const { redraws, onResize } = entry;
+	redraws.add(redraw);
+	return () => {
+		redraws.delete(redraw);
+		if (redraws.size === 0 && resizeFollowers.get(stdout) === entry) {
+			resizeFollowers.delete(stdout);
+			stdout.off("resize", onResize);
+		}
+	};
+};
 /**
 * The usable terminal size: the stdout Ink draws on, less one column and one row, re-read on every render and when
 * the terminal resizes; or, under a `UiProvider` given a `size`, that size less one column and one row.
@@ -89,6 +120,9 @@ const known = (reported, fallback) => reported !== void 0 && reported > 0 ? repo
 * same paint, so give a long row Ink's `wrap: "truncate-end"` too: on a shrink Ink then clips it rather than letting
 * the terminal wrap it.
 *
+* Every component following one stdout shares a single `resize` listener on it, so a screen of many rows (a
+* `Viewport` of `DocView`s) holds one listener, not one per row.
+*
 * A React hook: call it from a component rendered inside an Ink tree; it needs no screen, but reads a `UiProvider`'s
 * size when there is one.
 *
@@ -100,15 +134,10 @@ const useTerminalSize = () => {
 	const override = react.useContext(screenContext())?.size;
 	const [, redraw] = react.useReducer((count) => count + 1, 0);
 	const followsStdout = override === void 0;
-	react.useEffect(() => {
-		if (!followsStdout) return void 0;
-		stdout.on("resize", redraw);
-		return () => {
-			stdout.off("resize", redraw);
-		};
-	}, [stdout, followsStdout]);
-	const columns = override?.columns ?? stdout.columns;
-	const rows = override?.rows ?? stdout.rows;
+	react.useEffect(() => followsStdout ? followResize(stdout, redraw) : void 0, [stdout, followsStdout]);
+	const reported = stdout;
+	const columns = override?.columns ?? reported.columns;
+	const rows = override?.rows ?? reported.rows;
 	return {
 		columns: Math.max(1, known(columns, 80) - 1),
 		rows: Math.max(1, known(rows, 24) - 1)

package/ui/testing/CliUiTest.js

@@ -218,6 +218,10 @@ const LEADING_MOVES = /^(?:\u001b\[[0-9;?]*[A-Za-ln-z])+/;
 * moves; a write of moves alone is Ink clearing the frame for a log line, not a frame. stdout and stderr are two
 * streams, each read alone, and `fake.written` is both in the order written: one terminal, for `written` and the
 * transcript.
+*
+* Ink calls `onRender` after it writes a render's frame, in the same synchronous turn, so the frame is the last
+* frame-like write of that turn. A production render whose write Ink's throttle defers to its trailing timer has
+* none yet: the next frame-like write is taken instead.
 */
 const makeTerminal = (options, settings = { screens: "debug" }) => {
 	const columns = options.columns ?? 80;
@@ -226,25 +230,48 @@ const makeTerminal = (options, settings = { screens: "debug" }) => {
 	const captures = [];
 	let lastWrite = 0;
 	let frameDue = false;
+	let turn = [];
+	/** A chunk read as a frame in `mode`, or `undefined` for one that is not a frame (brackets or moves alone). */
+	const asFrame = (chunk, mode) => {
+		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 fake = makeFakeStreams({
 		columns,
 		rows,
 		onStdoutWrite: (chunk) => {
 			lastWrite = Date.now();
+			if (turn.length === 0) {
+				const opened = turn;
+				queueMicrotask(() => {
+					if (turn === opened) turn = [];
+				});
+			}
+			turn.push(chunk);
 			const current = captures.at(-1);
 			if (!frameDue || current === void 0 || current.ended) return;
-			if (current.mode === "debug") {
-				frameDue = false;
-				current.raws.push(chunk);
-				return;
-			}
-			const text = chunk.replace(FRAME_BRACKETS, "");
-			if (text === "") return;
+			const frame = asFrame(chunk, current.mode);
+			if (frame === void 0) return;
 			frameDue = false;
-			if (CONTROLS_ONLY.test(text)) return;
-			current.raws.push(text.replace(LEADING_MOVES, "").replace(/\n+$/, ""));
+			current.raws.push(frame);
 		}
 	});
+	/** Called as Ink reports a render: take the frame it wrote this turn, or wait for the one its throttle defers. */
+	const rendered = () => {
+		const current = captures.at(-1);
+		if (current === void 0 || current.ended) return;
+		for (let index = turn.length - 1; index >= 0; index--) {
+			const frame = asFrame(turn[index], current.mode);
+			if (frame === void 0) continue;
+			turn = [];
+			frameDue = false;
+			current.raws.push(frame);
+			return;
+		}
+		frameDue = true;
+	};
 	const streams = fake.streams;
 	const stream = {
 		isTerminal: true,
@@ -263,9 +290,7 @@ const makeTerminal = (options, settings = { screens: "debug" }) => {
 	}).pipe(Layer.provide(terminal)), CliInteractive.layerTest(options.interactive ?? true), Layer.succeed(UiStreams, streams), Layer.succeed(UiRenderOptions, {
 		...settings.screens === "debug" ? { debug: true } : {},
 		maxFps: 1e3,
-		onRender: () => {
-			frameDue = true;
-		},
+		onRender: rendered,
 		onMount: (kind) => {
 			const mode = kind === "live" ? "production" : settings.screens;
 			captures.push({

package/ui/testing/terminalModel.js

@@ -6,8 +6,9 @@ const ESC = String.fromCharCode(27);
 *
 * @remarks
 * It applies printable text, line feeds, the erase and cursor moves Ink's log-update writes (erase line, cursor up,
-* cursor to column one), and the clears of Ink's clear-terminal frame: `ESC[2J` blanks the visible screen, `ESC[3J`
-* drops the scrollback above it, `ESC[H` homes the cursor to the screen's top left. The visible screen is the last
+* down and forward, cursor to a column, cursor to the next line), and the clears of Ink's full-clear frame: `ESC[J`
+* erases from the cursor to the end of the screen, `ESC[2J` blanks the visible screen, `ESC[3J` drops the scrollback
+* above it, `ESC[H` homes the cursor to the screen's top left. The visible screen is the last
 * `rows` lines; with `rows` unknown, the whole buffer counts as the screen, so a clear takes everything. Every other
 * escape is ignored. It does not wrap a line wider than the terminal. Shared by `CliUiTest.live`'s transcript and the
 * kit's own production-path tests.
@@ -38,8 +39,16 @@ const screenAfter = (written, rows) => {
 			}
 		} else if (command === "K") lines[row] = "";
 		else if (command === "A") row = Math.max(0, row - Number(params === "" ? 1 : params));
-		else if (command === "G") column = 0;
-		else if (command === "J" && params === "2") for (let index = screenTop(); index < lines.length; index++) lines[index] = "";
+		else if (command === "B" || command === "E") {
+			row += Number(params === "" ? 1 : params);
+			if (command === "E") column = 0;
+			while (lines.length <= row) lines.push("");
+		} else if (command === "C") column += Number(params === "" ? 1 : params);
+		else if (command === "G") column = Math.max(0, Number(params === "" ? 1 : params) - 1);
+		else if (command === "J" && (params === "" || params === "0")) {
+			lines[row] = (lines[row] ?? "").slice(0, column);
+			for (let index = row + 1; index < lines.length; index++) lines[index] = "";
+		} else if (command === "J" && params === "2") for (let index = screenTop(); index < lines.length; index++) lines[index] = "";
 		else if (command === "J" && params === "3") {
 			const top = screenTop();
 			lines.splice(0, top);

package/ui-testing.d.ts

@@ -179,11 +179,14 @@ interface CliUiTestSession {
    * before the call is not missed. It waits at most 2 s, then dies naming the screen's number, the text it waited
    * for and how many screens had mounted. The returned screen's frames start at its own mount. A screen that crashed
    * makes `next` die with the crash instead.
+   *
+   * A `CliUi.live` run counts as a mount too, each run of the view one of its own: a program that draws a live
+   * progress view before its first screen takes one `next` per run before the screen's.
    */
   readonly next: (options?: CliUiTestNextOptions) => Effect.Effect<CliUiTestScreen>;
   /**
    * How many screens have mounted so far: every run that started mounting, one whose thunk threw before Ink drew
-   * included.
+   * included, and every run of a `CliUi.live` view.
    */
   readonly mounts: Effect.Effect<number>;
   /** What the program wrote to stdout through `Console` (`log`, `info`, `debug`), one line per call. */

package/ui.d.ts

@@ -92,13 +92,6 @@ interface LiveOptions<E, S> {
    * turns without events. Anything but a positive, finite number is a defect.
    */
   readonly tickMillis?: number;
-  /**
-   * Clear React's user-timing entries after every render: `true`, `false`, or `"auto"` (the default), which clears
-   * unless `NODE_ENV` is exactly `"production"`. React's development build records them on every render and never
-   * clears them. The clear is process-wide: it removes every `measure` entry, a program's own included; marks are left
-   * alone.
-   */
-  readonly drainPerformance?: boolean | "auto";
 }
 /**
  * The handle of a live view.
@@ -1779,6 +1772,9 @@ export declare const Styled: (props: StyledProps) => ReactElement;
  * same paint, so give a long row Ink's `wrap: "truncate-end"` too: on a shrink Ink then clips it rather than letting
  * the terminal wrap it.
  *
+ * Every component following one stdout shares a single `resize` listener on it, so a screen of many rows (a
+ * `Viewport` of `DocView`s) holds one listener, not one per row.
+ *
  * A React hook: call it from a component rendered inside an Ink tree; it needs no screen, but reads a `UiProvider`'s
  * size when there is one.
  *

package/ui/internal/perfDrain.js

@@ -1,33 +0,0 @@
-import { Config, Effect } from "effect";
-
-//#region src/ui/internal/perfDrain.ts
-/**
-* Whether a drain mode drains: `true` and `false` as given, and `"auto"` unless `NODE_ENV` is exactly `"production"`.
-*
-* @remarks
-* React picks its development build whenever `NODE_ENV` is not exactly `"production"`, and that build records
-* user-timing entries on every render and never clears them. An
-* unset `NODE_ENV`, the common case for a CLI, leaks like `"development"`, so `"auto"` drains then too. `NODE_ENV` is
-* read through `Config`, so a test sets it with a `ConfigProvider` and `./ui` reads no `process`.
-*
-* @internal
-*/
-const resolveDrain = (mode) => mode === "auto" ? Config.String("NODE_ENV").pipe(Config.withDefault(""), Effect.map((env) => env !== "production"), Effect.orElseSucceed(() => true)) : Effect.succeed(mode);
-/**
-* Clear every user-timing `measure` entry in the process, when `drain` is true.
-*
-* @remarks
-* The clear is global: it removes a consumer's own measures too, because the platform's `clearMeasures` filters only
-* by name, and React's entries (`Update`, `Mount`, tagged `detail.devtools`) share their names with anything a
-* consumer might call a measure. Marks are left alone: React's development build leaks measures only, never marks,
-* so clearing marks would only take a host's own. A runtime without `performance` is left alone.
-*
-* @internal
-*/
-const drainPerformance = (drain) => {
-	if (!drain) return;
-	globalThis.performance?.clearMeasures?.();
-};
-
-//#endregion
-export { drainPerformance, resolveDrain };