effective-progress 0.5.3 → 0.6.0

package/dist/index.mjs

@@ -1,9 +1,454 @@
-import { Brand, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref, Schema } from "effect";
+import { Brand, Cause, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Schema } from "effect";
 import { dual } from "effect/Function";
-import { Writable } from "node:stream";
 import { Box, Text, render } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import stringWidth from "string-width";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
+//#region src/types.ts
+const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
+const TaskId = Brand.nominal();
+const TaskStatusSchema = Schema.Literal("running", "done", "failed");
+const TaskCountDisplaySchema = Schema.Literal("processedOnly", "detailed");
+var DeterminateTaskUnits = class extends Schema.TaggedClass()("DeterminateTaskUnits", {
+	succeeded: Schema.Number,
+	failed: Schema.Number,
+	processed: Schema.Number,
+	total: Schema.Number
+}) {};
+var IndeterminateTaskUnits = class extends Schema.TaggedClass()("IndeterminateTaskUnits", {}) {};
+const TaskUnitsSchema = Schema.Union(DeterminateTaskUnits, IndeterminateTaskUnits);
+var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
+	id: TaskIdSchema,
+	parentId: Schema.NullOr(TaskIdSchema),
+	description: Schema.String,
+	status: TaskStatusSchema,
+	countDisplay: TaskCountDisplaySchema,
+	transient: Schema.Boolean,
+	units: TaskUnitsSchema,
+	startedAt: Schema.Number,
+	completedAt: Schema.NullOr(Schema.Number)
+}) {};
+var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
+var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
+	taskId: TaskIdSchema,
+	parentId: Schema.NullOr(TaskIdSchema),
+	description: Schema.String,
+	total: Schema.optional(Schema.Number),
+	transient: Schema.Boolean,
+	countDisplay: TaskCountDisplaySchema
+}) {};
+var TaskUpdatedEvent = class extends Schema.TaggedClass()("TaskUpdated", {
+	taskId: TaskIdSchema,
+	description: Schema.optional(Schema.String),
+	succeeded: Schema.optional(Schema.Number),
+	failed: Schema.optional(Schema.Number),
+	processed: Schema.optional(Schema.Number),
+	total: Schema.optional(Schema.Number),
+	transient: Schema.optional(Schema.Boolean),
+	countDisplay: Schema.optional(TaskCountDisplaySchema)
+}) {};
+var TaskAdvancedEvent = class extends Schema.TaggedClass()("TaskAdvanced", {
+	taskId: TaskIdSchema,
+	amount: Schema.Number,
+	kind: Schema.Literal("succeeded", "failed")
+}) {};
+var TaskCompletedEvent = class extends Schema.TaggedClass()("TaskCompleted", { taskId: TaskIdSchema }) {};
+var TaskFailedEvent = class extends Schema.TaggedClass()("TaskFailed", { taskId: TaskIdSchema }) {};
+var TaskRemovedEvent = class extends Schema.TaggedClass()("TaskRemoved", { taskId: TaskIdSchema }) {};
+const ProgressTaskEventSchema = Schema.Union(TaskAddedEvent, TaskUpdatedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskRemovedEvent);
+const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);
+
+//#endregion
+//#region src/ink-renderer/snapshot/render-snapshot.ts
+const orderedVisibleTasks = (store) => store.renderOrder.flatMap((row) => {
+	const snapshot = store.tasks.get(row.id);
+	if (!snapshot || snapshot.transient && snapshot.status !== "running") return [];
+	return [{
+		snapshot,
+		depth: row.depth
+	}];
+});
+const computeTreeInfo = (ordered) => {
+	const hasNextSiblingByIndex = Array.from({ length: ordered.length }, () => false);
+	for (let i = 0; i < ordered.length; i++) {
+		const depth = ordered[i].depth;
+		for (let j = i + 1; j < ordered.length; j++) {
+			const candidateDepth = ordered[j].depth;
+			if (candidateDepth < depth) break;
+			if (candidateDepth === depth) {
+				hasNextSiblingByIndex[i] = true;
+				break;
+			}
+		}
+	}
+	const ancestorStateByDepth = [];
+	return ordered.map((entry, index) => {
+		const depth = entry.depth;
+		ancestorStateByDepth.length = depth;
+		const hasChildren = index + 1 < ordered.length && ordered[index + 1] !== void 0 && ordered[index + 1].depth > depth;
+		const tree = {
+			depth,
+			hasNextSibling: hasNextSiblingByIndex[index] ?? false,
+			hasChildren,
+			ancestorHasNextSibling: [...ancestorStateByDepth]
+		};
+		ancestorStateByDepth[depth] = hasNextSiblingByIndex[index] ?? false;
+		return {
+			...entry,
+			tree
+		};
+	});
+};
+const toRenderSnapshot = (store) => {
+	const visibleTasks = orderedVisibleTasks(store);
+	const hasRunningTasks = visibleTasks.some((entry) => entry.snapshot.status === "running");
+	return {
+		rows: computeTreeInfo(visibleTasks).map((entry) => ({
+			task: entry.snapshot,
+			tree: entry.tree
+		})),
+		hasRunningTasks
+	};
+};
+
+//#endregion
+//#region src/ink-renderer/store.ts
+const normalizeDeterminateCounts = (counts) => {
+	const total = Math.max(0, counts.total);
+	const failed = Math.min(total, Math.max(0, counts.failed));
+	const succeeded = Math.min(total - failed, Math.max(0, counts.succeeded));
+	return new DeterminateTaskUnits({
+		succeeded,
+		failed,
+		processed: succeeded + failed,
+		total
+	});
+};
+const updateDeterminateCounts = (units, options) => normalizeDeterminateCounts({
+	succeeded: options.succeeded ?? units.succeeded,
+	failed: options.failed ?? units.failed,
+	total: options.total ?? units.total
+});
+const updatedSnapshot = (snapshot, options) => {
+	const currentUnits = snapshot.units;
+	const units = (() => {
+		if (options.total !== void 0) {
+			if (options.total <= 0) return new IndeterminateTaskUnits({});
+			if (currentUnits._tag === "DeterminateTaskUnits") return updateDeterminateCounts(currentUnits, options);
+			return normalizeDeterminateCounts({
+				succeeded: options.succeeded ?? 0,
+				failed: options.failed ?? 0,
+				total: options.total
+			});
+		}
+		if (currentUnits._tag === "DeterminateTaskUnits") {
+			if (options.succeeded === void 0 && options.failed === void 0) return currentUnits;
+			return updateDeterminateCounts(currentUnits, options);
+		}
+		return currentUnits;
+	})();
+	return new TaskSnapshot({
+		id: snapshot.id,
+		parentId: snapshot.parentId,
+		description: options.description ?? snapshot.description,
+		status: snapshot.status,
+		countDisplay: options.countDisplay ?? snapshot.countDisplay,
+		transient: options.transient ?? snapshot.transient,
+		units,
+		startedAt: snapshot.startedAt,
+		completedAt: snapshot.completedAt
+	});
+};
+const withTransient = (snapshot, transient) => new TaskSnapshot({
+	id: snapshot.id,
+	parentId: snapshot.parentId,
+	description: snapshot.description,
+	status: snapshot.status,
+	countDisplay: snapshot.countDisplay,
+	transient,
+	units: snapshot.units,
+	startedAt: snapshot.startedAt,
+	completedAt: snapshot.completedAt
+});
+const findInsertionIndex = (renderOrder, parentId) => {
+	if (parentId === null) return {
+		index: renderOrder.length,
+		depth: 0
+	};
+	const parentIdx = renderOrder.findIndex((row) => row.id === parentId);
+	if (parentIdx === -1) return {
+		index: renderOrder.length,
+		depth: 0
+	};
+	const parentDepth = renderOrder[parentIdx].depth;
+	let i = parentIdx + 1;
+	while (i < renderOrder.length && renderOrder[i].depth > parentDepth) i++;
+	return {
+		index: i,
+		depth: parentDepth + 1
+	};
+};
+const removeFromRenderOrder = (renderOrder, taskId) => {
+	const idx = renderOrder.findIndex((row) => row.id === taskId);
+	if (idx === -1) return renderOrder;
+	const taskDepth = renderOrder[idx].depth;
+	let end = idx + 1;
+	while (end < renderOrder.length && renderOrder[end].depth > taskDepth) end++;
+	const next = [...renderOrder];
+	next.splice(idx, end - idx);
+	return next;
+};
+const SNAPSHOT_PUBLISH_INTERVAL_MILLIS = 50;
+const makeProgressRenderStore = () => {
+	let nextTaskId = 0;
+	let state = {
+		tasks: /* @__PURE__ */ new Map(),
+		renderOrder: []
+	};
+	let publishedSnapshot = toRenderSnapshot(state);
+	let hasPendingPublish = false;
+	let lastPublishAt = 0;
+	let publishTimeout;
+	const listeners = /* @__PURE__ */ new Set();
+	const notifyListeners = () => {
+		for (const listener of listeners) listener();
+	};
+	const publishNow = () => {
+		hasPendingPublish = false;
+		lastPublishAt = Date.now();
+		publishedSnapshot = toRenderSnapshot(state);
+		notifyListeners();
+	};
+	const clearScheduledPublish = () => {
+		if (publishTimeout === void 0) return;
+		clearTimeout(publishTimeout);
+		publishTimeout = void 0;
+	};
+	const schedulePublish = () => {
+		if (!hasPendingPublish) return;
+		const now = Date.now();
+		const waitMillis = Math.max(0, SNAPSHOT_PUBLISH_INTERVAL_MILLIS - (now - lastPublishAt));
+		if (waitMillis === 0) {
+			clearScheduledPublish();
+			publishNow();
+			return;
+		}
+		if (publishTimeout !== void 0) return;
+		publishTimeout = setTimeout(() => {
+			publishTimeout = void 0;
+			if (!hasPendingPublish) return;
+			publishNow();
+		}, waitMillis);
+	};
+	const publish = (nextState) => {
+		if (nextState === state) return;
+		state = nextState;
+		hasPendingPublish = true;
+		schedulePublish();
+	};
+	const updateState = (transform) => {
+		publish(transform(state));
+	};
+	return {
+		getSnapshot: () => publishedSnapshot,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		flush: () => {
+			if (!hasPendingPublish) return;
+			clearScheduledPublish();
+			publishNow();
+		},
+		addTask: (options) => Effect.gen(function* () {
+			const taskId = TaskId(++nextTaskId);
+			const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({}) : normalizeDeterminateCounts({
+				succeeded: 0,
+				failed: 0,
+				total: options.total
+			});
+			const parentSnapshot = options.parentId === void 0 ? void 0 : state.tasks.get(options.parentId);
+			const now = yield* Clock.currentTimeMillis;
+			const parentId = options.parentId ?? null;
+			const countDisplay = options.countDisplay ?? parentSnapshot?.countDisplay ?? "detailed";
+			const task = new TaskSnapshot({
+				id: taskId,
+				parentId,
+				description: options.description,
+				status: "running",
+				countDisplay,
+				transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
+				units,
+				startedAt: now,
+				completedAt: null
+			});
+			updateState((current) => {
+				const nextTasks = new Map(current.tasks);
+				nextTasks.set(taskId, task);
+				const { index, depth } = findInsertionIndex(current.renderOrder, parentId);
+				const nextRenderOrder = [...current.renderOrder];
+				nextRenderOrder.splice(index, 0, {
+					id: taskId,
+					depth
+				});
+				return {
+					tasks: nextTasks,
+					renderOrder: nextRenderOrder
+				};
+			});
+			return taskId;
+		}),
+		updateTask: (taskId, options) => Effect.sync(() => {
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask) return current;
+				const nextTasks = new Map(current.tasks);
+				const nextTask = updatedSnapshot(currentTask, options);
+				nextTasks.set(taskId, nextTask);
+				if (options.transient !== void 0) for (const [candidateId, candidate] of current.tasks.entries()) {
+					if (candidateId === taskId) continue;
+					let parentId = candidate.parentId;
+					let isDescendant = false;
+					while (parentId !== null) {
+						if (parentId === taskId) {
+							isDescendant = true;
+							break;
+						}
+						parentId = current.tasks.get(parentId)?.parentId ?? null;
+					}
+					if (isDescendant) nextTasks.set(candidateId, withTransient(candidate, nextTask.transient));
+				}
+				return {
+					tasks: nextTasks,
+					renderOrder: current.renderOrder
+				};
+			});
+		}),
+		addSuccess: (taskId, amount = 1) => Effect.sync(() => {
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask || currentTask.units._tag !== "DeterminateTaskUnits") return current;
+				const nextTasks = new Map(current.tasks);
+				nextTasks.set(taskId, new TaskSnapshot({
+					id: currentTask.id,
+					parentId: currentTask.parentId,
+					description: currentTask.description,
+					status: currentTask.status,
+					countDisplay: currentTask.countDisplay,
+					transient: currentTask.transient,
+					units: normalizeDeterminateCounts({
+						succeeded: currentTask.units.succeeded + amount,
+						failed: currentTask.units.failed,
+						total: currentTask.units.total
+					}),
+					startedAt: currentTask.startedAt,
+					completedAt: currentTask.completedAt
+				}));
+				return {
+					tasks: nextTasks,
+					renderOrder: current.renderOrder
+				};
+			});
+		}),
+		addFailure: (taskId, amount = 1) => Effect.sync(() => {
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask || currentTask.units._tag !== "DeterminateTaskUnits") return current;
+				const nextTasks = new Map(current.tasks);
+				nextTasks.set(taskId, new TaskSnapshot({
+					id: currentTask.id,
+					parentId: currentTask.parentId,
+					description: currentTask.description,
+					status: currentTask.status,
+					countDisplay: currentTask.countDisplay,
+					transient: currentTask.transient,
+					units: normalizeDeterminateCounts({
+						succeeded: currentTask.units.succeeded,
+						failed: currentTask.units.failed + amount,
+						total: currentTask.units.total
+					}),
+					startedAt: currentTask.startedAt,
+					completedAt: currentTask.completedAt
+				}));
+				return {
+					tasks: nextTasks,
+					renderOrder: current.renderOrder
+				};
+			});
+		}),
+		completeTask: (taskId) => Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask) return current;
+				const nextTasks = new Map(current.tasks);
+				if (currentTask.transient) {
+					nextTasks.delete(taskId);
+					return {
+						tasks: nextTasks,
+						renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+					};
+				}
+				nextTasks.set(taskId, new TaskSnapshot({
+					id: currentTask.id,
+					parentId: currentTask.parentId,
+					description: currentTask.description,
+					status: "done",
+					countDisplay: currentTask.countDisplay,
+					transient: currentTask.transient,
+					units: currentTask.units._tag === "DeterminateTaskUnits" ? normalizeDeterminateCounts({
+						succeeded: currentTask.units.total - currentTask.units.failed,
+						failed: currentTask.units.failed,
+						total: currentTask.units.total
+					}) : currentTask.units,
+					startedAt: currentTask.startedAt,
+					completedAt: now
+				}));
+				return {
+					tasks: nextTasks,
+					renderOrder: current.renderOrder
+				};
+			});
+		}),
+		failTask: (taskId) => Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask) return current;
+				const nextTasks = new Map(current.tasks);
+				if (currentTask.transient) {
+					nextTasks.delete(taskId);
+					return {
+						tasks: nextTasks,
+						renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+					};
+				}
+				nextTasks.set(taskId, new TaskSnapshot({
+					id: currentTask.id,
+					parentId: currentTask.parentId,
+					description: currentTask.description,
+					status: "failed",
+					countDisplay: currentTask.countDisplay,
+					transient: currentTask.transient,
+					units: currentTask.units,
+					startedAt: currentTask.startedAt,
+					completedAt: now
+				}));
+				return {
+					tasks: nextTasks,
+					renderOrder: current.renderOrder
+				};
+			});
+		}),
+		getTask: (taskId) => Effect.sync(() => Option.fromNullable(state.tasks.get(taskId))),
+		listTasks: Effect.sync(() => Array.from(state.tasks.values()))
+	};
+};
+
+//#endregion
 //#region src/ink-renderer/format.ts
 const SPINNER_FRAMES = [
 	"⠋",
@@ -34,669 +479,999 @@ const formatElapsed = (task, now) => {
 };
 const formatEta = (task, now) => {
 	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return "";
-	const { completed, total } = task.units;
-	const remaining = total - completed;
-	if (completed <= 0 || remaining <= 0) return "";
+	const { processed, total } = task.units;
+	const remaining = total - processed;
+	if (processed <= 0 || remaining <= 0) return "";
 	const elapsedMillis = Math.max(1, now - task.startedAt);
-	return formatDurationSeconds(Math.max(0, Math.floor(elapsedMillis / completed * remaining)) / 1e3);
+	return formatDurationSeconds(Math.max(0, Math.floor(elapsedMillis / processed * remaining)) / 1e3);
 };
-const formatAmount = (task, tick) => {
+const getTaskIndicator = (task, tick) => {
+	if (task.status === "running") return {
+		symbol: SPINNER_FRAMES[tick % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0],
+		color: "yellow"
+	};
+	if (task.status === "failed") return {
+		symbol: "✗",
+		color: "red"
+	};
+	if (task.units._tag !== "DeterminateTaskUnits") return {
+		symbol: "✓",
+		color: "green"
+	};
+	const { succeeded, failed, processed, total } = task.units;
+	if (failed === 0 && processed === total) return {
+		symbol: "✓",
+		color: "green"
+	};
+	if (failed > 0 && succeeded > 0) return {
+		symbol: "~",
+		color: "yellow"
+	};
+	if (failed > 0 && succeeded === 0) return {
+		symbol: "✗",
+		color: "red"
+	};
+	return {
+		symbol: "✓",
+		color: "green"
+	};
+};
+const formatDeterminateAmountParts = (task) => {
+	if (task.units._tag !== "DeterminateTaskUnits") return;
+	const totalText = `${task.units.total}`;
+	const width = totalText.length;
+	const processedText = `${task.units.processed}`;
+	return {
+		succeeded: task.countDisplay === "detailed" ? `${task.units.succeeded}`.padStart(width, " ") : "",
+		failed: task.countDisplay === "detailed" ? `${task.units.failed}`.padStart(width, " ") : "",
+		processed: processedText,
+		total: totalText
+	};
+};
+const formatAmount = (task, _tick) => {
 	if (task.units._tag === "DeterminateTaskUnits") {
-		const totalText = `${task.units.total}`;
-		return `${`${task.units.completed}`.padStart(totalText.length, " ")}/${totalText}`;
+		const parts = formatDeterminateAmountParts(task);
+		if (parts === void 0) return "";
+		if (task.countDisplay === "detailed") return `${parts.succeeded} ${parts.failed} ${parts.processed}/${parts.total}`;
+		return `${parts.processed}/${parts.total}`;
 	}
-	if (task.status === "running") return SPINNER_FRAMES[(task.units.spinnerFrame + tick) % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0];
-	return task.status === "done" ? "✓" : "✗";
+	if (task.status === "running" && task.units._tag === "IndeterminateTaskUnits") return "";
+	return task.status === "failed" ? "✗" : "";
 };
 
 //#endregion
-//#region src/ink-renderer/tree.ts
-const treeAncestorPrefix = (tree) => tree.ancestorHasNextSibling.slice(1).map((hasNext) => hasNext ? "│  " : "   ").join("");
-const renderTreePrefix = (tree) => {
-	if (tree.depth <= 0) return "";
-	return `${treeAncestorPrefix(tree)}${tree.hasNextSibling ? "├─ " : "└─ "}`;
+//#region src/ink-renderer/columns/determinate.ts
+const isDeterminate = (task) => task.units._tag === "DeterminateTaskUnits";
+const hasDeterminateRows = (rows) => rows.some((row) => isDeterminate(row.task));
+
+//#endregion
+//#region src/ink-renderer/columns/spec.ts
+const WIDTH_CACHE_LIMIT = 4096;
+const widthCache = /* @__PURE__ */ new Map();
+const textWidth = (text) => {
+	const cached = widthCache.get(text);
+	if (cached !== void 0) return cached;
+	const width = stringWidth(text);
+	if (widthCache.size >= WIDTH_CACHE_LIMIT) widthCache.clear();
+	widthCache.set(text, width);
+	return width;
 };
-const computeTreeInfo = (ordered) => {
-	const hasNextSiblingByIndex = Array.from({ length: ordered.length }, () => false);
-	for (let i = 0; i < ordered.length; i++) {
-		const depth = ordered[i].depth;
-		for (let j = i + 1; j < ordered.length; j++) {
-			const candidateDepth = ordered[j].depth;
-			if (candidateDepth < depth) break;
-			if (candidateDepth === depth) {
-				hasNextSiblingByIndex[i] = true;
-				break;
-			}
-		}
+const resolveColumnSpec = (spec, resistance) => ({
+	id: spec.id,
+	grow: spec.grow,
+	canHide: spec.canHide,
+	variants: spec.variants.map((variant) => ({
+		id: variant.id,
+		minWidth: variant.minWidth,
+		idealWidth: variant.idealWidth,
+		maxWidth: variant.maxWidth,
+		shrinkResistance: resistance.shrink(spec.id, variant.id),
+		demoteResistance: resistance.demote(spec.id, variant.id),
+		hideResistance: resistance.hide(spec.id, variant.id),
+		renderCell: variant.renderCell
+	}))
+});
+const resolveColumnSpecs = (specs, resistance) => specs.flatMap((spec) => spec.variants.length > 0 ? [resolveColumnSpec(spec, resistance)] : []);
+
+//#endregion
+//#region src/ink-renderer/columns/amount-column.tsx
+const padLeft = (value, width) => value.padStart(Math.max(0, width), " ");
+const padRight = (value, width) => value.padEnd(Math.max(0, width), " ");
+const blank = (width) => " ".repeat(Math.max(0, width));
+const shouldShowDetailedCounts = (task) => task.units._tag === "DeterminateTaskUnits" && task.countDisplay === "detailed";
+const SucceededCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, {
+		color: "green",
+		children: padLeft(`${task.units.succeeded}`, width)
+	});
+};
+const FailedCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, {
+		color: "red",
+		children: padLeft(`${task.units.failed}`, width)
+	});
+};
+const ProcessedCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, { children: padLeft(`${task.units.processed}`, width) });
+};
+const AmountSeparatorColumn = ({ task, tick }) => {
+	if (task.units._tag === "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: "/" });
+	const symbol = formatAmount(task, tick);
+	if (task.status === "failed") return /* @__PURE__ */ jsx(Text, {
+		color: "red",
+		children: symbol
+	});
+	if (task.status === "running") return /* @__PURE__ */ jsx(Text, {
+		color: "yellow",
+		children: symbol
+	});
+	return /* @__PURE__ */ jsx(Text, { children: symbol });
+};
+const TotalCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, { children: padRight(`${task.units.total}`, width) });
+};
+const AmountColumn = ({ task, tick, layout }) => {
+	if (layout.kind === "text") {
+		const text = formatAmount(task, tick);
+		if (task.status === "failed") return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			color: "red",
+			children: text
+		});
+		if (task.status === "running") return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			color: "yellow",
+			children: text
+		});
+		return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			children: text
+		});
 	}
-	const ancestorStateByDepth = [];
-	return ordered.map((entry, index) => {
-		const depth = entry.depth;
-		ancestorStateByDepth.length = depth;
-		const hasChildren = index + 1 < ordered.length && ordered[index + 1] !== void 0 && ordered[index + 1].depth > depth;
-		const tree = {
-			depth,
-			hasNextSibling: hasNextSiblingByIndex[index] ?? false,
-			hasChildren,
-			ancestorHasNextSibling: [...ancestorStateByDepth]
-		};
-		ancestorStateByDepth[depth] = hasNextSiblingByIndex[index] ?? false;
-		return {
-			...entry,
-			tree
-		};
+	if (layout.kind === "processed") return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "row",
+		children: [
+			/* @__PURE__ */ jsx(ProcessedCountColumn, {
+				task,
+				width: layout.processedWidth
+			}),
+			/* @__PURE__ */ jsx(AmountSeparatorColumn, {
+				task,
+				tick
+			}),
+			/* @__PURE__ */ jsx(TotalCountColumn, {
+				task,
+				width: layout.totalWidth
+			})
+		]
+	});
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "row",
+		children: [
+			layout.succeededWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(SucceededCountColumn, {
+				task,
+				width: layout.succeededWidth
+			}), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
+			layout.failedWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(FailedCountColumn, {
+				task,
+				width: layout.failedWidth
+			}), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
+			/* @__PURE__ */ jsx(ProcessedCountColumn, {
+				task,
+				width: layout.processedWidth
+			}),
+			/* @__PURE__ */ jsx(AmountSeparatorColumn, {
+				task,
+				tick
+			}),
+			/* @__PURE__ */ jsx(TotalCountColumn, {
+				task,
+				width: layout.totalWidth
+			})
+		]
 	});
 };
-
-//#endregion
-//#region src/ink-renderer/layout.ts
-const DEFAULT_BAR_WIDTH = 20;
-const MIN_DESCRIPTION_WIDTH = 8;
-const MIN_BAR_WIDTH = 8;
-const MIN_ELAPSED_WIDTH = 3;
-const MIN_AMOUNT_WIDTH = 1;
-const BASELINE_ROW_WIDTH = 100;
-const MIN_DESCRIPTION_COLUMNS_FOR_TREE = 24;
-const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
-const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
-const textWidth = (text) => Array.from(text).length;
-const computeWidths = (rows, now, tick, terminalColumns, includeTree = true) => {
+const computeAmountMetrics = (rows, tick) => {
 	let hasDeterminate = false;
-	let description = MIN_DESCRIPTION_WIDTH;
-	let amount = 1;
-	let elapsed = RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR;
-	let eta = RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR;
+	let hasDetailed = false;
+	let totalDigits = 0;
+	let simpleTextWidth = 0;
 	for (const row of rows) {
-		const { task, tree } = row;
-		const treePrefix = includeTree ? renderTreePrefix(tree) : "";
-		description = Math.max(description, textWidth(`${treePrefix}${task.description}`));
-		if (task.units._tag === "DeterminateTaskUnits") hasDeterminate = true;
-		amount = Math.max(amount, textWidth(formatAmount(task, tick)));
-		elapsed = Math.max(elapsed, textWidth(formatElapsed(task, now)));
-		if (task.status === "running" && task.units._tag === "DeterminateTaskUnits") {
-			const etaValue = formatEta(task, now);
-			const etaText = `ETA: ${etaValue.length > 0 ? etaValue : "--"}`;
-			eta = Math.max(eta, textWidth(etaText));
+		const { task } = row;
+		if (isDeterminate(task)) {
+			hasDeterminate = true;
+			totalDigits = Math.max(totalDigits, textWidth(`${task.units.total}`));
+			if (task.countDisplay === "detailed") hasDetailed = true;
+			continue;
 		}
-	}
-	let widths = {
-		description,
-		bar: hasDeterminate ? DEFAULT_BAR_WIDTH : 0,
-		amount,
-		elapsed,
-		eta
-	};
-	const visible = (w) => [
-		w.description,
-		w.bar,
-		w.amount,
-		w.elapsed,
-		w.eta
-	].filter((width) => width > 0);
-	const total = (w) => {
-		const cols = visible(w);
-		return cols.reduce((sum, width) => sum + width, 0) + Math.max(0, cols.length - 1);
-	};
-	const baselineTarget = Math.max(BASELINE_ROW_WIDTH, total(widths));
-	const target = terminalColumns === void 0 ? baselineTarget : Math.max(1, Math.min(Math.max(1, Math.floor(terminalColumns)), baselineTarget));
-	if (total(widths) < target) widths.description += target - total(widths);
-	else if (total(widths) > target) {
-		let overflow = total(widths) - target;
-		const reduceBy = (key, min) => {
-			if (overflow <= 0) return;
-			const current = widths[key];
-			if (current <= min) return;
-			const reducible = current - min;
-			const delta = Math.min(reducible, overflow);
-			widths = {
-				...widths,
-				[key]: current - delta
-			};
-			overflow -= delta;
-		};
-		reduceBy("description", MIN_DESCRIPTION_WIDTH);
-		reduceBy("eta", 0);
-		reduceBy("bar", MIN_BAR_WIDTH);
-		reduceBy("bar", 0);
-		reduceBy("elapsed", MIN_ELAPSED_WIDTH);
-		reduceBy("amount", MIN_AMOUNT_WIDTH);
-		reduceBy("description", 0);
-		if (total(widths) < target) widths.description += target - total(widths);
+		simpleTextWidth = Math.max(simpleTextWidth, textWidth(formatAmount(task, tick)));
 	}
 	return {
-		row: total(widths),
-		description: widths.description,
-		bar: widths.bar,
-		amount: widths.amount,
-		elapsed: widths.elapsed,
-		eta: widths.eta
+		hasDeterminate,
+		hasDetailed,
+		totalDigits: Math.max(1, totalDigits),
+		simpleTextWidth
 	};
 };
-const computeSharedColumnWidths = (rows, now, tick, terminalColumns) => {
-	const withTree = computeWidths(rows, now, tick, terminalColumns, true);
-	if (withTree.description >= MIN_DESCRIPTION_COLUMNS_FOR_TREE) return {
-		...withTree,
-		showTree: true
-	};
+const detailedAmountLayout = (metrics) => ({
+	kind: "detailed",
+	succeededWidth: metrics.hasDetailed ? metrics.totalDigits : 0,
+	failedWidth: metrics.hasDetailed ? metrics.totalDigits : 0,
+	processedWidth: metrics.totalDigits,
+	totalWidth: metrics.totalDigits
+});
+const processedAmountLayout = (metrics) => ({
+	kind: "processed",
+	processedWidth: metrics.totalDigits,
+	totalWidth: metrics.totalDigits
+});
+const detailedAmountWidth = (metrics) => metrics.totalDigits + 1 + metrics.totalDigits + (metrics.hasDetailed ? metrics.totalDigits + 1 + metrics.totalDigits + 1 : 0);
+const processedAmountWidth = (metrics) => metrics.totalDigits + 1 + metrics.totalDigits;
+const createAmountColumnSpec = (context) => {
+	const metrics = computeAmountMetrics(context.rows, context.tick);
+	if (!metrics.hasDeterminate && metrics.simpleTextWidth <= 0) return;
+	const detailedLayout = detailedAmountLayout(metrics);
+	const processedLayout = processedAmountLayout(metrics);
+	const detailedWidth = detailedAmountWidth(metrics);
+	const processedWidth = processedAmountWidth(metrics);
+	return {
+		id: "amount",
+		grow: 0,
+		canHide: true,
+		variants: metrics.hasDeterminate && metrics.hasDetailed ? [{
+			id: "detailed",
+			minWidth: detailedWidth,
+			idealWidth: detailedWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(AmountColumn, {
+				task: row.task,
+				tick: context.tick,
+				layout: detailedLayout
+			})
+		}, {
+			id: "processed",
+			minWidth: processedWidth,
+			idealWidth: processedWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(AmountColumn, {
+				task: row.task,
+				tick: context.tick,
+				layout: processedLayout
+			})
+		}] : metrics.hasDeterminate ? [{
+			id: "processed",
+			minWidth: processedWidth,
+			idealWidth: processedWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(AmountColumn, {
+				task: row.task,
+				tick: context.tick,
+				layout: processedLayout
+			})
+		}] : [{
+			id: "text",
+			minWidth: 0,
+			idealWidth: metrics.simpleTextWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(AmountColumn, {
+				task: row.task,
+				tick: context.tick,
+				layout: { kind: "text" }
+			})
+		}]
+	};
+};
+
+//#endregion
+//#region src/ink-renderer/columns/bar-column.tsx
+const DEFAULT_BAR_WIDTH = 30;
+const MIN_BAR_WIDTH = 8;
+const segmentLengths = (width, total, succeeded, failed) => {
+	if (total <= 0) return {
+		succeeded: 0,
+		failed: 0,
+		remaining: width
+	};
+	const succeededEnd = Math.round(succeeded / total * width);
+	const failedEnd = Math.round((succeeded + failed) / total * width);
+	const succeededLength = Math.max(0, Math.min(width, succeededEnd));
+	const failedLength = Math.max(0, Math.min(width, failedEnd) - succeededLength);
+	return {
+		succeeded: succeededLength,
+		failed: failedLength,
+		remaining: Math.max(0, width - succeededLength - failedLength)
+	};
+};
+const BarColumn = ({ task, width }) => {
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
+	const lengths = segmentLengths(Math.max(1, Math.floor(width)), task.units.total, task.units.succeeded, task.units.failed);
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "green",
+				children: "━".repeat(lengths.succeeded)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "red",
+				children: "━".repeat(lengths.failed)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: "─".repeat(lengths.remaining)
+			})
+		]
+	});
+};
+const createBarColumnSpec = (context, isTTY) => {
+	if (!hasDeterminateRows(context.rows)) return;
 	return {
-		...computeWidths(rows, now, tick, terminalColumns, false),
-		showTree: false
+		id: "bar",
+		grow: 0,
+		canHide: true,
+		variants: [{
+			id: "full",
+			minWidth: MIN_BAR_WIDTH,
+			idealWidth: DEFAULT_BAR_WIDTH,
+			maxWidth: DEFAULT_BAR_WIDTH,
+			renderCell: (row, width) => /* @__PURE__ */ jsx(BarColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY,
+				width: Math.max(1, Math.min(width, DEFAULT_BAR_WIDTH))
+			})
+		}, {
+			id: "compact",
+			minWidth: 1,
+			idealWidth: MIN_BAR_WIDTH,
+			maxWidth: MIN_BAR_WIDTH,
+			renderCell: (row, width) => /* @__PURE__ */ jsx(BarColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY,
+				width: Math.max(1, width)
+			})
+		}]
 	};
 };
 
 //#endregion
-//#region src/ink-renderer/columns/amount-column.tsx
-const AmountColumn = ({ task, tick }) => {
-	const text = formatAmount(task, tick);
-	return /* @__PURE__ */ jsx(Text, {
-		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : task.units._tag === "DeterminateTaskUnits" ? "whiteBright" : "yellow",
-		children: text
-	});
+//#region src/ink-renderer/view/tree-prefix.ts
+const treeAncestorPrefix = (tree) => tree.ancestorHasNextSibling.slice(1).map((hasNext) => hasNext ? "│  " : "   ").join("");
+const renderTreePrefix = (tree) => {
+	if (tree.depth <= 0) return "";
+	return `${treeAncestorPrefix(tree)}${tree.hasNextSibling ? "├─ " : "└─ "}`;
 };
 
 //#endregion
-//#region src/ink-renderer/columns/bar-column.tsx
-const clamp = (value, minimum, maximum) => Math.min(Math.max(value, minimum), maximum);
-const BarColumn = ({ task, width }) => {
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
-	const barWidth = Math.max(1, Math.floor(width));
-	const safeTotal = Math.max(1, task.units.total);
-	const ratio = task.status === "done" ? 1 : clamp(task.units.completed / safeTotal, 0, 1);
-	const filled = Math.round(barWidth * ratio);
-	const empty = Math.max(0, barWidth - filled);
-	const bar = `${"━".repeat(filled)}${"─".repeat(empty)}`;
-	return /* @__PURE__ */ jsx(Text, {
+//#region src/ink-renderer/columns/description-column.tsx
+const DescriptionColumn = ({ task, tree, showTree, tick }) => {
+	const treePrefix = showTree ? renderTreePrefix(tree) : "";
+	const indicator = getTaskIndicator(task, tick);
+	return /* @__PURE__ */ jsxs(Text, {
 		wrap: "truncate-end",
-		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : "blue",
-		children: bar
+		children: [
+			treePrefix,
+			/* @__PURE__ */ jsx(Text, {
+				color: indicator.color,
+				children: indicator.symbol
+			}),
+			` ${task.description}`
+		]
 	});
 };
-
-//#endregion
-//#region src/ink-renderer/columns/description-column.tsx
-const DescriptionColumn = ({ task, tree, showTree }) => /* @__PURE__ */ jsx(Text, {
-	wrap: "truncate-end",
-	children: `${showTree ? renderTreePrefix(tree) : ""}${task.description}`
-});
+const MIN_DESCRIPTION_WIDTH = 8;
+const MIN_DESCRIPTION_WITH_TREE_WIDTH = 20;
+const DESCRIPTION_PADDING_GROWTH_LIMIT = 20;
+const maxDescriptionWidth = (rows, showTree) => rows.reduce((max, row) => {
+	const treePrefix = showTree ? renderTreePrefix(row.tree) : "";
+	return Math.max(max, textWidth(`${treePrefix}${row.task.description}`) + 2);
+}, MIN_DESCRIPTION_WIDTH);
+const createDescriptionColumnSpec = (context, isTTY) => {
+	const treeIdeal = maxDescriptionWidth(context.rows, true);
+	const plainIdeal = maxDescriptionWidth(context.rows, false);
+	const treeVariantIdeal = Math.max(MIN_DESCRIPTION_WITH_TREE_WIDTH, treeIdeal);
+	const plainVariantIdeal = Math.max(MIN_DESCRIPTION_WIDTH, plainIdeal);
+	return {
+		id: "description",
+		grow: 1,
+		canHide: false,
+		variants: [{
+			id: "tree",
+			minWidth: MIN_DESCRIPTION_WITH_TREE_WIDTH,
+			idealWidth: treeVariantIdeal,
+			maxWidth: Math.max(DESCRIPTION_PADDING_GROWTH_LIMIT, treeVariantIdeal),
+			renderCell: (row) => /* @__PURE__ */ jsx(DescriptionColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY,
+				showTree: true
+			})
+		}, {
+			id: "plain",
+			minWidth: MIN_DESCRIPTION_WIDTH,
+			idealWidth: plainVariantIdeal,
+			maxWidth: Math.max(DESCRIPTION_PADDING_GROWTH_LIMIT, plainVariantIdeal),
+			renderCell: (row) => /* @__PURE__ */ jsx(DescriptionColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY,
+				showTree: false
+			})
+		}]
+	};
+};
 
 //#endregion
 //#region src/ink-renderer/columns/elapsed-column.tsx
 const ElapsedColumn = ({ task, now }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
 	color: "gray",
 	children: formatElapsed(task, now)
 });
+const MIN_ELAPSED_WIDTH = 2;
+const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
+const maxElapsedWidth = (rows, now) => rows.reduce((max, row) => Math.max(max, textWidth(formatElapsed(row.task, now))), MIN_ELAPSED_WIDTH);
+const createElapsedColumnSpec = (context, isTTY) => {
+	const elapsedContentWidth = maxElapsedWidth(context.rows, context.now);
+	return {
+		id: "elapsed",
+		grow: 0,
+		canHide: false,
+		variants: [{
+			id: "stable",
+			minWidth: elapsedContentWidth,
+			idealWidth: hasDeterminateRows(context.rows) ? Math.max(elapsedContentWidth, RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR) : elapsedContentWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(ElapsedColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY
+			})
+		}, {
+			id: "compact",
+			minWidth: MIN_ELAPSED_WIDTH,
+			idealWidth: elapsedContentWidth,
+			renderCell: (row) => /* @__PURE__ */ jsx(ElapsedColumn, {
+				task: row.task,
+				tree: row.tree,
+				now: context.now,
+				tick: context.tick,
+				isTTY
+			})
+		}]
+	};
+};
 
 //#endregion
 //#region src/ink-renderer/columns/eta-column.tsx
-const EtaColumn = ({ task, now }) => {
-	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
+const primaryUnit = (duration) => duration.split(" ")[0] ?? duration;
+const etaDurationText = (task, now) => {
+	if (task.status !== "running" || !isDeterminate(task)) return;
 	const eta = formatEta(task, now);
+	return eta.length > 0 ? eta : "--";
+};
+const EtaColumn = ({ task, now, mode }) => {
+	const duration = etaDurationText(task, now);
+	if (duration === void 0) return /* @__PURE__ */ jsx(Text, {});
 	return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
 		color: "gray",
-		children: eta.length > 0 ? `ETA: ${eta}` : "ETA: --"
+		children: mode === "prefixed" ? `ETA: ${duration}` : mode === "primary" ? primaryUnit(duration) : duration
 	});
 };
+const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
+const computeEtaMetrics = (rows, now) => {
+	let hasEta = false;
+	let prefixedWidth = 0;
+	let durationWidth = 0;
+	let primaryUnitWidth = 0;
+	for (const row of rows) {
+		const duration = etaDurationText(row.task, now);
+		if (duration === void 0) continue;
+		hasEta = true;
+		const prefixed = `ETA: ${duration}`;
+		prefixedWidth = Math.max(prefixedWidth, textWidth(prefixed));
+		durationWidth = Math.max(durationWidth, textWidth(duration));
+		primaryUnitWidth = Math.max(primaryUnitWidth, textWidth(primaryUnit(duration)));
+	}
+	return {
+		hasEta,
+		prefixedWidth,
+		durationWidth: Math.max(2, durationWidth),
+		primaryUnitWidth: Math.max(2, primaryUnitWidth)
+	};
+};
+const createEtaColumnSpec = (context, isTTY) => {
+	const metrics = computeEtaMetrics(context.rows, context.now);
+	if (!metrics.hasEta) return;
+	return {
+		id: "eta",
+		grow: 0,
+		canHide: true,
+		variants: [
+			{
+				id: "prefixed",
+				minWidth: metrics.prefixedWidth,
+				idealWidth: Math.max(metrics.prefixedWidth, RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR),
+				renderCell: (row) => /* @__PURE__ */ jsx(EtaColumn, {
+					task: row.task,
+					tree: row.tree,
+					now: context.now,
+					tick: context.tick,
+					isTTY,
+					mode: "prefixed"
+				})
+			},
+			{
+				id: "duration",
+				minWidth: metrics.durationWidth,
+				idealWidth: metrics.durationWidth,
+				renderCell: (row) => /* @__PURE__ */ jsx(EtaColumn, {
+					task: row.task,
+					tree: row.tree,
+					now: context.now,
+					tick: context.tick,
+					isTTY,
+					mode: "duration"
+				})
+			},
+			{
+				id: "primary",
+				minWidth: metrics.primaryUnitWidth,
+				idealWidth: metrics.primaryUnitWidth,
+				renderCell: (row) => /* @__PURE__ */ jsx(EtaColumn, {
+					task: row.task,
+					tree: row.tree,
+					now: context.now,
+					tick: context.tick,
+					isTTY,
+					mode: "primary"
+				})
+			}
+		]
+	};
+};
+
+//#endregion
+//#region src/ink-renderer/columns/planner.ts
+const clampInt = (value, min, max) => Math.max(min, Math.min(max, Math.floor(value)));
+const activeColumns = (columns) => columns.filter((column) => !column.hidden);
+const visibleColumns = (columns) => columns.filter((column) => !column.hidden && column.width > 0);
+const visibleGapWidth = (columns) => Math.max(0, visibleColumns(columns).length - 1);
+const totalWidth = (columns) => visibleColumns(columns).reduce((sum, column) => sum + column.width, 0) + visibleGapWidth(columns);
+const currentVariant = (column) => column.variants[column.variantIndex];
+const variantMaxWidth = (column) => {
+	const variant = currentVariant(column);
+	return variant.maxWidth === void 0 ? Number.POSITIVE_INFINITY : Math.max(variant.minWidth, variant.maxWidth);
+};
+const reduceOverflowByShrink = (columns, overflow) => {
+	let remaining = overflow;
+	const candidates = activeColumns(columns).filter((column) => column.width > currentVariant(column).minWidth).sort((a, b) => currentVariant(a).shrinkResistance - currentVariant(b).shrinkResistance);
+	for (const column of candidates) {
+		if (remaining <= 0) break;
+		const variant = currentVariant(column);
+		const reducible = column.width - variant.minWidth;
+		if (reducible <= 0) continue;
+		const delta = Math.min(reducible, remaining);
+		column.width -= delta;
+		remaining -= delta;
+	}
+	return remaining;
+};
+const nextDemoteCandidate = (columns) => activeColumns(columns).filter((column) => column.variantIndex + 1 < column.variants.length).sort((a, b) => currentVariant(a).demoteResistance - currentVariant(b).demoteResistance)[0];
+const applyDemote = (column) => {
+	const nextVariant = column.variants[column.variantIndex + 1];
+	column.variantIndex += 1;
+	const nextMaxWidth = nextVariant.maxWidth === void 0 ? Number.POSITIVE_INFINITY : Math.max(nextVariant.minWidth, nextVariant.maxWidth);
+	column.width = Math.max(nextVariant.minWidth, Math.min(column.width, nextVariant.idealWidth, nextMaxWidth));
+};
+const nextHideCandidate = (columns) => activeColumns(columns).filter((column) => column.spec.canHide).sort((a, b) => currentVariant(a).hideResistance - currentVariant(b).hideResistance)[0];
+const applyHide = (column) => {
+	column.hidden = true;
+	column.width = 0;
+};
+const distributeGrowth = (columns, extra) => {
+	if (extra <= 0) return;
+	let remaining = extra;
+	while (remaining > 0) {
+		const candidates = activeColumns(columns).filter((column) => column.spec.grow > 0 && column.width < variantMaxWidth(column));
+		if (candidates.length === 0) break;
+		const growSum = candidates.reduce((sum, column) => sum + Math.max(0, column.spec.grow), 0);
+		if (growSum <= 0) break;
+		let distributed = 0;
+		for (const column of candidates) {
+			const weight = Math.max(0, column.spec.grow);
+			if (weight <= 0) continue;
+			const headroom = Math.max(0, variantMaxWidth(column) - column.width);
+			if (headroom <= 0) continue;
+			const share = Math.min(headroom, Math.floor(remaining * weight / growSum));
+			if (share <= 0) continue;
+			column.width += share;
+			distributed += share;
+		}
+		if (distributed === 0) {
+			for (const column of candidates) {
+				if (remaining <= 0) break;
+				if (Math.max(0, variantMaxWidth(column) - column.width) <= 0) continue;
+				column.width += 1;
+				distributed += 1;
+				remaining -= 1;
+			}
+			if (distributed === 0) break;
+			continue;
+		}
+		remaining -= distributed;
+	}
+};
+const planColumns = ({ context, baselineWidth, columns }) => {
+	const mutable = columns.flatMap((column) => {
+		if (column.variants.length === 0) return [];
+		const first = column.variants[0];
+		return [{
+			spec: column,
+			variants: column.variants,
+			variantIndex: 0,
+			width: Math.max(first.minWidth, Math.min(first.idealWidth, first.maxWidth === void 0 ? Number.POSITIVE_INFINITY : Math.max(first.minWidth, first.maxWidth))),
+			hidden: false
+		}];
+	});
+	if (mutable.length === 0) return {
+		rowWidth: 0,
+		columns: []
+	};
+	const naturalWidth = totalWidth(mutable);
+	const clampedTerminal = context.terminalColumns === void 0 ? void 0 : clampInt(context.terminalColumns, 1, Number.POSITIVE_INFINITY);
+	const baselineTarget = Math.max(1, Math.max(baselineWidth, naturalWidth));
+	const target = clampedTerminal === void 0 ? baselineTarget : Math.min(baselineTarget, clampedTerminal);
+	if (naturalWidth < target) distributeGrowth(mutable, target - naturalWidth);
+	else if (naturalWidth > target) {
+		let overflow = naturalWidth - target;
+		let progressed = true;
+		while (overflow > 0 && progressed) {
+			const before = overflow;
+			overflow = reduceOverflowByShrink(mutable, overflow);
+			if (overflow <= 0) break;
+			const demoteCandidate = nextDemoteCandidate(mutable);
+			const hideCandidate = nextHideCandidate(mutable);
+			if (demoteCandidate === void 0 && hideCandidate === void 0) {
+				progressed = before !== overflow;
+				continue;
+			}
+			if ((demoteCandidate === void 0 ? Number.POSITIVE_INFINITY : currentVariant(demoteCandidate).demoteResistance) <= (hideCandidate === void 0 ? Number.POSITIVE_INFINITY : currentVariant(hideCandidate).hideResistance) && demoteCandidate !== void 0) applyDemote(demoteCandidate);
+			else if (hideCandidate !== void 0) applyHide(hideCandidate);
+			overflow = Math.max(0, totalWidth(mutable) - target);
+			progressed = true;
+		}
+		const compactedWidth = totalWidth(mutable);
+		if (compactedWidth < target) distributeGrowth(mutable, target - compactedWidth);
+	}
+	const visible = visibleColumns(mutable);
+	return {
+		rowWidth: totalWidth(mutable),
+		columns: visible.map((column) => {
+			const variant = currentVariant(column);
+			return {
+				id: column.spec.id,
+				variantId: variant.id,
+				width: column.width,
+				renderCell: variant.renderCell
+			};
+		})
+	};
+};
 
 //#endregion
-//#region src/ink-renderer/task-row.tsx
-const TaskRow = ({ row, now, tick, isTTY, widths }) => {
-	const props = {
-		task: row.task,
-		tree: row.tree,
+//#region src/ink-renderer/columns/layout.tsx
+/**
+* Frame planning algorithm (per render tick):
+*
+* 1. Ask each column module to produce a logical column spec (variants + measured widths).
+* 2. Apply shared resistance rules (shrink / demote / hide) to those variants.
+* 3. Feed resolved columns into `planColumns`.
+* 4. `planColumns` shrinks, demotes, and hides until the row fits target width.
+* 5. Render rows with the selected variant and width for each visible column.
+*/
+const BASELINE_ROW_WIDTH = 150;
+const DEFAULT_RESISTANCE = 1e3;
+const variantOrderKey = ({ columnId, variantId }) => `${columnId}:${variantId}`;
+const SHRINK_ORDER = [
+	{
+		columnId: "eta",
+		variantId: "prefixed"
+	},
+	{
+		columnId: "elapsed",
+		variantId: "stable"
+	},
+	{
+		columnId: "eta",
+		variantId: "duration"
+	},
+	{
+		columnId: "eta",
+		variantId: "primary"
+	},
+	{
+		columnId: "bar",
+		variantId: "compact"
+	},
+	{
+		columnId: "bar",
+		variantId: "full"
+	},
+	{
+		columnId: "amount",
+		variantId: "text"
+	},
+	{
+		columnId: "elapsed",
+		variantId: "compact"
+	},
+	{
+		columnId: "description",
+		variantId: "tree"
+	},
+	{
+		columnId: "amount",
+		variantId: "detailed"
+	},
+	{
+		columnId: "amount",
+		variantId: "processed"
+	},
+	{
+		columnId: "description",
+		variantId: "plain"
+	}
+];
+const DEMOTE_ORDER = [
+	{
+		columnId: "description",
+		variantId: "tree"
+	},
+	{
+		columnId: "eta",
+		variantId: "prefixed"
+	},
+	{
+		columnId: "eta",
+		variantId: "duration"
+	},
+	{
+		columnId: "elapsed",
+		variantId: "stable"
+	},
+	{
+		columnId: "bar",
+		variantId: "full"
+	},
+	{
+		columnId: "amount",
+		variantId: "detailed"
+	}
+];
+const HIDE_ORDER = [
+	{
+		columnId: "eta",
+		variantId: "primary"
+	},
+	{
+		columnId: "eta",
+		variantId: "prefixed"
+	},
+	{
+		columnId: "eta",
+		variantId: "duration"
+	},
+	{
+		columnId: "bar",
+		variantId: "full"
+	},
+	{
+		columnId: "bar",
+		variantId: "compact"
+	},
+	{
+		columnId: "amount",
+		variantId: "text"
+	},
+	{
+		columnId: "amount",
+		variantId: "detailed"
+	},
+	{
+		columnId: "amount",
+		variantId: "processed"
+	}
+];
+const toResistanceLookup = (order) => new Map(order.map((item, index) => [variantOrderKey(item), index + 1]));
+const shrinkResistanceLookup = toResistanceLookup(SHRINK_ORDER);
+const demoteResistanceLookup = toResistanceLookup(DEMOTE_ORDER);
+const hideResistanceLookup = toResistanceLookup(HIDE_ORDER);
+const resistanceFor = (lookup, columnId, variantId) => lookup.get(`${columnId}:${variantId}`) ?? DEFAULT_RESISTANCE;
+const buildColumns = (context, isTTY) => {
+	return resolveColumnSpecs([
+		createDescriptionColumnSpec(context, isTTY),
+		createBarColumnSpec(context, isTTY),
+		createAmountColumnSpec(context),
+		createElapsedColumnSpec(context, isTTY),
+		createEtaColumnSpec(context, isTTY)
+	].filter((spec) => spec !== void 0), {
+		shrink: (columnId, variantId) => resistanceFor(shrinkResistanceLookup, columnId, variantId),
+		demote: (columnId, variantId) => resistanceFor(demoteResistanceLookup, columnId, variantId),
+		hide: (columnId, variantId) => resistanceFor(hideResistanceLookup, columnId, variantId)
+	});
+};
+const computeFrameLayout = (rows, now, tick, terminalColumns, isTTY) => {
+	const context = {
+		rows,
 		now,
 		tick,
-		isTTY,
-		showTree: widths.showTree
+		terminalColumns
 	};
-	return /* @__PURE__ */ jsxs(Box, {
+	return planColumns({
+		context,
+		columns: buildColumns(context, isTTY),
+		baselineWidth: hasDeterminateRows(rows) ? BASELINE_ROW_WIDTH : 1
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/view/task-row.tsx
+const TaskRow = ({ row, layout }) => {
+	return /* @__PURE__ */ jsx(Box, {
 		flexDirection: "row",
-		minWidth: widths.row,
-		children: [
-			/* @__PURE__ */ jsx(Box, {
-				width: widths.description,
-				flexShrink: 1,
-				marginRight: 1,
-				children: /* @__PURE__ */ jsx(DescriptionColumn, { ...props })
-			}),
-			widths.bar > 0 ? /* @__PURE__ */ jsx(Box, {
-				width: widths.bar,
-				flexShrink: 0,
-				marginRight: 1,
-				children: /* @__PURE__ */ jsx(BarColumn, {
-					...props,
-					width: Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))
-				})
-			}) : null,
-			/* @__PURE__ */ jsx(Box, {
-				width: widths.amount,
-				flexShrink: 0,
-				marginRight: 1,
-				children: /* @__PURE__ */ jsx(AmountColumn, { ...props })
-			}),
-			/* @__PURE__ */ jsx(Box, {
-				width: widths.elapsed,
-				flexShrink: 0,
-				marginRight: 1,
-				children: /* @__PURE__ */ jsx(ElapsedColumn, { ...props })
-			}),
-			widths.eta > 0 ? /* @__PURE__ */ jsx(Box, {
-				width: widths.eta,
-				flexShrink: 0,
-				children: /* @__PURE__ */ jsx(EtaColumn, { ...props })
-			}) : null
-		]
+		minWidth: layout.rowWidth,
+		children: layout.columns.map((column, index) => /* @__PURE__ */ jsx(Box, {
+			width: column.width,
+			flexShrink: column.id === "description" ? 1 : 0,
+			marginRight: index < layout.columns.length - 1 ? 1 : 0,
+			children: column.renderCell(row, column.width)
+		}, column.id))
 	});
 };
 
 //#endregion
-//#region src/ink-renderer/app.tsx
-const ProgressApp = ({ rows, now, tick, isTTY, terminalColumns }) => {
-	const widths = computeSharedColumnWidths(rows, now, tick, terminalColumns);
+//#region src/ink-renderer/view/progress-view.tsx
+const ProgressView = ({ rows, now, tick, isTTY, terminalColumns }) => {
+	const layout = computeFrameLayout(rows, now, tick, terminalColumns, isTTY);
 	return /* @__PURE__ */ jsx(Box, {
 		flexDirection: "column",
 		children: rows.map((row) => /* @__PURE__ */ jsx(TaskRow, {
 			row,
-			now,
-			tick,
-			isTTY,
-			widths
+			layout
 		}, row.task.id))
 	});
 };
 
 //#endregion
-//#region src/ink-renderer/model.ts
-const orderedVisibleTasks = (store) => store.renderOrder.flatMap((row) => {
-	const snapshot = store.tasks.get(row.id);
-	if (!snapshot || snapshot.transient && snapshot.status !== "running") return [];
-	return [{
-		snapshot,
-		depth: row.depth
-	}];
-});
-const toTaskRows = (store) => computeTreeInfo(orderedVisibleTasks(store)).map((entry) => ({
-	task: entry.snapshot,
-	tree: entry.tree
-}));
-
-//#endregion
-//#region src/ink-renderer/service.tsx
-const RENDER_INTERVAL_MILLIS = 100;
-const hasRunningSpinners = (tasks) => tasks.some((task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits");
-const createInkWritable = (terminal) => new Writable({ write(chunk, _encoding, callback) {
-	try {
-		const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
-		Effect.runSync(terminal.writeStderr(text));
-		callback();
-	} catch (error) {
-		callback(error);
-	}
-} });
-const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, terminal, isTTY) => Effect.gen(function* () {
-	const output = createInkWritable(terminal);
-	let instance;
-	let tick = 0;
-	let rendererActive = false;
-	const renderStore = (store, now, terminalColumns) => Effect.sync(() => {
-		const app = /* @__PURE__ */ jsx(ProgressApp, {
-			rows: toTaskRows(store),
-			now,
-			tick,
-			isTTY,
-			terminalColumns
-		});
-		if (instance === void 0) {
-			instance = render(app, {
-				stdout: output,
-				stderr: output,
-				patchConsole: true,
-				exitOnCtrlC: false,
-				debug: false
-			});
-			return;
-		}
-		instance.rerender(app);
-	});
-	return yield* Effect.gen(function* () {
-		rendererActive = true;
-		while (true) {
-			const dirty = yield* Ref.getAndSet(dirtyRef, false);
-			const store = yield* Ref.get(storeRef);
-			const tasks = Array.from(store.tasks.values()).filter((task) => !(task.transient && task.status !== "running"));
-			if (dirty || hasRunningSpinners(tasks)) yield* renderStore(store, yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
-			tick += 1;
-			yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
-		}
-	}).pipe(Effect.ensuring(Effect.gen(function* () {
-		if (rendererActive) yield* renderStore(yield* Ref.get(storeRef), yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
-		yield* Effect.sync(() => {
-			instance?.unmount();
-		});
-	})));
-}) });
-var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")() {
-	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
+//#region src/ink-renderer/view/hooks/use-now-clock.ts
+const useNowClock = (active, intervalMillis) => {
+	const [now, setNow] = useState(() => Date.now());
+	useEffect(() => {
+		if (!active) return;
+		setNow(Date.now());
+		const interval = setInterval(() => {
+			setNow(Date.now());
+		}, intervalMillis);
+		return () => {
+			clearInterval(interval);
+		};
+	}, [active, intervalMillis]);
+	return now;
 };
 
 //#endregion
-//#region src/terminal.ts
-const withRawInputCapture = (effect) => Effect.suspend(() => {
-	if (!process.stdin.isTTY) return effect;
-	const stdin = process.stdin;
-	const wasRaw = Boolean(stdin.isRaw);
-	const onData = (chunk) => {
-		if (chunk.length === 1 && chunk[0] === 3) process.kill(process.pid, "SIGINT");
-	};
-	return Effect.acquireUseRelease(Effect.sync(() => {
-		stdin.resume();
-		stdin.setRawMode?.(true);
-		stdin.on("data", onData);
-	}), () => effect, () => Effect.sync(() => {
-		try {
-			stdin.off("data", onData);
-			stdin.setRawMode?.(wasRaw);
-			stdin.pause();
-		} catch {}
-	}));
-});
-const defaultTerminalService = {
-	isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
-	stderrRows: Effect.sync(() => process.stderr.rows),
-	stderrColumns: Effect.sync(() => process.stderr.columns),
-	writeStderr: (text) => Effect.sync(() => {
-		process.stderr.write(text);
-	}),
-	withRawInputCapture
-};
-var ProgressTerminal = class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")() {
-	static Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
+//#region src/ink-renderer/view/hooks/use-spinner-clock.ts
+const useSpinnerClock = (active, intervalMillis) => {
+	const [tick, setTick] = useState(0);
+	useEffect(() => {
+		if (!active) return;
+		const interval = setInterval(() => {
+			setTick((current) => current + 1);
+		}, intervalMillis);
+		return () => {
+			clearInterval(interval);
+		};
+	}, [active, intervalMillis]);
+	return tick;
 };
 
 //#endregion
-//#region src/types.ts
-const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
-const TaskId = Brand.nominal();
-const TaskStatusSchema = Schema.Literal("running", "done", "failed");
-var DeterminateTaskUnits = class extends Schema.TaggedClass()("DeterminateTaskUnits", {
-	completed: Schema.Number,
-	total: Schema.Number
-}) {};
-var IndeterminateTaskUnits = class extends Schema.TaggedClass()("IndeterminateTaskUnits", { spinnerFrame: Schema.Number }) {};
-const TaskUnitsSchema = Schema.Union(DeterminateTaskUnits, IndeterminateTaskUnits);
-var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
-	id: TaskIdSchema,
-	parentId: Schema.NullOr(TaskIdSchema),
-	description: Schema.String,
-	status: TaskStatusSchema,
-	transient: Schema.Boolean,
-	units: TaskUnitsSchema,
-	startedAt: Schema.Number,
-	completedAt: Schema.NullOr(Schema.Number)
-}) {};
-var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
-var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
-	taskId: TaskIdSchema,
-	parentId: Schema.NullOr(TaskIdSchema),
-	description: Schema.String,
-	total: Schema.optional(Schema.Number),
-	transient: Schema.Boolean
-}) {};
-var TaskUpdatedEvent = class extends Schema.TaggedClass()("TaskUpdated", {
-	taskId: TaskIdSchema,
-	description: Schema.optional(Schema.String),
-	completed: Schema.optional(Schema.Number),
-	total: Schema.optional(Schema.Number),
-	transient: Schema.optional(Schema.Boolean)
-}) {};
-var TaskAdvancedEvent = class extends Schema.TaggedClass()("TaskAdvanced", {
-	taskId: TaskIdSchema,
-	amount: Schema.Number
-}) {};
-var TaskCompletedEvent = class extends Schema.TaggedClass()("TaskCompleted", { taskId: TaskIdSchema }) {};
-var TaskFailedEvent = class extends Schema.TaggedClass()("TaskFailed", { taskId: TaskIdSchema }) {};
-var TaskRemovedEvent = class extends Schema.TaggedClass()("TaskRemoved", { taskId: TaskIdSchema }) {};
-const ProgressTaskEventSchema = Schema.Union(TaskAddedEvent, TaskUpdatedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskRemovedEvent);
-const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);
+//#region src/ink-renderer/view/render-root.tsx
+const SPINNER_INTERVAL_MILLIS = 100;
+const NOW_INTERVAL_MILLIS = 1e3;
+const ProgressRoot = ({ store, isTTY, getTerminalColumns }) => {
+	const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+	const tick = useSpinnerClock(snapshot.hasRunningTasks, SPINNER_INTERVAL_MILLIS);
+	const now = useNowClock(snapshot.hasRunningTasks, NOW_INTERVAL_MILLIS);
+	return /* @__PURE__ */ jsx(ProgressView, {
+		rows: snapshot.rows,
+		now,
+		tick,
+		isTTY,
+		terminalColumns: getTerminalColumns()
+	});
+};
 
 //#endregion
-//#region src/runtime.ts
-const updatedSnapshot = (snapshot, options) => {
-	const currentUnits = snapshot.units;
-	const units = (() => {
-		if (options.total !== void 0) {
-			if (options.total <= 0) return new IndeterminateTaskUnits({ spinnerFrame: 0 });
-			const completed = options.completed ?? (currentUnits._tag === "DeterminateTaskUnits" ? currentUnits.completed : 0);
-			return new DeterminateTaskUnits({
-				completed: Math.max(0, completed),
-				total: Math.max(0, options.total)
-			});
-		}
-		if (currentUnits._tag === "DeterminateTaskUnits") {
-			if (options.completed === void 0) return currentUnits;
-			return new DeterminateTaskUnits({
-				completed: Math.max(0, options.completed),
-				total: currentUnits.total
-			});
-		}
-		return currentUnits;
-	})();
-	return new TaskSnapshot({
-		id: snapshot.id,
-		parentId: snapshot.parentId,
-		description: options.description ?? snapshot.description,
-		status: snapshot.status,
-		transient: options.transient ?? snapshot.transient,
-		units,
-		startedAt: snapshot.startedAt,
-		completedAt: snapshot.completedAt
+//#region src/services/ink-renderer.tsx
+const MAX_FPS = 12;
+const makeDefaultInkRenderer = () => ({ run: (store, stdio, isTTY) => Effect.sync(() => render(/* @__PURE__ */ jsx(ProgressRoot, {
+	store,
+	isTTY,
+	getTerminalColumns: () => isTTY ? stdio.stderr.columns : void 0
+}), {
+	stdout: stdio.stdout,
+	stderr: stdio.stderr,
+	patchConsole: true,
+	exitOnCtrlC: false,
+	debug: false,
+	maxFps: MAX_FPS
+})).pipe(Effect.flatMap((instance) => Effect.never.pipe(Effect.ensuring(Effect.gen(function* () {
+	store.flush();
+	yield* Effect.sleep("0 millis");
+	yield* Effect.sync(() => {
+		instance.unmount();
 	});
+}))))) });
+var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")() {
+	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
 };
-const withTransient = (snapshot, transient) => new TaskSnapshot({
-	id: snapshot.id,
-	parentId: snapshot.parentId,
-	description: snapshot.description,
-	status: snapshot.status,
-	transient,
-	units: snapshot.units,
-	startedAt: snapshot.startedAt,
-	completedAt: snapshot.completedAt
-});
-const findInsertionIndex = (renderOrder, parentId) => {
-	if (parentId === null) return {
-		index: renderOrder.length,
-		depth: 0
-	};
-	const parentIdx = renderOrder.findIndex((row) => row.id === parentId);
-	if (parentIdx === -1) return {
-		index: renderOrder.length,
-		depth: 0
-	};
-	const parentDepth = renderOrder[parentIdx].depth;
-	let i = parentIdx + 1;
-	while (i < renderOrder.length && renderOrder[i].depth > parentDepth) i++;
-	return {
-		index: i,
-		depth: parentDepth + 1
-	};
+
+//#endregion
+//#region src/services/stdio.ts
+const defaultStdioService = {
+	stdout: process.stdout,
+	stderr: process.stderr
 };
-const removeFromRenderOrder = (renderOrder, taskId) => {
-	const idx = renderOrder.findIndex((row) => row.id === taskId);
-	if (idx === -1) return renderOrder;
-	const taskDepth = renderOrder[idx].depth;
-	let end = idx + 1;
-	while (end < renderOrder.length && renderOrder[end].depth > taskDepth) end++;
-	const next = [...renderOrder];
-	next.splice(idx, end - idx);
-	return next;
+var ProgressStdio = class ProgressStdio extends Context.Tag("stromseng.dev/effective-progress/ProgressStdio")() {
+	static Default = Layer.succeed(ProgressStdio, defaultStdioService);
 };
+
+//#endregion
+//#region src/services/progress.ts
 const makeProgressService = Effect.gen(function* () {
-	const terminal = yield* ProgressTerminal;
+	const stdio = yield* ProgressStdio;
 	const inkRenderer = yield* InkRenderer;
 	const outerConsole = yield* Effect.console;
-	const isTTY = yield* terminal.isTTY;
-	const nextTaskIdRef = yield* Ref.make(0);
-	const storeRef = yield* Ref.make({
-		tasks: /* @__PURE__ */ new Map(),
-		renderOrder: []
-	});
-	const dirtyRef = yield* Ref.make(true);
+	const isTTY = Boolean(stdio.stderr.isTTY);
+	const store = makeProgressRenderStore();
 	const currentParentRef = yield* FiberRef.make(Option.none());
 	const scope = yield* Effect.scope;
-	const markDirty = Ref.set(dirtyRef, true);
 	const log = (...args) => args.length === 0 ? Effect.void : outerConsole.log(...args);
-	yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
+	yield* Effect.forkIn(inkRenderer.run(store, stdio, isTTY), scope);
 	yield* Effect.sleep("0 millis");
 	const addTask = (options) => Effect.gen(function* () {
 		const resolvedParentId = options.parentId === void 0 ? yield* FiberRef.get(currentParentRef) : Option.some(options.parentId);
-		const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
-		const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({ spinnerFrame: 0 }) : new DeterminateTaskUnits({
-			completed: 0,
-			total: Math.max(0, options.total)
-		});
-		const store = yield* Ref.get(storeRef);
-		const parentSnapshot = Option.isSome(resolvedParentId) ? store.tasks.get(resolvedParentId.value) : void 0;
-		const now = yield* Clock.currentTimeMillis;
-		const parentIdValue = Option.getOrNull(resolvedParentId);
-		const snapshot = new TaskSnapshot({
-			id: taskId,
-			parentId: parentIdValue,
-			description: options.description,
-			status: "running",
-			transient: parentSnapshot?.transient ?? options.transient ?? false,
-			units,
-			startedAt: now,
-			completedAt: null
-		});
-		yield* Ref.update(storeRef, (s) => {
-			const nextTasks = new Map(s.tasks);
-			nextTasks.set(taskId, snapshot);
-			const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
-			const nextOrder = [...s.renderOrder];
-			nextOrder.splice(index, 0, {
-				id: taskId,
-				depth
-			});
-			return {
-				tasks: nextTasks,
-				renderOrder: nextOrder
-			};
-		});
-		yield* markDirty;
-		return taskId;
-	});
-	const updateTask = (taskId, options) => Ref.update(storeRef, (store) => {
-		const snapshot = store.tasks.get(taskId);
-		if (!snapshot) return store;
-		const nextTasks = new Map(store.tasks);
-		const nextSnapshot = updatedSnapshot(snapshot, options);
-		nextTasks.set(taskId, nextSnapshot);
-		if (options.transient !== void 0) for (const [candidateId, candidate] of store.tasks.entries()) {
-			if (candidateId === taskId) continue;
-			let parentId = candidate.parentId;
-			let isDescendant = false;
-			while (parentId !== null) {
-				if (parentId === taskId) {
-					isDescendant = true;
-					break;
-				}
-				parentId = store.tasks.get(parentId)?.parentId ?? null;
-			}
-			if (isDescendant) nextTasks.set(candidateId, withTransient(candidate, nextSnapshot.transient));
-		}
-		return {
-			tasks: nextTasks,
-			renderOrder: store.renderOrder
-		};
-	}).pipe(Effect.zipRight(markDirty));
-	const advanceTask = (taskId, amount = 1) => Ref.update(storeRef, (store) => {
-		const snapshot = store.tasks.get(taskId);
-		if (!snapshot) return store;
-		const units = snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
-			completed: Math.min(snapshot.units.total, snapshot.units.completed + amount),
-			total: snapshot.units.total
-		}) : new IndeterminateTaskUnits({ spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount) });
-		const nextTasks = new Map(store.tasks);
-		nextTasks.set(taskId, new TaskSnapshot({
-			id: snapshot.id,
-			parentId: snapshot.parentId,
-			description: snapshot.description,
-			status: snapshot.status,
-			transient: snapshot.transient,
-			units,
-			startedAt: snapshot.startedAt,
-			completedAt: snapshot.completedAt
-		}));
-		return {
-			tasks: nextTasks,
-			renderOrder: store.renderOrder
-		};
-	}).pipe(Effect.zipRight(markDirty));
-	const completeTask = (taskId) => Effect.gen(function* () {
-		const now = yield* Clock.currentTimeMillis;
-		yield* Ref.update(storeRef, (store) => {
-			const snapshot = store.tasks.get(taskId);
-			if (!snapshot) return store;
-			const nextTasks = new Map(store.tasks);
-			if (snapshot.transient) {
-				nextTasks.delete(taskId);
-				return {
-					tasks: nextTasks,
-					renderOrder: removeFromRenderOrder(store.renderOrder, taskId)
-				};
-			}
-			nextTasks.set(taskId, new TaskSnapshot({
-				id: snapshot.id,
-				parentId: snapshot.parentId,
-				description: snapshot.description,
-				status: "done",
-				transient: snapshot.transient,
-				units: snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
-					completed: snapshot.units.total,
-					total: snapshot.units.total
-				}) : snapshot.units,
-				startedAt: snapshot.startedAt,
-				completedAt: now
-			}));
-			return {
-				tasks: nextTasks,
-				renderOrder: store.renderOrder
-			};
-		});
-		yield* markDirty;
-	});
-	const failTask = (taskId) => Effect.gen(function* () {
-		const now = yield* Clock.currentTimeMillis;
-		yield* Ref.update(storeRef, (store) => {
-			const snapshot = store.tasks.get(taskId);
-			if (!snapshot) return store;
-			const nextTasks = new Map(store.tasks);
-			if (snapshot.transient) {
-				nextTasks.delete(taskId);
-				return {
-					tasks: nextTasks,
-					renderOrder: removeFromRenderOrder(store.renderOrder, taskId)
-				};
-			}
-			nextTasks.set(taskId, new TaskSnapshot({
-				id: snapshot.id,
-				parentId: snapshot.parentId,
-				description: snapshot.description,
-				status: "failed",
-				transient: snapshot.transient,
-				units: snapshot.units,
-				startedAt: snapshot.startedAt,
-				completedAt: now
-			}));
-			return {
-				tasks: nextTasks,
-				renderOrder: store.renderOrder
-			};
+		return yield* store.addTask({
+			...options,
+			parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : void 0
 		});
-		yield* markDirty;
 	});
-	const getTask = (taskId) => Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
-	const listTasks = Ref.get(storeRef).pipe(Effect.map((store) => Array.from(store.tasks.values())));
+	const updateTask = store.updateTask;
+	const advanceTask = store.addSuccess;
+	const advanceTaskFailed = store.addFailure;
+	const completeTask = store.completeTask;
+	const failTask = store.failTask;
+	const getTask = store.getTask;
+	const listTasks = store.listTasks;
 	const runTask = dual(2, (effect, options) => Effect.gen(function* () {
 		const inheritedParentId = yield* FiberRef.get(currentParentRef);
 		const resolvedParentId = options.parentId === void 0 ? inheritedParentId : Option.some(options.parentId);
@@ -711,6 +1486,7 @@ const makeProgressService = Effect.gen(function* () {
 		addTask,
 		updateTask,
 		advanceTask,
+		advanceTaskFailed,
 		completeTask,
 		failTask,
 		log,
@@ -732,11 +1508,11 @@ const makeProgressService = Effect.gen(function* () {
 });
 var Progress = class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")() {
 	static Default = Layer.unwrapEffect(Effect.gen(function* () {
-		const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
+		const stdioOption = yield* Effect.serviceOption(ProgressStdio);
 		const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
 		let layer = Layer.scoped(Progress, makeProgressService);
 		if (Option.isNone(inkRendererOption)) layer = layer.pipe(Layer.provide(InkRenderer.Default));
-		if (Option.isNone(terminalOption)) layer = layer.pipe(Layer.provide(ProgressTerminal.Default));
+		if (Option.isNone(stdioOption)) layer = layer.pipe(Layer.provide(ProgressStdio.Default));
 		return layer;
 	}));
 };
@@ -765,11 +1541,29 @@ const task = dual(2, (effect, options) => {
 });
 const wrapEffects = (effects, tap) => Array.isArray(effects) ? effects.map(tap) : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
 const countEffects = (effects) => Array.isArray(effects) ? effects.length : Object.keys(effects).length;
+const isCollectAllMode = (mode) => mode === "either" || mode === "validate";
+const allCountDisplay = (mode) => isCollectAllMode(mode) ? "detailed" : "processedOnly";
+const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* () {
+	const exit = yield* Effect.exit(effect);
+	if (Exit.isSuccess(exit)) {
+		yield* progress.advanceTask(taskId, 1);
+		return exit.value;
+	}
+	if (Cause.isInterruptedOnly(exit.cause)) return yield* Effect.failCause(exit.cause);
+	yield* progress.advanceTaskFailed(taskId, 1);
+	return yield* Effect.failCause(exit.cause);
+});
+const isTaskFullyProcessed = (progress, taskId) => Effect.gen(function* () {
+	const taskOption = yield* progress.getTask(taskId);
+	if (Option.isNone(taskOption) || taskOption.value.units._tag !== "DeterminateTaskUnits") return false;
+	const { processed, total } = taskOption.value.units;
+	return processed >= total;
+});
 const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* () {
 	const progress = yield* Progress;
 	return yield* progress.runTask(Effect.gen(function* () {
 		const taskId = yield* Task;
-		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))), {
+		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => wrapTrackedEffect(progress, taskId, effect)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
 			discard: options.discard,
@@ -777,6 +1571,8 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 			concurrentFinalizers: options.concurrentFinalizers
 		}));
 		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
+		else if (!isCollectAllMode(options.mode)) yield* progress.failTask(taskId);
+		else if (yield* isTaskFullyProcessed(progress, taskId)) yield* progress.completeTask(taskId);
 		else yield* progress.failTask(taskId);
 		return yield* Exit.match(exit, {
 			onFailure: Effect.failCause,
@@ -785,14 +1581,15 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 	}), {
 		description: options.description,
 		total: countEffects(effects),
-		transient: options.transient
+		transient: options.transient,
+		countDisplay: allCountDisplay(options.mode)
 	});
 })));
 const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(function* () {
 	const progress = yield* Progress;
 	return yield* progress.runTask(Effect.gen(function* () {
 		const taskId = yield* Task;
-		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)), {
+		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => wrapTrackedEffect(progress, taskId, f(item, index)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
 			discard: options.discard,
@@ -807,9 +1604,10 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 	}), {
 		description: options.description,
 		total: options.total ?? inferTotal(iterable),
-		transient: options.transient
+		transient: options.transient,
+		countDisplay: "processedOnly"
 	});
 })));
 
 //#endregion
-export { DeterminateTaskUnits, IndeterminateTaskUnits, Progress, ProgressTaskEventSchema, ProgressTerminal, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };
+export { DeterminateTaskUnits, IndeterminateTaskUnits, Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };