limina 0.1.2 → 0.2.0

package/chunks/dep-gI8bWpox.js

@@ -0,0 +1,1092 @@
+import { stripVTControlCharacters } from "node:util";
+//#region ../../node_modules/.pnpm/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+	return new RegExp(`(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))|[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`, onlyFirst ? void 0 : "g");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/strip-ansi@7.1.2/node_modules/strip-ansi/index.js
+const regex = ansiRegex();
+function stripAnsi(string) {
+	if (typeof string !== "string") throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+	return string.replace(regex, "");
+}
+const ambiguousRanges = [
+	161,
+	161,
+	164,
+	164,
+	167,
+	168,
+	170,
+	170,
+	173,
+	174,
+	176,
+	180,
+	182,
+	186,
+	188,
+	191,
+	198,
+	198,
+	208,
+	208,
+	215,
+	216,
+	222,
+	225,
+	230,
+	230,
+	232,
+	234,
+	236,
+	237,
+	240,
+	240,
+	242,
+	243,
+	247,
+	250,
+	252,
+	252,
+	254,
+	254,
+	257,
+	257,
+	273,
+	273,
+	275,
+	275,
+	283,
+	283,
+	294,
+	295,
+	299,
+	299,
+	305,
+	307,
+	312,
+	312,
+	319,
+	322,
+	324,
+	324,
+	328,
+	331,
+	333,
+	333,
+	338,
+	339,
+	358,
+	359,
+	363,
+	363,
+	462,
+	462,
+	464,
+	464,
+	466,
+	466,
+	468,
+	468,
+	470,
+	470,
+	472,
+	472,
+	474,
+	474,
+	476,
+	476,
+	593,
+	593,
+	609,
+	609,
+	708,
+	708,
+	711,
+	711,
+	713,
+	715,
+	717,
+	717,
+	720,
+	720,
+	728,
+	731,
+	733,
+	733,
+	735,
+	735,
+	768,
+	879,
+	913,
+	929,
+	931,
+	937,
+	945,
+	961,
+	963,
+	969,
+	1025,
+	1025,
+	1040,
+	1103,
+	1105,
+	1105,
+	8208,
+	8208,
+	8211,
+	8214,
+	8216,
+	8217,
+	8220,
+	8221,
+	8224,
+	8226,
+	8228,
+	8231,
+	8240,
+	8240,
+	8242,
+	8243,
+	8245,
+	8245,
+	8251,
+	8251,
+	8254,
+	8254,
+	8308,
+	8308,
+	8319,
+	8319,
+	8321,
+	8324,
+	8364,
+	8364,
+	8451,
+	8451,
+	8453,
+	8453,
+	8457,
+	8457,
+	8467,
+	8467,
+	8470,
+	8470,
+	8481,
+	8482,
+	8486,
+	8486,
+	8491,
+	8491,
+	8531,
+	8532,
+	8539,
+	8542,
+	8544,
+	8555,
+	8560,
+	8569,
+	8585,
+	8585,
+	8592,
+	8601,
+	8632,
+	8633,
+	8658,
+	8658,
+	8660,
+	8660,
+	8679,
+	8679,
+	8704,
+	8704,
+	8706,
+	8707,
+	8711,
+	8712,
+	8715,
+	8715,
+	8719,
+	8719,
+	8721,
+	8721,
+	8725,
+	8725,
+	8730,
+	8730,
+	8733,
+	8736,
+	8739,
+	8739,
+	8741,
+	8741,
+	8743,
+	8748,
+	8750,
+	8750,
+	8756,
+	8759,
+	8764,
+	8765,
+	8776,
+	8776,
+	8780,
+	8780,
+	8786,
+	8786,
+	8800,
+	8801,
+	8804,
+	8807,
+	8810,
+	8811,
+	8814,
+	8815,
+	8834,
+	8835,
+	8838,
+	8839,
+	8853,
+	8853,
+	8857,
+	8857,
+	8869,
+	8869,
+	8895,
+	8895,
+	8978,
+	8978,
+	9312,
+	9449,
+	9451,
+	9547,
+	9552,
+	9587,
+	9600,
+	9615,
+	9618,
+	9621,
+	9632,
+	9633,
+	9635,
+	9641,
+	9650,
+	9651,
+	9654,
+	9655,
+	9660,
+	9661,
+	9664,
+	9665,
+	9670,
+	9672,
+	9675,
+	9675,
+	9678,
+	9681,
+	9698,
+	9701,
+	9711,
+	9711,
+	9733,
+	9734,
+	9737,
+	9737,
+	9742,
+	9743,
+	9756,
+	9756,
+	9758,
+	9758,
+	9792,
+	9792,
+	9794,
+	9794,
+	9824,
+	9825,
+	9827,
+	9829,
+	9831,
+	9834,
+	9836,
+	9837,
+	9839,
+	9839,
+	9886,
+	9887,
+	9919,
+	9919,
+	9926,
+	9933,
+	9935,
+	9939,
+	9941,
+	9953,
+	9955,
+	9955,
+	9960,
+	9961,
+	9963,
+	9969,
+	9972,
+	9972,
+	9974,
+	9977,
+	9979,
+	9980,
+	9982,
+	9983,
+	10045,
+	10045,
+	10102,
+	10111,
+	11094,
+	11097,
+	12872,
+	12879,
+	57344,
+	63743,
+	65024,
+	65039,
+	65533,
+	65533,
+	127232,
+	127242,
+	127248,
+	127277,
+	127280,
+	127337,
+	127344,
+	127373,
+	127375,
+	127376,
+	127387,
+	127404,
+	917760,
+	917999,
+	983040,
+	1048573,
+	1048576,
+	1114109
+];
+const fullwidthRanges = [
+	12288,
+	12288,
+	65281,
+	65376,
+	65504,
+	65510
+];
+const wideRanges = [
+	4352,
+	4447,
+	8986,
+	8987,
+	9001,
+	9002,
+	9193,
+	9196,
+	9200,
+	9200,
+	9203,
+	9203,
+	9725,
+	9726,
+	9748,
+	9749,
+	9776,
+	9783,
+	9800,
+	9811,
+	9855,
+	9855,
+	9866,
+	9871,
+	9875,
+	9875,
+	9889,
+	9889,
+	9898,
+	9899,
+	9917,
+	9918,
+	9924,
+	9925,
+	9934,
+	9934,
+	9940,
+	9940,
+	9962,
+	9962,
+	9970,
+	9971,
+	9973,
+	9973,
+	9978,
+	9978,
+	9981,
+	9981,
+	9989,
+	9989,
+	9994,
+	9995,
+	10024,
+	10024,
+	10060,
+	10060,
+	10062,
+	10062,
+	10067,
+	10069,
+	10071,
+	10071,
+	10133,
+	10135,
+	10160,
+	10160,
+	10175,
+	10175,
+	11035,
+	11036,
+	11088,
+	11088,
+	11093,
+	11093,
+	11904,
+	11929,
+	11931,
+	12019,
+	12032,
+	12245,
+	12272,
+	12287,
+	12289,
+	12350,
+	12353,
+	12438,
+	12441,
+	12543,
+	12549,
+	12591,
+	12593,
+	12686,
+	12688,
+	12773,
+	12783,
+	12830,
+	12832,
+	12871,
+	12880,
+	42124,
+	42128,
+	42182,
+	43360,
+	43388,
+	44032,
+	55203,
+	63744,
+	64255,
+	65040,
+	65049,
+	65072,
+	65106,
+	65108,
+	65126,
+	65128,
+	65131,
+	94176,
+	94180,
+	94192,
+	94198,
+	94208,
+	101589,
+	101631,
+	101662,
+	101760,
+	101874,
+	110576,
+	110579,
+	110581,
+	110587,
+	110589,
+	110590,
+	110592,
+	110882,
+	110898,
+	110898,
+	110928,
+	110930,
+	110933,
+	110933,
+	110948,
+	110951,
+	110960,
+	111355,
+	119552,
+	119638,
+	119648,
+	119670,
+	126980,
+	126980,
+	127183,
+	127183,
+	127374,
+	127374,
+	127377,
+	127386,
+	127488,
+	127490,
+	127504,
+	127547,
+	127552,
+	127560,
+	127568,
+	127569,
+	127584,
+	127589,
+	127744,
+	127776,
+	127789,
+	127797,
+	127799,
+	127868,
+	127870,
+	127891,
+	127904,
+	127946,
+	127951,
+	127955,
+	127968,
+	127984,
+	127988,
+	127988,
+	127992,
+	128062,
+	128064,
+	128064,
+	128066,
+	128252,
+	128255,
+	128317,
+	128331,
+	128334,
+	128336,
+	128359,
+	128378,
+	128378,
+	128405,
+	128406,
+	128420,
+	128420,
+	128507,
+	128591,
+	128640,
+	128709,
+	128716,
+	128716,
+	128720,
+	128722,
+	128725,
+	128728,
+	128732,
+	128735,
+	128747,
+	128748,
+	128756,
+	128764,
+	128992,
+	129003,
+	129008,
+	129008,
+	129292,
+	129338,
+	129340,
+	129349,
+	129351,
+	129535,
+	129648,
+	129660,
+	129664,
+	129674,
+	129678,
+	129734,
+	129736,
+	129736,
+	129741,
+	129756,
+	129759,
+	129770,
+	129775,
+	129784,
+	131072,
+	196605,
+	196608,
+	262141
+];
+//#endregion
+//#region ../../node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js
+/**
+Binary search on a sorted flat array of [start, end] pairs.
+
+@param {number[]} ranges - Flat array of inclusive [start, end] range pairs, e.g. [0, 5, 10, 20].
+@param {number} codePoint - The value to search for.
+@returns {boolean} Whether the value falls within any of the ranges.
+*/
+const isInRange = (ranges, codePoint) => {
+	let low = 0;
+	let high = Math.floor(ranges.length / 2) - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const i = mid * 2;
+		if (codePoint < ranges[i]) high = mid - 1;
+		else if (codePoint > ranges[i + 1]) low = mid + 1;
+		else return true;
+	}
+	return false;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js
+const commonCjkCodePoint = 19968;
+const [wideFastPathStart, wideFastPathEnd] = /* #__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+	let fastPathStart = ranges[0];
+	let fastPathEnd = ranges[1];
+	for (let index = 0; index < ranges.length; index += 2) {
+		const start = ranges[index];
+		const end = ranges[index + 1];
+		if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) return [start, end];
+		if (end - start > fastPathEnd - fastPathStart) {
+			fastPathStart = start;
+			fastPathEnd = end;
+		}
+	}
+	return [fastPathStart, fastPathEnd];
+}
+const isAmbiguous = (codePoint) => {
+	if (codePoint < 161 || codePoint > 1114109) return false;
+	return isInRange(ambiguousRanges, codePoint);
+};
+const isFullWidth = (codePoint) => {
+	if (codePoint < 12288 || codePoint > 65510) return false;
+	return isInRange(fullwidthRanges, codePoint);
+};
+const isWide = (codePoint) => {
+	if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) return true;
+	if (codePoint < 4352 || codePoint > 262141) return false;
+	return isInRange(wideRanges, codePoint);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+	if (!Number.isSafeInteger(codePoint)) throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+	validate(codePoint);
+	if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) return 2;
+	return 1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/string-width@8.2.2/node_modules/string-width/index.js
+/**
+Logic:
+- Segment graphemes to match how terminals render clusters.
+- Width rules:
+1. Skip non-printing clusters (Default_Ignorable, Control, pure nonspacing/enclosing Mark, lone Surrogates). Tabs are ignored by design.
+2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
+3. Minimally-qualified/unqualified emoji clusters (ZWJ sequences with 2+ Extended_Pictographic, or keycap sequences) are double-width.
+4. Hangul jamo collapse each standard modern Hangul L+V or L+V+T syllable piece to width 2.
+Unmatched repeated leading/vowel/trailing jamo stay additive because that matches how the terminals we target render them.
+5. Otherwise use East Asian Width of the cluster's first visible code point, and add widths for trailing spacing marks and Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+*/
+const segmenter = new Intl.Segmenter();
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Nonspacing_Mark}|\p{Enclosing_Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Nonspacing_Mark}\p{Enclosing_Mark}\p{Surrogate}]+/v;
+const spacingMarkRegex = /\p{Spacing_Mark}/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+const unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+const extendedPictographicRegex = /\p{Extended_Pictographic}/gu;
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+	if (segment.length > 50) return false;
+	if (unqualifiedKeycapRegex.test(segment)) return true;
+	if (segment.includes("‍")) {
+		const pictographics = segment.match(extendedPictographicRegex);
+		return pictographics !== null && pictographics.length >= 2;
+	}
+	return false;
+}
+function baseVisible(segment) {
+	return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+	return zeroWidthClusterRegex.test(segment);
+}
+function isHangulLeadingJamo(codePoint) {
+	return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+	return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+	return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+	return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+	const codePoints = [];
+	for (const character of visibleSegment) {
+		if (zeroWidthClusterRegex.test(character)) continue;
+		codePoints.push(character.codePointAt(0));
+	}
+	if (codePoints.length === 0) return;
+	let width = 0;
+	for (let index = 0; index < codePoints.length; index++) {
+		const codePoint = codePoints[index];
+		if (!isHangulJamo(codePoint)) {
+			if (width === 0) return;
+			for (let remaining = index; remaining < codePoints.length; remaining++) width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+			return width;
+		}
+		if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+			width += 2;
+			index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+			continue;
+		}
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+	}
+	return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+	let extra = 0;
+	let first = true;
+	for (const character of visibleSegment) {
+		if (first) {
+			first = false;
+			continue;
+		}
+		if (spacingMarkRegex.test(character) || character >= "＀" && character <= "￯") extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+	}
+	return extra;
+}
+function stringWidth(input, options = {}) {
+	if (typeof input !== "string" || input.length === 0) return 0;
+	const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+	let string = input;
+	if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("›"))) string = stripAnsi(string);
+	if (string.length === 0) return 0;
+	if (/^[\u0020-\u007E]*$/.test(string)) return string.length;
+	let width = 0;
+	const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+	for (const { segment } of segmenter.segment(string)) {
+		if (isZeroWidthCluster(segment)) continue;
+		if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+			width += 2;
+			continue;
+		}
+		const visibleSegment = baseVisible(segment);
+		const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+		if (hangulWidth !== void 0) {
+			width += hangulWidth;
+			continue;
+		}
+		const codePoint = visibleSegment.codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+	}
+	return width;
+}
+//#endregion
+//#region src/flow/terminal-position.ts
+const TAB_STOP_COLUMNS = 8;
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function advanceColumns(position, width, columns) {
+	if (width <= 0) return;
+	if (position.column > 0 && position.column + width > columns) {
+		position.rowsAdvanced += 1;
+		position.column = 0;
+	}
+	position.column += width;
+	while (position.column >= columns) {
+		position.rowsAdvanced += 1;
+		position.column -= columns;
+	}
+}
+function stripTerminalControlSequences(text) {
+	return stripVTControlCharacters(text).replaceAll("\r", "");
+}
+function advanceTerminalPosition(text, columns, initialColumn = 0) {
+	const normalizedColumns = Math.max(1, columns);
+	const position = {
+		column: Math.max(0, initialColumn) % normalizedColumns,
+		rowsAdvanced: Math.floor(Math.max(0, initialColumn) / normalizedColumns)
+	};
+	const visibleText = stripTerminalControlSequences(text);
+	for (const { segment } of graphemeSegmenter.segment(visibleText)) {
+		if (segment === "\n") {
+			position.rowsAdvanced += 1;
+			position.column = 0;
+			continue;
+		}
+		if (segment === "	") {
+			advanceColumns(position, TAB_STOP_COLUMNS - position.column % TAB_STOP_COLUMNS, normalizedColumns);
+			continue;
+		}
+		advanceColumns(position, stringWidth(segment), normalizedColumns);
+	}
+	return position;
+}
+var TerminalTextStream = class {
+	#decoder = new TextDecoder();
+	#state = "text";
+	decode(chunk) {
+		const text = typeof chunk === "string" ? `${this.#decoder.decode()}${chunk}` : this.#decoder.decode(chunk, { stream: true });
+		let visibleText = "";
+		for (const character of text) switch (this.#state) {
+			case "control-string":
+				if (character === "\x07") this.#state = "text";
+				else if (character === "\x1B") this.#state = "control-string-escape";
+				break;
+			case "control-string-escape":
+				this.#state = character === "\\" ? "text" : "control-string";
+				break;
+			case "csi":
+				if (/^[\u0040-\u007E]$/u.test(character)) this.#state = "text";
+				break;
+			case "escape":
+				if (character === "[") this.#state = "csi";
+				else if (character === "]" || character === "P" || character === "X" || character === "^" || character === "_") this.#state = "control-string";
+				else this.#state = "text";
+				break;
+			case "text":
+				if (character === "\x1B") this.#state = "escape";
+				else if (character !== "\r") visibleText += character;
+				break;
+		}
+		return visibleText;
+	}
+	reset() {
+		this.#decoder = new TextDecoder();
+		this.#state = "text";
+	}
+};
+//#endregion
+//#region src/flow/render-model.ts
+const ANSI_RESET = "\x1B[0m";
+const ANSI_GREEN = "\x1B[32m";
+const ANSI_RED = "\x1B[31m";
+const ANSI_YELLOW = "\x1B[33m";
+const DEFAULT_TERMINAL_COLUMNS = 80;
+const TERMINAL_FRAME_MARGIN_LINES = 1;
+const TERMINAL_FRAME_CONTEXT_LINES = 6;
+const OMITTED_LINES_MARKER = "│  ...";
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const FLOW_SYMBOL_BY_STATUS = {
+	block: "⊘",
+	fail: "✕",
+	info: "│",
+	pass: "◆",
+	planned: "◇",
+	skip: "◇",
+	start: "◇",
+	warn: "▲"
+};
+function colorInteractiveSymbol(status, symbol) {
+	if (status === "pass") return `${ANSI_GREEN}${symbol}${ANSI_RESET}`;
+	if (status === "fail") return `${ANSI_RED}${symbol}${ANSI_RESET}`;
+	if (status === "warn" || status === "block") return `${ANSI_YELLOW}${symbol}${ANSI_RESET}`;
+	return symbol;
+}
+function formatElapsedTime(milliseconds) {
+	if (milliseconds < 1e3) return `${Math.round(milliseconds)}ms`;
+	return `${(milliseconds / 1e3).toFixed(2)}s`;
+}
+function formatMessageWithElapsed(message, elapsedTimeMs) {
+	return typeof elapsedTimeMs === "number" ? `${message} (${formatElapsedTime(elapsedTimeMs)})` : message;
+}
+function indentMessage(message, depth) {
+	if (depth <= 0) return message;
+	return `${"  ".repeat(depth)}${message}`;
+}
+function formatInteractiveLine(status, message, depth, spinnerFrameIndex) {
+	const renderedMessage = indentMessage(message, depth);
+	return `${colorInteractiveSymbol(status, status === "start" ? SPINNER_FRAMES[spinnerFrameIndex % SPINNER_FRAMES.length] : FLOW_SYMBOL_BY_STATUS[status])}    ${renderedMessage}`;
+}
+function toTreeFlowStatus(status) {
+	switch (status) {
+		case "blocked": return "block";
+		case "failed": return "fail";
+		case "passed": return "pass";
+		case "planned": return "planned";
+		case "running": return "start";
+		case "skipped": return "skip";
+	}
+	throw new Error(`Unsupported flow tree node status: ${status}`);
+}
+function isTreeNodeTerminal(node) {
+	return node.status === "failed" || node.status === "blocked" || node.status === "passed" || node.status === "skipped";
+}
+function areTreeNodeDescendantsTerminal(node) {
+	return node.children.every((child) => isTreeNodeTerminal(child) && areTreeNodeDescendantsTerminal(child));
+}
+function renderTreeNodeLine(node, spinnerFrameIndex) {
+	const elapsedTimeMs = isTreeNodeTerminal(node) && areTreeNodeDescendantsTerminal(node) ? node.elapsedTimeMs : void 0;
+	return formatInteractiveLine(toTreeFlowStatus(node.status), formatMessageWithElapsed(node.message, elapsedTimeMs), node.depth, spinnerFrameIndex);
+}
+function renderTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.flatMap((child) => renderTreeNodeLines(child, spinnerFrameIndex))];
+}
+function renderCompactTreeNodeLines(node, spinnerFrameIndex) {
+	return [renderTreeNodeLine(node, spinnerFrameIndex), ...node.children.map((child) => renderTreeNodeLine(child, spinnerFrameIndex))];
+}
+function renderSnapshotLines(snapshot, spinnerFrameIndex) {
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		return snapshot.treeRoots.flatMap((root) => renderTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function renderCompactSnapshotLines(snapshot, spinnerFrameIndex) {
+	const flowLineDepths = snapshot.entries.filter((entry) => entry.kind === "flow-line").map((entry) => entry.depth);
+	const maxCompactFlowLineDepth = flowLineDepths.length > 0 ? Math.min(...flowLineDepths) + 1 : Number.POSITIVE_INFINITY;
+	const lines = snapshot.entries.flatMap((entry) => {
+		if (entry.kind === "line") return [entry.line];
+		if (entry.kind === "flow-line") {
+			if (entry.depth > maxCompactFlowLineDepth) return [];
+			return [formatInteractiveLine(entry.status, formatMessageWithElapsed(entry.message, entry.elapsedTimeMs), entry.depth, spinnerFrameIndex)];
+		}
+		return snapshot.treeRoots.flatMap((root) => renderCompactTreeNodeLines(root, spinnerFrameIndex));
+	});
+	return snapshot.outroMessage ? [...lines, `└  ${snapshot.outroMessage}`] : lines;
+}
+function countRenderedTerminalRows(line, columns) {
+	return advanceTerminalPosition(line, columns).rowsAdvanced + 1;
+}
+function countRenderedRows(lines, dimensions) {
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS);
+	return lines.reduce((sum, line) => sum + countRenderedTerminalRows(line, columns), 0);
+}
+function fitsRenderedLines(lines, dimensions, options = {}) {
+	if (dimensions.rows === void 0) return true;
+	const contextLines = options.reserveContext && dimensions.rows > TERMINAL_FRAME_CONTEXT_LINES * 2 ? TERMINAL_FRAME_CONTEXT_LINES : 0;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES - contextLines);
+	return countRenderedRows(lines, dimensions) <= lineLimit;
+}
+function fitRenderedLinesToTerminal(lines, dimensions, options = {}) {
+	if (fitsRenderedLines(lines, dimensions) && !options.omittedLines) return lines;
+	if (dimensions.rows === void 0) return options.omittedLines ? addOmittedLinesMarker(lines) : lines;
+	const lineLimit = Math.max(1, dimensions.rows - TERMINAL_FRAME_MARGIN_LINES);
+	const columns = Math.max(1, dimensions.columns ?? DEFAULT_TERMINAL_COLUMNS);
+	const lastLine = lines.at(-1);
+	const shouldPreserveOutro = lastLine?.startsWith("└  ") ?? false;
+	const bodyLineCount = lines.length - (shouldPreserveOutro ? 1 : 0);
+	const bodyLines = lines.slice(0, bodyLineCount);
+	const ellipsisRows = countRenderedTerminalRows(OMITTED_LINES_MARKER, columns);
+	const reservedRows = shouldPreserveOutro && lastLine ? countRenderedTerminalRows(lastLine, columns) : 0;
+	const availableBodyRows = Math.max(0, lineLimit - reservedRows);
+	const bodyRows = countRenderedRows(bodyLines, { columns });
+	const shouldShowOmissionMarker = (options.omittedLines === true || bodyRows > availableBodyRows) && availableBodyRows >= ellipsisRows;
+	const fittedLines = [];
+	let remainingRows = availableBodyRows;
+	if (shouldShowOmissionMarker) remainingRows -= ellipsisRows;
+	for (let index = 0; index < bodyLineCount && remainingRows > 0; index++) {
+		const line = lines[index];
+		const rowCount = countRenderedTerminalRows(line, columns);
+		if (rowCount > remainingRows) break;
+		fittedLines.push(line);
+		remainingRows -= rowCount;
+	}
+	if (shouldShowOmissionMarker) fittedLines.push(OMITTED_LINES_MARKER);
+	if (shouldPreserveOutro && lastLine && reservedRows <= lineLimit) fittedLines.push(lastLine);
+	if (fittedLines.length > 0) return fittedLines;
+	return lines.slice(0, 1);
+}
+function addOmittedLinesMarker(lines) {
+	if (lines.includes(OMITTED_LINES_MARKER)) return lines;
+	const lastLine = lines.at(-1);
+	if (lastLine?.startsWith("└  ")) return [
+		...lines.slice(0, -1),
+		OMITTED_LINES_MARKER,
+		lastLine
+	];
+	return [...lines, OMITTED_LINES_MARKER];
+}
+function renderSnapshotLinesForTerminal(snapshot, spinnerFrameIndex, dimensions) {
+	const shouldPreferCompact = snapshot.compactMode === "check-flow" && snapshot.outroMessage !== void 0;
+	const fullLines = renderSnapshotLines(snapshot, spinnerFrameIndex);
+	if (!shouldPreferCompact && fitsRenderedLines(fullLines, dimensions, { reserveContext: true })) return fullLines;
+	const compactLines = renderCompactSnapshotLines(snapshot, spinnerFrameIndex);
+	return fitRenderedLinesToTerminal(compactLines, dimensions, { omittedLines: compactLines.length < fullLines.length });
+}
+function hasRunningSnapshotWork(snapshot) {
+	const hasRunningTreeNode = (node) => node.status === "running" || node.children.some(hasRunningTreeNode);
+	return snapshot.entries.some((entry) => entry.kind === "flow-line" && entry.status === "start") || snapshot.treeRoots.some(hasRunningTreeNode);
+}
+function toWritableText(chunk) {
+	if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString();
+	return chunk;
+}
+//#endregion
+//#region src/flow/terminal-frame.ts
+var TerminalFrameTracker = class {
+	#completedLineCount = 0;
+	#currentLine = "";
+	#textStream = new TerminalTextStream();
+	#getColumns;
+	constructor(getColumns) {
+		this.#getColumns = getColumns;
+	}
+	get lineCount() {
+		return this.#completedLineCount + advanceTerminalPosition(this.#currentLine, Math.max(1, this.#getColumns())).rowsAdvanced;
+	}
+	record(chunk) {
+		const text = this.#textStream.decode(chunk);
+		const columns = Math.max(1, this.#getColumns());
+		const lines = text.split("\n");
+		this.#currentLine += lines.shift() ?? "";
+		for (const line of lines) {
+			this.#completedLineCount += advanceTerminalPosition(this.#currentLine, columns).rowsAdvanced + 1;
+			this.#currentLine = line;
+		}
+	}
+	reset() {
+		this.#completedLineCount = 0;
+		this.#currentLine = "";
+		this.#textStream.reset();
+	}
+	setLineCount(lineCount) {
+		this.#completedLineCount = Math.max(0, lineCount);
+		this.#currentLine = "";
+		this.#textStream.reset();
+	}
+};
+function patchWriteStream(stream, onWrite) {
+	if (typeof stream?.write !== "function") return;
+	const originalWrite = stream.write;
+	const patchedWrite = (...args) => {
+		onWrite(args[0]);
+		return writeWithFlowArgs(originalWrite, args);
+	};
+	stream.write = patchedWrite;
+	return () => {
+		stream.write = originalWrite;
+	};
+}
+function writeWithFlowArgs(write, args) {
+	if (typeof args[1] === "string") return write(args[0], args[1], args[2]);
+	return write(args[0], args[1]);
+}
+//#endregion
+export { formatInteractiveLine as a, renderSnapshotLinesForTerminal as c, stripAnsi as d, SPINNER_FRAMES as i, toTreeFlowStatus as l, patchWriteStream as n, formatMessageWithElapsed as o, writeWithFlowArgs as r, hasRunningSnapshotWork as s, TerminalFrameTracker as t, toWritableText as u };