effective-progress 0.9.0 → 0.11.0

package/dist/index.mjs

@@ -1,9 +1,11 @@
-import { Brand, Cause, Clock, Context, Data, Effect, Exit, FiberRef, Hash, Layer, Option, Schema } from "effect";
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { Brand, Cause, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Schema } from "effect";
 import { dual } from "effect/Function";
-import { Box, Text, render } from "ink";
-import { useEffect, useRef, useState, useSyncExternalStore } from "react";
-import stringWidth from "fast-string-width";
+import { Box, Text, render, useBoxMetrics } from "ink";
+import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import cliSpinners from "cli-spinners";
+import stringWidth from "fast-string-width";
 
 //#region src/types.ts
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
@@ -16,7 +18,7 @@ const TaskUnitsSchema = Schema.Struct({
 	processed: Schema.Number,
 	total: Schema.optional(Schema.Number)
 });
-var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
+const TaskSnapshotSchema = Schema.Struct({
 	id: TaskIdSchema,
 	parentId: Schema.NullOr(TaskIdSchema),
 	description: Schema.String,
@@ -25,8 +27,10 @@ var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
 	transient: Schema.Boolean,
 	units: TaskUnitsSchema,
 	startedAt: Schema.Number,
-	completedAt: Schema.NullOr(Schema.Number)
-}) {};
+	completedAt: Schema.NullOr(Schema.Number),
+	metadata: Schema.Unknown
+});
+const TaskSnapshot = (snapshot) => snapshot;
 var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
 var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
 	taskId: TaskIdSchema,
@@ -58,60 +62,7 @@ const ProgressTaskEventSchema = Schema.Union(TaskAddedEvent, TaskUpdatedEvent, T
 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
+//#region src/renderer/store.ts
 const hasExplicitTotal = (options) => Object.prototype.hasOwnProperty.call(options, "total");
 const sanitizeTotalOnAdd = (total) => {
 	if (total === void 0) return;
@@ -142,7 +93,7 @@ const updatedSnapshot = (snapshot, options) => {
 		failed: options.failed ?? currentUnits.failed,
 		total: hasExplicitTotal(options) ? sanitizeTotalOnUpdate(options.total) : currentUnits.total
 	});
-	return new TaskSnapshot({
+	return TaskSnapshot({
 		id: snapshot.id,
 		parentId: snapshot.parentId,
 		description: options.description ?? snapshot.description,
@@ -151,10 +102,11 @@ const updatedSnapshot = (snapshot, options) => {
 		transient: options.transient ?? snapshot.transient,
 		units,
 		startedAt: snapshot.startedAt,
-		completedAt: snapshot.completedAt
+		completedAt: snapshot.completedAt,
+		metadata: snapshot.metadata
 	});
 };
-const withTransient = (snapshot, transient) => new TaskSnapshot({
+const withTransient = (snapshot, transient) => TaskSnapshot({
 	id: snapshot.id,
 	parentId: snapshot.parentId,
 	description: snapshot.description,
@@ -163,7 +115,8 @@ const withTransient = (snapshot, transient) => new TaskSnapshot({
 	transient,
 	units: snapshot.units,
 	startedAt: snapshot.startedAt,
-	completedAt: snapshot.completedAt
+	completedAt: snapshot.completedAt,
+	metadata: snapshot.metadata
 });
 const findInsertionIndex = (renderOrder, parentId) => {
 	if (parentId === null) return {
@@ -193,14 +146,27 @@ const removeFromRenderOrder = (renderOrder, taskId) => {
 	next.splice(idx, end - idx);
 	return next;
 };
-const SNAPSHOT_PUBLISH_INTERVAL_MILLIS = 50;
+const subtreeTaskIds = (renderOrder, taskId) => {
+	const idx = renderOrder.findIndex((row) => row.id === taskId);
+	if (idx === -1) return [];
+	const taskDepth = renderOrder[idx].depth;
+	let end = idx + 1;
+	while (end < renderOrder.length && renderOrder[end].depth > taskDepth) end++;
+	return renderOrder.slice(idx, end).map((row) => row.id);
+};
+const SNAPSHOT_PUBLISH_INTERVAL_MILLIS = 100;
 const makeProgressRenderStore = () => {
 	let nextTaskId = 0;
 	let state = {
 		tasks: /* @__PURE__ */ new Map(),
-		renderOrder: []
+		renderOrder: [],
+		columns: /* @__PURE__ */ new Map()
+	};
+	let pendingEvents = [];
+	let publishedPublication = {
+		snapshot: state,
+		events: []
 	};
-	let publishedSnapshot = toRenderSnapshot(state);
 	let hasPendingPublish = false;
 	let lastPublishAt = 0;
 	let publishTimeout;
@@ -209,10 +175,15 @@ const makeProgressRenderStore = () => {
 		for (const listener of listeners) listener();
 	};
 	const publishNow = () => {
+		const nextPublication = {
+			snapshot: state,
+			events: [...pendingEvents]
+		};
 		hasPendingPublish = false;
-		lastPublishAt = Date.now();
-		publishedSnapshot = toRenderSnapshot(state);
+		publishedPublication = nextPublication;
 		notifyListeners();
+		pendingEvents = [];
+		lastPublishAt = Date.now();
 	};
 	const clearScheduledPublish = () => {
 		if (publishTimeout === void 0) return;
@@ -235,9 +206,10 @@ const makeProgressRenderStore = () => {
 			publishNow();
 		}, waitMillis);
 	};
-	const publish = (nextState) => {
-		if (nextState === state) return;
-		state = nextState;
+	const publish = (update) => {
+		if (update.state === state) return;
+		state = update.state;
+		if (update.events.length > 0) pendingEvents.push(...update.events);
 		hasPendingPublish = true;
 		schedulePublish();
 	};
@@ -245,7 +217,7 @@ const makeProgressRenderStore = () => {
 		publish(transform(state));
 	};
 	return {
-		getSnapshot: () => publishedSnapshot,
+		getSnapshot: () => publishedPublication,
 		subscribe: (listener) => {
 			listeners.add(listener);
 			return () => {
@@ -268,7 +240,7 @@ const makeProgressRenderStore = () => {
 			const now = yield* Clock.currentTimeMillis;
 			const parentId = options.parentId ?? null;
 			const countDisplay = options.countDisplay ?? parentSnapshot?.countDisplay ?? "detailed";
-			const task = new TaskSnapshot({
+			const task = TaskSnapshot({
 				id: taskId,
 				parentId,
 				description: options.description,
@@ -277,7 +249,8 @@ const makeProgressRenderStore = () => {
 				transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
 				units,
 				startedAt: now,
-				completedAt: null
+				completedAt: null,
+				metadata: options.metadata
 			});
 			updateState((current) => {
 				const nextTasks = new Map(current.tasks);
@@ -289,45 +262,72 @@ const makeProgressRenderStore = () => {
 					depth
 				});
 				return {
-					tasks: nextTasks,
-					renderOrder: nextRenderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: nextRenderOrder,
+						columns: options.columns ? new Map(current.columns).set(taskId, options.columns) : current.columns
+					},
+					events: [new TaskAddedEvent({
+						taskId,
+						parentId,
+						description: task.description,
+						total: task.units.total,
+						transient: task.transient,
+						countDisplay: task.countDisplay
+					})]
 				};
 			});
 			return taskId;
 		}),
-		updateTask: (taskId, options) => Effect.gen(function* () {
-			const currentTask = state.tasks.get(taskId);
-			if (!currentTask) return;
-			const nextTask = updatedSnapshot(currentTask, options);
+		updateTask: (taskId, options) => Effect.sync(() => {
 			updateState((current) => {
-				if (!current.tasks.get(taskId)) return current;
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
+				const nextTask = updatedSnapshot(currentTask, options);
 				const nextTasks = new Map(current.tasks);
 				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));
+				const events = [new TaskUpdatedEvent({
+					taskId,
+					description: options.description ?? void 0,
+					succeeded: options.succeeded ?? void 0,
+					failed: options.failed ?? void 0,
+					processed: options.succeeded !== void 0 || options.failed !== void 0 ? nextTask.units.processed : void 0,
+					total: hasExplicitTotal(options) ? nextTask.units.total : void 0,
+					transient: options.transient ?? void 0,
+					countDisplay: options.countDisplay ?? void 0
+				})];
+				if (options.transient !== void 0) for (const candidateId of subtreeTaskIds(current.renderOrder, taskId).slice(1)) {
+					const candidate = current.tasks.get(candidateId);
+					if (!candidate) continue;
+					const nextCandidate = withTransient(candidate, nextTask.transient);
+					nextTasks.set(candidateId, nextCandidate);
+					events.push(new TaskUpdatedEvent({
+						taskId: candidateId,
+						transient: nextCandidate.transient
+					}));
 				}
 				return {
-					tasks: nextTasks,
-					renderOrder: current.renderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events
 				};
 			});
 		}),
 		incrementSucceeded: (taskId, amount = 1) => Effect.sync(() => {
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return current;
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, new TaskSnapshot({
+				nextTasks.set(taskId, TaskSnapshot({
 					id: currentTask.id,
 					parentId: currentTask.parentId,
 					description: currentTask.description,
@@ -340,20 +340,32 @@ const makeProgressRenderStore = () => {
 						total: currentTask.units.total
 					}),
 					startedAt: currentTask.startedAt,
-					completedAt: currentTask.completedAt
+					completedAt: currentTask.completedAt,
+					metadata: currentTask.metadata
 				}));
 				return {
-					tasks: nextTasks,
-					renderOrder: current.renderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events: [new TaskAdvancedEvent({
+						taskId,
+						amount,
+						kind: "succeeded"
+					})]
 				};
 			});
 		}),
 		incrementFailed: (taskId, amount = 1) => Effect.sync(() => {
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return current;
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, new TaskSnapshot({
+				nextTasks.set(taskId, TaskSnapshot({
 					id: currentTask.id,
 					parentId: currentTask.parentId,
 					description: currentTask.description,
@@ -366,11 +378,20 @@ const makeProgressRenderStore = () => {
 						total: currentTask.units.total
 					}),
 					startedAt: currentTask.startedAt,
-					completedAt: currentTask.completedAt
+					completedAt: currentTask.completedAt,
+					metadata: currentTask.metadata
 				}));
 				return {
-					tasks: nextTasks,
-					renderOrder: current.renderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events: [new TaskAdvancedEvent({
+						taskId,
+						amount,
+						kind: "failed"
+					})]
 				};
 			});
 		}),
@@ -378,16 +399,30 @@ const makeProgressRenderStore = () => {
 			const now = yield* Clock.currentTimeMillis;
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return current;
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
+				if (currentTask.status !== "running") return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
 				if (currentTask.transient) {
-					nextTasks.delete(taskId);
+					const removedTaskIds = subtreeTaskIds(current.renderOrder, taskId);
+					for (const removedTaskId of removedTaskIds) nextTasks.delete(removedTaskId);
+					const nextColumns = new Map(current.columns);
+					for (const removedTaskId of removedTaskIds) nextColumns.delete(removedTaskId);
 					return {
-						tasks: nextTasks,
-						renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+						state: {
+							tasks: nextTasks,
+							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
+							columns: nextColumns
+						},
+						events: [new TaskCompletedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
 					};
 				}
-				nextTasks.set(taskId, new TaskSnapshot({
+				nextTasks.set(taskId, TaskSnapshot({
 					id: currentTask.id,
 					parentId: currentTask.parentId,
 					description: currentTask.description,
@@ -404,11 +439,16 @@ const makeProgressRenderStore = () => {
 						total: currentTask.units.processed
 					}) : currentTask.units,
 					startedAt: currentTask.startedAt,
-					completedAt: now
+					completedAt: now,
+					metadata: currentTask.metadata
 				}));
 				return {
-					tasks: nextTasks,
-					renderOrder: current.renderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events: [new TaskCompletedEvent({ taskId })]
 				};
 			});
 		}),
@@ -416,16 +456,30 @@ const makeProgressRenderStore = () => {
 			const now = yield* Clock.currentTimeMillis;
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return current;
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
+				if (currentTask.status !== "running") return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
 				if (currentTask.transient) {
-					nextTasks.delete(taskId);
+					const removedTaskIds = subtreeTaskIds(current.renderOrder, taskId);
+					for (const removedTaskId of removedTaskIds) nextTasks.delete(removedTaskId);
+					const nextColumns = new Map(current.columns);
+					for (const removedTaskId of removedTaskIds) nextColumns.delete(removedTaskId);
 					return {
-						tasks: nextTasks,
-						renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+						state: {
+							tasks: nextTasks,
+							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
+							columns: nextColumns
+						},
+						events: [new TaskFailedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
 					};
 				}
-				nextTasks.set(taskId, new TaskSnapshot({
+				nextTasks.set(taskId, TaskSnapshot({
 					id: currentTask.id,
 					parentId: currentTask.parentId,
 					description: currentTask.description,
@@ -434,60 +488,139 @@ const makeProgressRenderStore = () => {
 					transient: currentTask.transient,
 					units: currentTask.units,
 					startedAt: currentTask.startedAt,
-					completedAt: now
+					completedAt: now,
+					metadata: currentTask.metadata
 				}));
 				return {
-					tasks: nextTasks,
-					renderOrder: current.renderOrder
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events: [new TaskFailedEvent({ taskId })]
 				};
 			});
 		}),
 		getTask: (taskId) => Effect.sync(() => Option.fromNullable(state.tasks.get(taskId))),
-		listTasks: Effect.sync(() => Array.from(state.tasks.values()))
+		listTasks: Effect.sync(() => Array.from(state.tasks.values())),
+		setMetadata: (taskId, metadata) => Effect.sync(() => {
+			updateState((current) => {
+				const currentTask = current.tasks.get(taskId);
+				if (!currentTask) return {
+					state: current,
+					events: []
+				};
+				const nextTasks = new Map(current.tasks);
+				nextTasks.set(taskId, TaskSnapshot({
+					id: currentTask.id,
+					parentId: currentTask.parentId,
+					description: currentTask.description,
+					status: currentTask.status,
+					countDisplay: currentTask.countDisplay,
+					transient: currentTask.transient,
+					units: currentTask.units,
+					startedAt: currentTask.startedAt,
+					completedAt: currentTask.completedAt,
+					metadata
+				}));
+				return {
+					state: {
+						tasks: nextTasks,
+						renderOrder: current.renderOrder,
+						columns: current.columns
+					},
+					events: []
+				};
+			});
+		}),
+		getMetadata: (taskId) => Effect.sync(() => {
+			return state.tasks.get(taskId)?.metadata;
+		})
 	};
 };
 
 //#endregion
-//#region src/ink-renderer/columns/frame.ts
-const createRenderFrame = (rows, now, tick, stickyWidths) => {
-	const tasks = /* @__PURE__ */ new Map();
-	const trees = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		tasks.set(row.task.id, row.task);
-		trees.set(row.task.id, row.tree);
-	}
-	return {
-		taskIds: rows.map((row) => row.task.id),
-		now,
-		tick,
-		stickyWidths,
-		getTask: (taskId) => {
-			const task = tasks.get(taskId);
-			if (task === void 0) throw new Error(`Unknown task id: ${taskId}`);
-			return task;
-		},
-		getTree: (taskId) => {
-			const tree = trees.get(taskId);
-			if (tree === void 0) throw new Error(`Unknown task tree: ${taskId}`);
-			return tree;
-		}
-	};
+//#region src/renderer/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/ink-renderer/format.ts
-const SPINNER_FRAMES = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
+//#region src/renderer/context/now-context.tsx
+const NOW_INTERVAL_MILLIS = 1e3;
+const NowContext = createContext(Date.now());
+const NowProvider = ({ active, children, nowOverride }) => {
+	const liveNow = useNowClock(active, NOW_INTERVAL_MILLIS);
+	const now = nowOverride ?? liveNow;
+	return /* @__PURE__ */ jsx(NowContext.Provider, {
+		value: now,
+		children
+	});
+};
+const useNow = () => useContext(NowContext);
+
+//#endregion
+//#region src/renderer/hooks/use-spinner-clock.ts
+const normalizeIntervalMillis = (intervalMillis) => Math.max(1, intervalMillis);
+const getSpinnerTickAtTime = (baseTick, startedAt, now, intervalMillis) => {
+	const elapsedMillis = Math.max(0, now - startedAt);
+	return baseTick + Math.floor(elapsedMillis / normalizeIntervalMillis(intervalMillis));
+};
+const useSpinnerClock = (active, intervalMillis) => {
+	const [tick, setTick] = useState(0);
+	const tickRef = useRef(tick);
+	useEffect(() => {
+		tickRef.current = tick;
+	}, [tick]);
+	useEffect(() => {
+		if (!active) return;
+		const baseTick = tickRef.current;
+		const startedAt = Date.now();
+		const updateTick = () => {
+			setTick(getSpinnerTickAtTime(baseTick, startedAt, Date.now(), intervalMillis));
+		};
+		updateTick();
+		const interval = setInterval(() => {
+			updateTick();
+		}, normalizeIntervalMillis(intervalMillis));
+		return () => {
+			clearInterval(interval);
+		};
+	}, [active, intervalMillis]);
+	return tick;
+};
+
+//#endregion
+//#region src/renderer/context/spinner-context.tsx
+const DEFAULT_SPINNER_INTERVAL_MILLIS = cliSpinners.dots.interval;
+const SpinnerContext = createContext(0);
+const SpinnerProvider = ({ active, children, intervalMillis = DEFAULT_SPINNER_INTERVAL_MILLIS, tickOverride }) => {
+	const liveTick = useSpinnerClock(active, intervalMillis);
+	const tick = tickOverride ?? liveTick;
+	return /* @__PURE__ */ jsx(SpinnerContext.Provider, {
+		value: tick,
+		children
+	});
+};
+const useSpinnerTick = () => useContext(SpinnerContext);
+
+//#endregion
+//#region src/renderer/shared/determinate.ts
+const isDeterminate$2 = (task) => task.units.total !== void 0;
+
+//#endregion
+//#region src/renderer/shared/format.ts
 const isDeterminate$1 = (task) => task.units.total !== void 0;
 const showsUnknownTotalCounts = (task) => task.units.total === void 0 && task.units.processed > 0;
 const formatDurationSeconds = (seconds) => {
@@ -513,37 +646,6 @@ const formatEta = (task, now) => {
 	const elapsedMillis = Math.max(1, now - task.startedAt);
 	return formatDurationSeconds(Math.max(0, Math.floor(elapsedMillis / processed * remaining)) / 1e3);
 };
-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 (!isDeterminate$1(task)) 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 (!isDeterminate$1(task)) return;
 	const totalText = `${task.units.total}`;
@@ -556,16 +658,6 @@ const formatDeterminateAmountParts = (task) => {
 		total: totalText
 	};
 };
-const getDeterminateProcessedColor = (task) => {
-	if (!isDeterminate$1(task)) return "whiteBright";
-	const { succeeded, failed, processed, total } = task.units;
-	if (task.status === "failed" && processed < total) return "red";
-	if (processed >= total && failed === 0) return "green";
-	if (processed >= total && failed > 0 && succeeded === 0) return "red";
-	if (succeeded > 0 && failed > 0) return "yellow";
-	if (failed > 0 && succeeded === 0) return "red";
-	return "whiteBright";
-};
 const formatAmount = (task, _tick) => {
 	if (isDeterminate$1(task)) {
 		const parts = formatDeterminateAmountParts(task);
@@ -582,50 +674,8 @@ const formatAmount = (task, _tick) => {
 };
 
 //#endregion
-//#region src/ink-renderer/columns/node.ts
-const createColumnDefinition = (config, create) => {
-	return {
-		id: Hash.hash(Data.struct(config)).toString(36),
-		build: (frame) => create(frame, config)
-	};
-};
-
-//#endregion
-//#region src/ink-renderer/columns/sticky-width.ts
-const applyStickyWidth = ({ key, measure, stickyWidths }) => {
-	const preferred = Math.max(measure.preferred, stickyWidths.get(key) ?? 0);
-	const max = measure.max === void 0 ? void 0 : Math.max(measure.max, preferred);
-	return {
-		...measure,
-		preferred,
-		max
-	};
-};
-const commitStickyWidth = ({ key, measure, stickyWidths }) => {
-	stickyWidths.set(key, measure.preferred);
-};
-const createStickyColumn = ({ frame, measure: baseMeasure, render, stickyKey }) => {
-	const measure = stickyKey === void 0 ? baseMeasure : applyStickyWidth({
-		key: stickyKey,
-		measure: baseMeasure,
-		stickyWidths: frame.stickyWidths
-	});
-	return {
-		measure,
-		commitStickyWidth: stickyKey === void 0 ? void 0 : () => {
-			commitStickyWidth({
-				key: stickyKey,
-				measure,
-				stickyWidths: frame.stickyWidths
-			});
-		},
-		render
-	};
-};
-
-//#endregion
-//#region src/ink-renderer/columns/text-width.ts
-const WIDTH_CACHE_LIMIT = 4096;
+//#region src/renderer/shared/text-width.ts
+const WIDTH_CACHE_LIMIT = 8192;
 const widthCache = /* @__PURE__ */ new Map();
 const textWidth = (text) => {
 	const cached = widthCache.get(text);
@@ -637,725 +687,526 @@ const textWidth = (text) => {
 };
 
 //#endregion
-//#region src/ink-renderer/columns/description-column.tsx
-const MIN_PLAIN_DESCRIPTION_WIDTH = 8;
-const MIN_COMPACT_DESCRIPTION_WIDTH = 3;
-const MIN_SPINNER_WIDTH = 1;
-const MIN_TREE_DESCRIPTION_TEXT_WIDTH = 6;
-const DESCRIPTION_TREE_STICKY_KEY = Symbol("description.tree");
-const DESCRIPTION_PLAIN_STICKY_KEY = Symbol("description.plain");
-const DESCRIPTION_COMPACT_STICKY_KEY = Symbol("description.compact");
-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/renderer/columns/amount-column.tsx
+const hasUnknownTotalCounts = (task) => task.units.total === void 0 && task.units.processed > 0;
+const hasCountedAmount = (task) => isDeterminate$2(task) || hasUnknownTotalCounts(task);
+const totalTextFor = (task) => task.units.total === void 0 ? "?" : `${task.units.total}`;
+const emptyAmountLayout = {
+	hasDetailedRows: false,
+	countWidth: 0,
+	processedWidth: 0,
+	totalWidth: 0,
+	preferredWidth: 0
 };
-const maxDescriptionWidth = (frame, showTree) => frame.taskIds.reduce((max, taskId) => {
-	const treePrefix = showTree ? renderTreePrefix(frame.getTree(taskId)) : "";
-	return Math.max(max, textWidth(`${treePrefix}${frame.getTask(taskId).description}`) + 2);
-}, MIN_PLAIN_DESCRIPTION_WIDTH);
-const minTreeDescriptionWidth = (frame) => frame.taskIds.reduce((max, taskId) => {
-	const treePrefixWidth = textWidth(renderTreePrefix(frame.getTree(taskId)));
-	return Math.max(max, treePrefixWidth + 2 + MIN_TREE_DESCRIPTION_TEXT_WIDTH);
-}, MIN_PLAIN_DESCRIPTION_WIDTH);
-const DescriptionColumn = (frame, config = {}) => {
-	const variant = config.variant ?? "plain";
-	const showTree = variant === "tree";
-	const stickyKey = variant === "tree" ? DESCRIPTION_TREE_STICKY_KEY : variant === "plain" ? DESCRIPTION_PLAIN_STICKY_KEY : variant === "compact" ? DESCRIPTION_COMPACT_STICKY_KEY : void 0;
-	const min = variant === "spinner" ? MIN_SPINNER_WIDTH : variant === "compact" ? MIN_COMPACT_DESCRIPTION_WIDTH : variant === "tree" ? minTreeDescriptionWidth(frame) : MIN_PLAIN_DESCRIPTION_WIDTH;
-	const preferred = variant === "spinner" ? MIN_SPINNER_WIDTH : Math.max(min, maxDescriptionWidth(frame, showTree));
-	return createStickyColumn({
-		frame,
-		measure: {
-			min,
-			preferred,
-			max: preferred
-		},
-		stickyKey,
-		render: (taskId) => {
-			const task = frame.getTask(taskId);
-			const tree = frame.getTree(taskId);
-			const treePrefix = showTree ? renderTreePrefix(tree) : "";
-			const indicator = getTaskIndicator(task, frame.tick);
-			if (variant === "spinner") return /* @__PURE__ */ jsx(Text, {
-				color: indicator.color,
-				children: indicator.symbol
-			});
-			return /* @__PURE__ */ jsxs(Text, {
-				wrap: "truncate-end",
-				children: [
-					treePrefix,
-					/* @__PURE__ */ jsx(Text, {
-						color: indicator.color,
-						children: indicator.symbol
-					}),
-					` ${task.description}`
-				]
-			});
-		}
-	});
+const measureAmountLayout = (rows) => {
+	const countedTasks = rows.flatMap((row) => hasCountedAmount(row.task) ? [row.task] : []);
+	const hasDetailedRows = countedTasks.some((task) => task.countDisplay === "detailed");
+	if (countedTasks.length === 0) {
+		const preferredWidth = rows.reduce((max, row) => Math.max(max, textWidth(formatAmount(row.task, 0))), 0);
+		return {
+			...emptyAmountLayout,
+			preferredWidth
+		};
+	}
+	const processedWidth = countedTasks.reduce((max, task) => Math.max(max, `${task.units.processed}`.length), 1);
+	const totalWidth = countedTasks.reduce((max, task) => Math.max(max, totalTextFor(task).length), 1);
+	const countWidth = hasDetailedRows ? countedTasks.reduce((max, task) => Math.max(max, processedWidth, totalWidth, `${task.units.succeeded}`.length, `${task.units.failed}`.length), 1) : 0;
+	const countedWidth = (hasDetailedRows ? countWidth + 1 + countWidth + 1 : 0) + processedWidth + 1 + totalWidth;
+	return {
+		hasDetailedRows,
+		countWidth,
+		processedWidth,
+		totalWidth,
+		preferredWidth: rows.reduce((max, row) => {
+			if (hasCountedAmount(row.task)) return Math.max(max, countedWidth);
+			return Math.max(max, textWidth(formatAmount(row.task, 0)));
+		}, countedWidth)
+	};
 };
-const createDescriptionRootColumn = (variant) => createColumnDefinition({
-	_tag: "description",
-	variant
-}, (frame, config) => DescriptionColumn(frame, config));
-const DescriptionTreeRootColumn = createDescriptionRootColumn("tree");
-const DescriptionPlainRootColumn = createDescriptionRootColumn("plain");
-const DescriptionCompactRootColumn = createDescriptionRootColumn("compact");
-const DescriptionSpinnerRootColumn = createDescriptionRootColumn("spinner");
+const renderAmount = (task, layout) => {
+	if (!hasCountedAmount(task)) return formatAmount(task, 0);
+	const processed = `${task.units.processed}`.padStart(layout.processedWidth, " ");
+	const total = totalTextFor(task).padStart(layout.totalWidth, " ");
+	if (!layout.hasDetailedRows) return `${processed}/${total}`;
+	if (task.countDisplay !== "detailed") return `${" ".repeat(layout.countWidth)} ${" ".repeat(layout.countWidth)} ${processed}/${total}`;
+	const succeeded = `${task.units.succeeded}`.padStart(layout.countWidth, " ");
+	const failed = `${task.units.failed}`.padStart(layout.countWidth, " ");
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(Text, {
+			color: "green",
+			children: succeeded
+		}),
+		/* @__PURE__ */ jsx(Text, { children: ` ` }),
+		/* @__PURE__ */ jsx(Text, {
+			color: "red",
+			children: failed
+		}),
+		/* @__PURE__ */ jsx(Text, { children: ` ${processed}/${total}` })
+	] });
+};
+const AmountCell = ({ task, layout }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
+	children: renderAmount(task, layout)
+});
 
 //#endregion
-//#region src/ink-renderer/columns/elapsed-column.tsx
-const MIN_ELAPSED_WIDTH = Array.from("10s").length;
-const ELAPSED_STICKY_KEY = Symbol("elapsed");
-const maxElapsedWidth = (frame) => frame.taskIds.reduce((max, taskId) => Math.max(max, textWidth(formatElapsed(frame.getTask(taskId), frame.now))), MIN_ELAPSED_WIDTH);
-const ElapsedColumn = (frame) => {
-	const elapsedContentWidth = maxElapsedWidth(frame);
-	return createStickyColumn({
-		frame,
-		stickyKey: ELAPSED_STICKY_KEY,
-		measure: {
-			min: MIN_ELAPSED_WIDTH,
-			preferred: elapsedContentWidth,
-			max: elapsedContentWidth
-		},
-		render: (taskId, width) => {
-			const formatted = formatElapsed(frame.getTask(taskId), frame.now);
-			return /* @__PURE__ */ jsx(Box, {
-				width,
-				justifyContent: "flex-end",
-				children: /* @__PURE__ */ jsx(Text, {
-					color: "gray",
-					children: textWidth(formatted) <= width ? formatted : formatted.slice(0, width)
-				})
-			});
-		}
+//#region src/renderer/columns/bar-column.tsx
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+const prepareBar = (rows) => {
+	return { hasDeterminateRows: rows.some((row) => row.derived.isDeterminate) };
+};
+const renderProgressBar = (task, width) => {
+	if (!isDeterminate$2(task)) return /* @__PURE__ */ jsx(Text, { children: ` `.repeat(Math.max(0, width)) });
+	const displayTotal = Math.max(task.units.total, task.units.succeeded + task.units.failed);
+	const succeededEnd = displayTotal === 0 ? width : Math.round(task.units.succeeded / displayTotal * width);
+	const failedEnd = displayTotal === 0 ? width : Math.round((task.units.succeeded + task.units.failed) / displayTotal * width);
+	const succeededLength = clamp(succeededEnd, 0, width);
+	const failedLength = clamp(failedEnd, succeededLength, width) - succeededLength;
+	const remainingLength = Math.max(0, width - succeededLength - failedLength);
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "green",
+				children: "━".repeat(succeededLength)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "red",
+				children: "━".repeat(failedLength)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: "─".repeat(remainingLength)
+			})
+		]
 	});
 };
-const ElapsedRootColumn = createColumnDefinition({ _tag: "elapsed" }, (frame) => ElapsedColumn(frame));
+const BarCell = ({ task, width }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
+	children: renderProgressBar(task, width ?? 0)
+});
 
 //#endregion
-//#region src/ink-renderer/columns/determinate.ts
+//#region src/renderer/columns/description-column.tsx
+const MIN_TREE_DESCRIPTION_TEXT_WIDTH = 6;
+const DEFAULT_SPINNER_TYPE = "dots";
 const isDeterminate = (task) => task.units.total !== void 0;
-
-//#endregion
-//#region src/ink-renderer/columns/eta-column.tsx
-const primaryUnit = (duration) => duration.split(" ")[0] ?? duration;
-const ETA_STICKY_KEY = Symbol("eta");
-const etaDurationText = (task, now) => {
-	if (task.status !== "running" || !isDeterminate(task)) return;
-	const eta = formatEta(task, now);
-	return eta.length > 0 ? eta : "--";
-};
-const renderEtaText = (task, now, width) => {
-	const duration = etaDurationText(task, now);
-	if (duration === void 0) return "";
-	const prefixed = `ETA: ${duration}`;
-	if (width >= textWidth(prefixed)) return prefixed;
-	if (width >= textWidth(duration)) return duration;
-	return primaryUnit(duration);
+const getSpinnerFrame = (tick, spinnerType) => {
+	const frames = cliSpinners[spinnerType].frames;
+	return frames[(tick % frames.length + frames.length) % frames.length] ?? frames[0] ?? "";
 };
-const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
-const computeEtaMetrics = (frame) => {
-	let hasEta = false;
-	let prefixedWidth = 0;
-	let durationWidth = 0;
-	let primaryUnitWidth = 0;
-	for (const taskId of frame.taskIds) {
-		const duration = etaDurationText(frame.getTask(taskId), frame.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 getTaskIndicator = (task, tick, spinnerType = DEFAULT_SPINNER_TYPE) => {
+	if (task.status === "running") return {
+		symbol: getSpinnerFrame(tick, spinnerType),
+		color: "yellow"
+	};
+	if (task.status === "failed") return {
+		symbol: "✗",
+		color: "red"
+	};
+	if (!isDeterminate(task)) 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"
 	};
-};
-const EtaColumn = (frame) => {
-	const metrics = computeEtaMetrics(frame);
-	if (!metrics.hasEta) return;
-	return createStickyColumn({
-		frame,
-		stickyKey: ETA_STICKY_KEY,
-		measure: {
-			min: metrics.primaryUnitWidth,
-			preferred: Math.max(metrics.prefixedWidth, RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR),
-			max: Math.max(metrics.prefixedWidth, RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR)
-		},
-		render: (taskId, width) => /* @__PURE__ */ jsx(Text, {
-			wrap: "truncate-end",
-			color: "gray",
-			children: renderEtaText(frame.getTask(taskId), frame.now, width)
-		})
-	});
-};
-const EtaRootColumn = createColumnDefinition({ _tag: "eta" }, (frame) => EtaColumn(frame));
-
-//#endregion
-//#region src/ink-renderer/columns/progress/shared.ts
-const DEFAULT_BAR_WIDTH = 30;
-const PERCENT_FALLBACK_WIDTH = 10;
-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 shouldShowCountAmount = (task) => task.units.total !== void 0 || task.units.processed > 0;
-const shouldShowDetailedCounts = (task) => shouldShowCountAmount(task) && task.countDisplay === "detailed";
-const computeProgressMetrics = (frame) => {
-	let hasStructuredCounts = false;
-	let hasDetailed = false;
-	let hasDeterminate = false;
-	let countDigits = 0;
-	let totalWidth = 0;
-	let simpleTextWidth = 0;
-	for (const taskId of frame.taskIds) {
-		const task = frame.getTask(taskId);
-		hasDeterminate ||= isDeterminate(task);
-		if (shouldShowCountAmount(task)) {
-			hasStructuredCounts = true;
-			countDigits = Math.max(countDigits, textWidth(`${task.units.succeeded}`), textWidth(`${task.units.failed}`), textWidth(`${task.units.processed}`));
-			totalWidth = Math.max(totalWidth, textWidth(isDeterminate(task) ? `${task.units.total}` : "?"));
-			if (task.countDisplay === "detailed") hasDetailed = true;
-			continue;
-		}
-		simpleTextWidth = Math.max(simpleTextWidth, textWidth(formatAmount(task, frame.tick)));
-	}
 	return {
-		hasStructuredCounts,
-		hasDetailed,
-		hasDeterminate,
-		countDigits: Math.max(1, countDigits),
-		totalWidth: Math.max(1, totalWidth),
-		simpleTextWidth
+		symbol: "✓",
+		color: "green"
 	};
 };
-const processedAmountWidth = (metrics) => metrics.countDigits + 1 + metrics.totalWidth;
-const detailedAmountWidth = (metrics) => metrics.countDigits + 1 + metrics.totalWidth + (metrics.hasDetailed ? metrics.countDigits + 1 + metrics.countDigits + 1 : 0);
-const percentText = (task) => {
-	if (!isDeterminate(task)) return formatAmount(task, 0);
-	if (task.units.total === 0) return "100%";
-	const displayTotal = Math.max(task.units.total, task.units.processed);
-	return `${Math.max(0, Math.min(100, Math.round(task.units.processed / displayTotal * 100)))}%`;
-};
-
-//#endregion
-//#region src/ink-renderer/columns/progress/amount-column.tsx
-const succeededCount = (task, width) => {
-	if (width <= 0 || !shouldShowCountAmount(task) || !shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+const prepareDescription = (rows) => ({ minTreeWidth: rows.reduce((max, row) => Math.max(max, row.derived.treePrefixWidth + 2 + MIN_TREE_DESCRIPTION_TEXT_WIDTH), MIN_TREE_DESCRIPTION_TEXT_WIDTH + 2) });
+const TaskIndicatorGlyph = ({ task, tick, spinnerType = DEFAULT_SPINNER_TYPE }) => {
+	const indicator = getTaskIndicator(task, tick, spinnerType);
 	return /* @__PURE__ */ jsx(Text, {
-		color: "green",
-		children: padLeft(`${task.units.succeeded}`, width)
+		color: indicator.color,
+		children: indicator.symbol
 	});
 };
-const failedCount = (task, width) => {
-	if (width <= 0 || !shouldShowCountAmount(task) || !shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
-	return /* @__PURE__ */ jsx(Text, {
-		color: "red",
-		children: padLeft(`${task.units.failed}`, width)
+const DescriptionCell = ({ cell, width, minTreeWidth, spinnerTick }) => {
+	const showTree = width === void 0 || width >= minTreeWidth;
+	const treePrefix = showTree ? cell.derived.treePrefix : "";
+	if (!showTree && width !== void 0 && width <= 1) return /* @__PURE__ */ jsx(TaskIndicatorGlyph, {
+		task: cell.task,
+		tick: spinnerTick
 	});
-};
-const processedCount = (task, width) => {
-	if (width <= 0 || !shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
-	return /* @__PURE__ */ jsx(Text, { children: padLeft(`${task.units.processed}`, width) });
-};
-const totalCount = (task, width) => {
-	if (width <= 0 || !shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
-	return /* @__PURE__ */ jsx(Text, { children: padRight(isDeterminate(task) ? `${task.units.total}` : "?", width) });
-};
-const structuredAmount = (task, tick, width, layout) => {
-	if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, {
+	if (!showTree && width !== void 0 && width === 2) return /* @__PURE__ */ jsxs(Text, {
 		wrap: "truncate-end",
-		children: formatAmount(task, tick)
-	});
-	if (layout.kind === "processed") return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "row",
-		width,
-		children: [
-			processedCount(task, layout.processedWidth),
-			/* @__PURE__ */ jsx(Text, { children: "/" }),
-			totalCount(task, layout.totalWidth)
-		]
+		children: [/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
+			task: cell.task,
+			tick: spinnerTick
+		}), "…"]
 	});
-	return /* @__PURE__ */ jsxs(Box, {
-		flexDirection: "row",
-		width,
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
 		children: [
-			layout.succeededWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [succeededCount(task, layout.succeededWidth), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
-			layout.failedWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [failedCount(task, layout.failedWidth), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
-			processedCount(task, layout.processedWidth),
-			/* @__PURE__ */ jsx(Text, { children: "/" }),
-			totalCount(task, layout.totalWidth)
+			treePrefix,
+			/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
+				task: cell.task,
+				tick: spinnerTick
+			}),
+			` ${cell.task.description}`
 		]
 	});
 };
-const AmountColumn = (frame, config) => {
-	const metrics = config.metrics ?? computeProgressMetrics(frame);
-	const detailedWidth = detailedAmountWidth(metrics);
-	const processedWidth = processedAmountWidth(metrics);
-	const preferredWidth = metrics.hasStructuredCounts ? metrics.hasDetailed ? detailedWidth : processedWidth : Math.max(1, metrics.simpleTextWidth);
-	const minWidth = metrics.hasStructuredCounts ? processedWidth : Math.max(1, metrics.simpleTextWidth);
-	const summary = {
-		hasDetailed: metrics.hasDetailed,
-		countDigits: metrics.countDigits,
-		totalWidth: metrics.totalWidth,
-		detailedWidth,
-		processedWidth,
-		preferredWidth,
-		minWidth,
-		simpleTextWidth: Math.max(1, metrics.simpleTextWidth)
-	};
-	return createStickyColumn({
-		frame,
-		measure: {
-			min: summary.minWidth,
-			preferred: summary.preferredWidth,
-			max: summary.preferredWidth
-		},
-		stickyKey: config.stickyWidth === true ? config.key : void 0,
-		render: (taskId, width) => {
-			const task = frame.getTask(taskId);
-			if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, {
-				wrap: "truncate-end",
-				children: formatAmount(task, frame.tick)
-			});
-			if (summary.hasDetailed && width >= summary.detailedWidth) return structuredAmount(task, frame.tick, width, {
-				kind: "detailed",
-				succeededWidth: summary.countDigits,
-				failedWidth: summary.countDigits,
-				processedWidth: summary.countDigits,
-				totalWidth: summary.totalWidth
-			});
-			return structuredAmount(task, frame.tick, width, {
-				kind: "processed",
-				processedWidth: summary.countDigits,
-				totalWidth: summary.totalWidth
-			});
-		}
+
+//#endregion
+//#region src/renderer/columns/elapsed-column.tsx
+const ElapsedCell = ({ task, now }) => {
+	return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		color: "gray",
+		children: formatElapsed(task, now)
 	});
 };
 
 //#endregion
-//#region src/ink-renderer/columns/progress/bar-column.tsx
-const segmentLengths = (width, total, succeeded, failed) => {
-	if (total === 0) return {
-		succeeded: width,
-		failed: 0,
-		remaining: 0
-	};
-	const displayTotal = Math.max(total, succeeded + failed);
-	const succeededEnd = Math.round(succeeded / displayTotal * width);
-	const failedEnd = Math.round((succeeded + failed) / displayTotal * 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 = (frame, config) => {
-	return createStickyColumn({
-		frame,
-		measure: {
-			min: 4,
-			preferred: DEFAULT_BAR_WIDTH,
-			max: config.fullWidth ? void 0 : DEFAULT_BAR_WIDTH
-		},
-		stickyKey: config.stickyWidth === true ? config.key : void 0,
-		render: (taskId, width) => {
-			const task = frame.getTask(taskId);
-			if (!isDeterminate(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
-			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)
-					})
-				]
-			});
-		}
+//#region src/renderer/columns/eta-column.tsx
+const EtaCell = ({ task, now }) => {
+	const eta = formatEta(task, now);
+	if (eta === "") return null;
+	return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		color: "gray",
+		children: `ETA: ${eta}`
 	});
 };
 
 //#endregion
-//#region src/ink-renderer/columns/progress/percent-column.tsx
-const PercentColumn = (frame) => ({
-	measure: {
-		min: 4,
-		preferred: 4,
-		max: 4
-	},
-	render: (taskId, _width) => {
-		const task = frame.getTask(taskId);
-		const determinateColor = isDeterminate(task) ? getDeterminateProcessedColor(task) : void 0;
-		return /* @__PURE__ */ jsx(Text, {
-			wrap: "truncate-end",
-			color: determinateColor === "green" || determinateColor === "yellow" || determinateColor === "red" ? determinateColor : void 0,
-			children: percentText(task)
-		});
-	}
+//#region src/columns.tsx
+var columns_exports = /* @__PURE__ */ __exportAll({
+	amount: () => amount,
+	bar: () => bar,
+	defaults: () => defaults,
+	description: () => description,
+	elapsed: () => elapsed,
+	eta: () => eta,
+	resolveColumnSizeValue: () => resolveColumnSizeValue,
+	spacer: () => spacer
+});
+const spacer = ({ flexGrow, flexShrink, flexBasis, minWidth } = {}) => ({
+	render: () => null,
+	flexGrow,
+	flexShrink,
+	flexBasis,
+	minWidth
+});
+const description = () => ({
+	prepare: prepareDescription,
+	flexGrow: 1,
+	flexShrink: 1,
+	minWidth: 1,
+	render: (cell, ctx) => /* @__PURE__ */ jsx(DescriptionCell, {
+		cell,
+		width: ctx.width,
+		minTreeWidth: ctx.prepared.minTreeWidth,
+		spinnerTick: ctx.spinnerTick
+	})
+});
+const bar = () => ({
+	prepare: prepareBar,
+	flexShrink: (prepared) => prepared.hasDeterminateRows ? 1 : 0,
+	flexBasis: (prepared) => prepared.hasDeterminateRows ? 30 : 0,
+	minWidth: (prepared) => prepared.hasDeterminateRows ? 4 : 0,
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(BarCell, {
+		task,
+		width: ctx.width
+	})
+});
+const amount = () => ({
+	prepare: measureAmountLayout,
+	align: "right",
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(AmountCell, {
+		task,
+		layout: ctx.prepared
+	})
+});
+const elapsed = () => ({
+	align: "right",
+	flexShrink: 0,
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(ElapsedCell, {
+		task,
+		now: ctx.now
+	})
 });
+const eta = () => ({
+	align: "right",
+	flexShrink: 0,
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(EtaCell, {
+		task,
+		now: ctx.now
+	})
+});
+const defaults = () => [
+	description(),
+	bar(),
+	amount(),
+	elapsed(),
+	eta()
+];
+const resolveColumnSizeValue = (value, prepared) => {
+	if (typeof value === "function") return value(prepared);
+	return value;
+};
 
 //#endregion
-//#region src/ink-renderer/columns/progress-metrics-column.tsx
-const PROGRESS_BAR_STICKY_KEY = Symbol("progress.bar");
-const PROGRESS_AMOUNT_STICKY_KEY = Symbol("progress.amount");
-const createProgressColumnModel = (frame, mode) => {
-	const metrics = computeProgressMetrics(frame);
-	const percent = PercentColumn(frame);
-	if (mode === "percent" && metrics.hasDeterminate) return {
-		metrics,
-		percent
-	};
-	return {
-		metrics,
-		percent,
-		amount: AmountColumn(frame, {
-			key: PROGRESS_AMOUNT_STICKY_KEY,
-			metrics,
-			stickyWidth: true
-		}),
-		bar: metrics.hasDeterminate ? BarColumn(frame, {
-			key: PROGRESS_BAR_STICKY_KEY,
-			fullWidth: false,
-			stickyWidth: true
-		}) : void 0
-	};
+//#region src/renderer/column-resolver.ts
+const NO_PREPARE = Symbol("no-prepare");
+const getColumnsForRow = (row, columns) => columns.get(row.task.id) ?? defaults();
+const toCellInfo = (row) => row;
+const maxDefined = (values) => values.reduce((maxValue, value) => value === void 0 ? maxValue : Math.max(maxValue ?? Number.NEGATIVE_INFINITY, value), void 0);
+const resolvePreparedGroups = (defs, cellInfos) => {
+	const groupedRows = /* @__PURE__ */ new Map();
+	defs.forEach((def, rowIndex) => {
+		if (!def?.prepare) return;
+		const key = def.prepare;
+		const rows = groupedRows.get(key);
+		const cell = cellInfos[rowIndex];
+		if (!cell) return;
+		if (rows) rows.push(cell);
+		else groupedRows.set(key, [cell]);
+	});
+	const groups = [{
+		key: NO_PREPARE,
+		prepared: void 0
+	}];
+	for (const [key, rows] of groupedRows) groups.push({
+		key,
+		prepared: key(rows)
+	});
+	return groups;
 };
-const layoutForWidth = (width, model) => {
-	if (!model.metrics.hasDeterminate || model.amount === void 0) return { kind: "amount-only" };
-	const bar = model.bar;
-	if (bar === void 0) return { kind: "percent" };
-	if (width < bar.measure.min + 1 + model.amount.measure.min || width < PERCENT_FALLBACK_WIDTH) return { kind: "percent" };
-	const available = Math.max(0, width - 1);
-	const amountWidth = Math.min(model.amount.measure.preferred, Math.max(model.amount.measure.min, available - bar.measure.min));
-	return {
-		kind: "bar-amount",
-		bar,
-		barWidth: Math.max(bar.measure.min, available - amountWidth),
-		amountWidth
-	};
+const getPreparedFor = (def, groups) => {
+	if (!def?.prepare) return;
+	return groups.find((group) => group.key === def.prepare)?.prepared;
 };
-const ProgressMetricsColumn = (frame, config = {}) => {
-	const mode = config.mode ?? "full";
-	const model = createProgressColumnModel(frame, mode);
-	if (!model.metrics.hasStructuredCounts && !model.metrics.hasDeterminate) return;
-	if (mode === "percent" && model.metrics.hasDeterminate) return model.percent;
-	const amount = model.amount;
-	if (amount === void 0) return;
-	const preferred = model.metrics.hasDeterminate && model.bar !== void 0 ? model.bar.measure.preferred + 1 + amount.measure.preferred : amount.measure.preferred;
-	const fullMin = model.metrics.hasDeterminate && model.bar !== void 0 ? model.bar.measure.min + 1 + amount.measure.min : amount.measure.min;
-	const max = !model.metrics.hasDeterminate || model.bar === void 0 || model.bar.measure.max === void 0 ? amount.measure.max : model.bar.measure.max + 1 + amount.measure.preferred;
-	return {
-		measure: {
-			min: !model.metrics.hasDeterminate ? amount.measure.min : fullMin,
-			preferred,
-			max
-		},
-		commitStickyWidth: () => {
-			model.bar?.commitStickyWidth?.();
-			amount.commitStickyWidth?.();
-		},
-		render: (taskId, width) => {
-			const layout = layoutForWidth(width, model);
-			if (layout.kind === "percent") return model.percent.render(taskId, width);
-			if (layout.kind === "amount-only") return amount.render(taskId, width);
-			return /* @__PURE__ */ jsxs(Box, {
-				flexDirection: "row",
-				width,
-				children: [
-					/* @__PURE__ */ jsx(Box, {
-						width: layout.barWidth,
-						children: layout.bar.render(taskId, layout.barWidth)
-					}),
-					/* @__PURE__ */ jsx(Box, { marginRight: 1 }),
-					/* @__PURE__ */ jsx(Box, {
-						width: layout.amountWidth,
-						children: amount.render(taskId, layout.amountWidth)
-					})
-				]
-			});
-		}
-	};
+const resolveColumns = (rows, columns) => {
+	const columnsByRow = rows.map((row) => getColumnsForRow(row, columns));
+	const cellInfos = rows.map(toCellInfo);
+	const maxColumnCount = columnsByRow.reduce((max, defs) => Math.max(max, defs.length), 0);
+	return Array.from({ length: maxColumnCount }, (_, index) => {
+		const defsAtIndex = columnsByRow.map((defs) => defs[index]);
+		const preparedGroups = resolvePreparedGroups(defsAtIndex, cellInfos);
+		const entries = defsAtIndex.map((column) => column === void 0 ? void 0 : {
+			column,
+			prepared: getPreparedFor(column, preparedGroups)
+		});
+		return {
+			index,
+			rows,
+			entries,
+			flexGrow: maxDefined(entries.map((entry) => entry === void 0 ? void 0 : resolveColumnSizeValue(entry.column.flexGrow, entry.prepared))),
+			flexShrink: maxDefined(entries.map((entry) => entry === void 0 ? void 0 : resolveColumnSizeValue(entry.column.flexShrink, entry.prepared))),
+			flexBasis: maxDefined(entries.map((entry) => entry === void 0 ? void 0 : resolveColumnSizeValue(entry.column.flexBasis, entry.prepared))),
+			minWidth: maxDefined(entries.map((entry) => entry === void 0 ? void 0 : resolveColumnSizeValue(entry.column.minWidth, entry.prepared)))
+		};
+	});
 };
-const createProgressRootColumn = (mode) => createColumnDefinition({
-	_tag: "progress",
-	mode
-}, (frame, config) => ProgressMetricsColumn(frame, config));
-const ProgressRootColumn = createProgressRootColumn("full");
-const ProgressPercentRootColumn = createProgressRootColumn("percent");
 
 //#endregion
-//#region src/ink-renderer/columns/root-column.tsx
-const ROOT_GAP = 1;
-const visibleWidth = (widths, gap) => {
-	const visible = widths.filter((width) => width > 0);
-	return visible.reduce((sum, width) => sum + width, 0) + Math.max(0, visible.length - 1) * gap;
-};
-const ROOT_LAYOUTS = [
-	[
-		DescriptionTreeRootColumn,
-		ProgressRootColumn,
-		ElapsedRootColumn,
-		EtaRootColumn
-	],
-	[
-		DescriptionPlainRootColumn,
-		ProgressRootColumn,
-		ElapsedRootColumn,
-		EtaRootColumn
-	],
-	[
-		DescriptionPlainRootColumn,
-		ProgressPercentRootColumn,
-		ElapsedRootColumn,
-		EtaRootColumn
-	],
-	[
-		DescriptionPlainRootColumn,
-		ProgressPercentRootColumn,
-		ElapsedRootColumn
-	],
-	[DescriptionPlainRootColumn, ProgressPercentRootColumn],
-	[DescriptionCompactRootColumn, ProgressPercentRootColumn],
-	[DescriptionCompactRootColumn],
-	[DescriptionSpinnerRootColumn]
-];
-const ROOT_COLUMNS = [...new Map(ROOT_LAYOUTS.flat().map((column) => [column.id, column])).values()];
-const measureColumns = (frame) => new Map(ROOT_COLUMNS.flatMap((definition) => {
-	const column = definition.build(frame);
-	if (column === void 0) return [];
-	const measure = column.measure;
-	return [[definition.id, {
-		definition,
-		id: definition.id,
-		measure,
-		preferredWidth: measure.preferred,
-		commitStickyWidth: column.commitStickyWidth,
-		render: column.render
-	}]];
-}));
-const candidateRootLayouts = (columnsById) => {
-	const hasProgress = columnsById.has(ProgressRootColumn.id);
-	const hasPercentProgress = columnsById.has(ProgressPercentRootColumn.id);
-	const hasEta = columnsById.has(EtaRootColumn.id);
-	return [
-		...hasProgress && hasEta ? [[
-			DescriptionTreeRootColumn,
-			ProgressRootColumn,
-			ElapsedRootColumn,
-			EtaRootColumn
-		], [
-			DescriptionPlainRootColumn,
-			ProgressRootColumn,
-			ElapsedRootColumn,
-			EtaRootColumn
-		]] : [],
-		...hasProgress && !hasEta ? [[
-			DescriptionTreeRootColumn,
-			ProgressRootColumn,
-			ElapsedRootColumn
-		], [
-			DescriptionPlainRootColumn,
-			ProgressRootColumn,
-			ElapsedRootColumn
-		]] : [],
-		...hasPercentProgress && hasEta ? [[
-			DescriptionPlainRootColumn,
-			ProgressPercentRootColumn,
-			ElapsedRootColumn,
-			EtaRootColumn
-		]] : [],
-		...hasPercentProgress ? [
-			[
-				DescriptionPlainRootColumn,
-				ProgressPercentRootColumn,
-				ElapsedRootColumn
-			],
-			[DescriptionPlainRootColumn, ProgressPercentRootColumn],
-			[DescriptionCompactRootColumn, ProgressPercentRootColumn]
-		] : [],
-		...!hasProgress && !hasPercentProgress ? [
-			[DescriptionTreeRootColumn, ElapsedRootColumn],
-			[DescriptionPlainRootColumn, ElapsedRootColumn],
-			[DescriptionPlainRootColumn]
-		] : [],
-		[DescriptionCompactRootColumn],
-		[DescriptionSpinnerRootColumn]
-	];
-};
-const resolveRootLayouts = (columnsById) => {
-	const resolveLayout = (definitions) => {
-		const columns = [];
-		for (const definition of definitions) {
-			const column = columnsById.get(definition.id);
-			if (column === void 0) return;
-			columns.push(column);
-		}
-		return columns;
-	};
-	return candidateRootLayouts(columnsById).map(resolveLayout).filter((columns) => columns !== void 0);
-};
-const minimumWidthForSet = (columns) => visibleWidth(columns.map((column) => column.measure.min), ROOT_GAP);
-const selectColumnSet = (columnSets, terminalColumns) => {
-	if (columnSets.length === 0) return [];
-	if (terminalColumns === void 0) return columnSets[0] ?? [];
-	return columnSets.find((columns) => minimumWidthForSet(columns) <= terminalColumns) ?? columnSets.at(-1) ?? [];
-};
-const preferredWidthsForSet = (columns) => columns.map((column) => Math.max(column.measure.min, column.preferredWidth));
-const nextDistinctWidth = (entries, widest) => entries.find((entry) => entry.width < widest)?.width;
-const reduceOverflowRichStyle = (widths, minimums, targetWidth) => {
-	let overflow = visibleWidth(widths, ROOT_GAP) - targetWidth;
-	while (overflow > 0) {
-		const shrinkable = widths.map((width, index) => ({
-			width,
-			index,
-			minimum: minimums[index] ?? width
-		})).filter(({ width, minimum }) => width > minimum).sort((left, right) => right.width - left.width || left.index - right.index);
-		if (shrinkable.length === 0) break;
-		const widest = shrinkable[0].width;
-		const cohort = shrinkable.filter(({ width }) => width === widest);
-		const nextWidth = nextDistinctWidth(shrinkable, widest);
-		const maxUniformDrop = widest - Math.max(nextWidth ?? 0, ...cohort.map(({ minimum }) => minimum));
-		const uniformDrop = Math.min(maxUniformDrop, Math.floor(overflow / cohort.length));
-		if (uniformDrop > 0) {
-			for (const { index } of cohort) widths[index] = widths[index] - uniformDrop;
-			overflow -= uniformDrop * cohort.length;
-			continue;
-		}
-		let changed = false;
-		for (const { index, minimum } of cohort) {
-			if (overflow <= 0) break;
-			if (widths[index] <= minimum) continue;
-			widths[index] = widths[index] - 1;
-			overflow -= 1;
-			changed = true;
-		}
-		if (!changed) break;
-	}
-	return widths;
+//#region src/renderer/public-api.tsx
+const justifyContentForAlign = (align) => {
+	if (align === "right") return "flex-end";
+	if (align === "center") return "center";
+	return "flex-start";
 };
-const widthForSelectedSet = (columns, targetWidth) => {
-	if (columns.length === 0) return [];
-	if (targetWidth === void 0) return preferredWidthsForSet(columns);
-	const minimums = columns.map((column) => column.measure.min);
-	const widths = preferredWidthsForSet(columns);
-	if (visibleWidth(widths, ROOT_GAP) <= targetWidth) return widths;
-	return reduceOverflowRichStyle(widths, minimums, targetWidth);
+const renderNode = (node) => {
+	if (typeof node === "string" || typeof node === "number") return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		children: node
+	});
+	return node;
 };
-const emptyRootColumn = (stickyWidths) => {
-	stickyWidths.clear();
-	return { render: () => null };
+const ColumnPosition = ({ position }) => {
+	const ref = useRef(null);
+	const { width, hasMeasured } = useBoxMetrics(ref);
+	const now = useNow();
+	const spinnerTick = useSpinnerTick();
+	return /* @__PURE__ */ jsx(Box, {
+		ref,
+		flexDirection: "column",
+		flexGrow: position.flexGrow,
+		flexShrink: position.flexShrink ?? 0,
+		flexBasis: position.flexBasis,
+		minWidth: position.minWidth,
+		children: position.rows.map((row, rowIndex) => {
+			const entry = position.entries[rowIndex];
+			const column = entry?.column;
+			const cell = row;
+			const output = column?.render(cell, {
+				width: hasMeasured ? width : void 0,
+				now,
+				spinnerTick,
+				prepared: entry?.prepared
+			}) ?? null;
+			return /* @__PURE__ */ jsx(Box, {
+				height: 1,
+				justifyContent: justifyContentForAlign(column?.align),
+				children: renderNode(output)
+			}, row.task.id);
+		})
+	});
 };
-const RootColumn = (rows, now, tick, terminalColumns, stickyWidths = /* @__PURE__ */ new Map()) => {
-	if (rows.length === 0) return emptyRootColumn(stickyWidths);
-	const selectedColumns = selectColumnSet(resolveRootLayouts(measureColumns(createRenderFrame(rows, now, tick, stickyWidths))), terminalColumns);
-	for (const column of selectedColumns) column.commitStickyWidth?.();
-	const columns = widthForSelectedSet(selectedColumns, terminalColumns === void 0 ? visibleWidth(selectedColumns.map((column) => column.preferredWidth), ROOT_GAP) : terminalColumns).map((width, index) => ({
-		id: selectedColumns[index].id,
-		width,
-		render: selectedColumns[index].render
-	})).filter((column) => column.width > 0);
-	const taskIds = rows.map((row) => row.task.id);
-	const rowWidth = visibleWidth(columns.map((column) => column.width), ROOT_GAP);
-	return { render: () => /* @__PURE__ */ jsx(Box, {
+const ProgressRenderer = ({ rows, columns }) => {
+	if (rows.length === 0) return null;
+	return /* @__PURE__ */ jsx(Box, {
 		flexDirection: "row",
-		minWidth: rowWidth,
-		children: columns.map((column, index) => /* @__PURE__ */ jsx(Box, {
-			flexDirection: "column",
-			width: column.width,
-			marginRight: index < columns.length - 1 ? ROOT_GAP : 0,
-			children: taskIds.map((taskId) => /* @__PURE__ */ jsx(Box, {
-				width: column.width,
-				height: 1,
-				children: column.render(taskId, column.width)
-			}, taskId))
-		}, column.id))
-	}) };
+		columnGap: 1,
+		overflow: "hidden",
+		children: resolveColumns(rows, columns).map((position) => /* @__PURE__ */ jsx(ColumnPosition, { position }, position.index))
+	});
 };
 
 //#endregion
-//#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);
+//#region src/renderer/store/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 treeAncestorPrefix = (ancestorHasNextSibling) => ancestorHasNextSibling.slice(1).map((hasNextSibling) => hasNextSibling ? "│  " : "   ").join("");
+const renderTreePrefix = (tree) => {
+	if (tree.depth <= 0) return "";
+	return `${treeAncestorPrefix(tree.ancestorHasNextSibling)}${tree.hasNextSibling ? "├─ " : "└─ "}`;
+};
+const arraysEqual = (left, right) => {
+	if (left.length !== right.length) return false;
+	for (let i = 0; i < left.length; i++) if (left[i] !== right[i]) return false;
+	return true;
+};
+const sameTreePrefixInputs = (left, right) => left.depth === right.depth && left.hasNextSibling === right.hasNextSibling && arraysEqual(left.ancestorHasNextSibling, right.ancestorHasNextSibling);
+const sameTree = (left, right) => sameTreePrefixInputs(left, right) && left.hasChildren === right.hasChildren;
+const deriveRow = (task, tree, previousRow) => {
+	if (previousRow !== void 0 && previousRow.task === task && sameTree(previousRow.tree, tree)) return previousRow.derived;
+	const treePrefix = previousRow !== void 0 && sameTreePrefixInputs(previousRow.tree, tree) ? previousRow.derived.treePrefix : renderTreePrefix(tree);
+	const treePrefixWidth = previousRow !== void 0 && sameTreePrefixInputs(previousRow.tree, tree) ? previousRow.derived.treePrefixWidth : treePrefix.length;
+	const descriptionWidth = previousRow !== void 0 && previousRow.task.description === task.description ? previousRow.derived.descriptionWidth : textWidth(task.description);
+	const isDeterminate = previousRow !== void 0 && previousRow.task.units.total === task.units.total ? previousRow.derived.isDeterminate : task.units.total !== void 0;
+	const hasRenderableProgress = previousRow !== void 0 && previousRow.task.units.total === task.units.total && previousRow.task.units.processed === task.units.processed ? previousRow.derived.hasRenderableProgress : task.units.total !== void 0 || task.units.processed > 0;
+	return {
+		treePrefix,
+		treePrefixWidth,
+		descriptionWidth,
+		treePrefixedDescriptionWidth: treePrefixWidth + descriptionWidth,
+		hasRenderableProgress,
+		isDeterminate
+	};
+};
+const computeTreeInfo = (ordered, previousRows) => {
+	const hasNextSiblingByIndex = Array.from({ length: ordered.length }, () => false);
+	const seenByDepth = [];
+	for (let i = ordered.length - 1; i >= 0; i--) {
+		const depth = ordered[i].depth;
+		hasNextSiblingByIndex[i] = seenByDepth[depth] ?? false;
+		seenByDepth[depth] = true;
+		seenByDepth.length = depth + 1;
+	}
+	const ancestorStateByDepth = [];
+	const previousRowsByTaskId = new Map(previousRows.map((row) => [row.task.id, row]));
+	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]
 		};
-	}, [active, intervalMillis]);
-	return now;
+		const previousRow = previousRowsByTaskId.get(entry.snapshot.id);
+		ancestorStateByDepth[depth] = hasNextSiblingByIndex[index] ?? false;
+		if (previousRow !== void 0 && previousRow.task === entry.snapshot && sameTree(previousRow.tree, tree)) return previousRow;
+		const derived = deriveRow(entry.snapshot, tree, previousRow);
+		return {
+			task: entry.snapshot,
+			tree: previousRow !== void 0 && sameTree(previousRow.tree, tree) ? previousRow.tree : tree,
+			derived
+		};
+	});
+};
+const toRenderSnapshot = (store, previousSnapshot) => {
+	const visibleTasks = orderedVisibleTasks(store);
+	const hasRunningTasks = visibleTasks.some((entry) => entry.snapshot.status === "running");
+	return {
+		rows: computeTreeInfo(visibleTasks, previousSnapshot?.rows ?? []),
+		hasRunningTasks
+	};
 };
 
 //#endregion
-//#region src/ink-renderer/view/hooks/use-spinner-clock.ts
-const useSpinnerClock = (active, intervalMillis) => {
-	const [tick, setTick] = useState(0);
+//#region src/renderer/store/use-progress-render-view.ts
+const useRenderSnapshot = (storeSnapshot) => {
+	const previousSnapshotRef = useRef(void 0);
+	const renderSnapshot = useMemo(() => toRenderSnapshot(storeSnapshot, previousSnapshotRef.current), [storeSnapshot]);
 	useEffect(() => {
-		if (!active) return;
-		const interval = setInterval(() => {
-			setTick((current) => current + 1);
-		}, intervalMillis);
-		return () => {
-			clearInterval(interval);
-		};
-	}, [active, intervalMillis]);
-	return tick;
+		previousSnapshotRef.current = renderSnapshot;
+	}, [renderSnapshot]);
+	return renderSnapshot;
+};
+const useProgressRenderView = (store) => {
+	const publication = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+	const renderSnapshot = useRenderSnapshot(publication.snapshot);
+	return {
+		publication,
+		renderSnapshot,
+		hasRunningTasks: renderSnapshot.rows.some((row) => row.task.status === "running")
+	};
 };
 
 //#endregion
-//#region src/ink-renderer/view/render-root.tsx
-const SPINNER_INTERVAL_MILLIS = 100;
-const NOW_INTERVAL_MILLIS = 1e3;
-const ProgressRoot = ({ store, 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);
-	const stickyWidths = useRef(/* @__PURE__ */ new Map());
-	return RootColumn(snapshot.rows, now, tick, getTerminalColumns(), stickyWidths.current).render();
+//#region src/renderer/renderer-service.tsx
+const MAX_FPS = 24;
+const ProgressRoot = ({ store }) => {
+	const { renderSnapshot, hasRunningTasks, publication } = useProgressRenderView(store);
+	return /* @__PURE__ */ jsx(SpinnerProvider, {
+		active: hasRunningTasks,
+		children: /* @__PURE__ */ jsx(NowProvider, {
+			active: hasRunningTasks,
+			children: /* @__PURE__ */ jsx(ProgressRenderer, {
+				rows: renderSnapshot.rows,
+				columns: publication.snapshot.columns
+			})
+		})
+	});
+};
+const makeRendererv2InkRendererService = () => {
+	return { run: (store, stdio) => {
+		const proot = /* @__PURE__ */ jsx(ProgressRoot, { store });
+		return Effect.sync(() => render(proot, {
+			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();
+			instance.rerender(proot);
+			yield* Effect.sync(() => {
+				instance.unmount();
+			});
+		})))));
+	} };
 };
 
 //#endregion
 //#region src/services/ink-renderer.tsx
-const MAX_FPS = 12;
-const makeDefaultInkRenderer = () => ({ run: (store, stdio, isTTY) => Effect.sync(() => render(/* @__PURE__ */ jsx(ProgressRoot, {
-	store,
-	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()));
+	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeRendererv2InkRendererService()));
 };
 
 //#endregion
@@ -1370,16 +1221,16 @@ var ProgressStdio = class ProgressStdio extends Context.Tag("stromseng.dev/effec
 
 //#endregion
 //#region src/services/progress.ts
+/** Builds the scoped implementation used by `ProgressService.task(...)` without auto-providing services. */
 const makeProgressService = Effect.gen(function* () {
 	const stdio = yield* ProgressStdio;
 	const inkRenderer = yield* InkRenderer;
 	const outerConsole = yield* Effect.console;
-	const isTTY = Boolean(stdio.stderr.isTTY);
 	const store = makeProgressRenderStore();
 	const currentParentRef = yield* FiberRef.make(Option.none());
 	const scope = yield* Effect.scope;
 	const log = (...args) => args.length === 0 ? Effect.void : outerConsole.log(...args);
-	yield* Effect.forkIn(inkRenderer.run(store, stdio, isTTY), scope);
+	yield* Effect.forkIn(inkRenderer.run(store, stdio), 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);
@@ -1395,7 +1246,27 @@ const makeProgressService = Effect.gen(function* () {
 	const failTask = store.failTask;
 	const getTask = store.getTask;
 	const listTasks = store.listTasks;
-	const runTask = dual(2, (effect, options) => Effect.gen(function* () {
+	const setMetadata = store.setMetadata;
+	const getMetadata = store.getMetadata;
+	const makeTaskHandle = (taskId) => ({
+		id: taskId,
+		getMetadata: getMetadata(taskId),
+		setMetadata: (metadata) => setMetadata(taskId, metadata),
+		updateMetadata: (f) => Effect.flatMap(getMetadata(taskId), (current) => setMetadata(taskId, f(current))),
+		incrementSucceeded: (amount) => incrementSucceeded(taskId, amount),
+		incrementFailed: (amount) => incrementFailed(taskId, amount),
+		update: (options) => updateTask(taskId, options),
+		complete: completeTask(taskId),
+		fail: failTask(taskId),
+		getSnapshot: getTask(taskId).pipe(Effect.map(Option.getOrThrow))
+	});
+	const autoFinalizeIfRunning = (taskId, exit) => Effect.gen(function* () {
+		const task = yield* getTask(taskId);
+		if (Option.isNone(task) || task.value.status !== "running") return;
+		if (Exit.isSuccess(exit)) yield* completeTask(taskId);
+		else yield* failTask(taskId);
+	});
+	const scopedTask = dual(2, (effect, options) => Effect.gen(function* () {
 		const inheritedParentId = yield* FiberRef.get(currentParentRef);
 		const resolvedParentId = options.parentId === void 0 ? inheritedParentId : Option.some(options.parentId);
 		const taskId = yield* addTask({
@@ -1415,17 +1286,29 @@ const makeProgressService = Effect.gen(function* () {
 		log,
 		getTask,
 		listTasks,
-		runTask,
-		withTask: dual(2, (effect, options) => runTask(Effect.gen(function* () {
-			const taskId = yield* Task;
-			const exit = yield* Effect.exit(effect);
-			if (Exit.isSuccess(exit)) yield* completeTask(taskId);
-			else yield* failTask(taskId);
-			return yield* Exit.match(exit, {
-				onFailure: Effect.failCause,
-				onSuccess: Effect.succeed
-			});
-		}), options))
+		setMetadata,
+		getMetadata,
+		task: dual(2, (effectOrCallback, options) => {
+			if (typeof effectOrCallback === "function") return scopedTask(Effect.gen(function* () {
+				const taskId = yield* Task;
+				const handle = makeTaskHandle(taskId);
+				const exit = yield* Effect.exit(effectOrCallback(handle));
+				yield* autoFinalizeIfRunning(taskId, exit);
+				return yield* Exit.match(exit, {
+					onFailure: Effect.failCause,
+					onSuccess: Effect.succeed
+				});
+			}), options);
+			return scopedTask(Effect.gen(function* () {
+				const taskId = yield* Task;
+				const exit = yield* Effect.exit(effectOrCallback);
+				yield* autoFinalizeIfRunning(taskId, exit);
+				return yield* Exit.match(exit, {
+					onFailure: Effect.failCause,
+					onSuccess: Effect.succeed
+				});
+			}), options);
+		})
 	};
 	return Progress.of(service);
 });
@@ -1457,9 +1340,17 @@ const provideProgress = (effect) => Effect.gen(function* () {
 	if (Option.isSome(existing)) return yield* Effect.provideService(effect, Progress, existing.value);
 	return yield* Effect.scoped(effect.pipe(Effect.provide(Progress.Default)));
 });
-const task = dual(2, (effect, options) => {
+/**
+* Runs an effect inside a task, creating and providing a `Progress` service automatically when one
+* is not already present in the environment.
+*
+* The effect form tracks success and failure from the effect exit. The callback form exposes a
+* typed `TaskHandle` for task-local updates, typed metadata, and explicit completion or failure,
+* and otherwise auto-finalizes from the callback exit if the task is still `running`.
+*/
+const task = dual(2, (effectOrCallback, options) => {
 	return provideProgress(Effect.gen(function* () {
-		return yield* (yield* Progress).withTask(effect, options);
+		return yield* (yield* Progress).task(effectOrCallback, options);
 	}));
 });
 const wrapEffects = (effects, tap) => Array.isArray(effects) ? effects.map(tap) : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
@@ -1482,10 +1373,14 @@ const isTaskFullyProcessed = (progress, taskId) => Effect.gen(function* () {
 	const { processed, total } = taskOption.value.units;
 	return total !== void 0 && processed >= total;
 });
+/**
+* Runs multiple effects under a single parent task and keeps the task counters in sync with the
+* child effect outcomes.
+*/
 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;
+	return yield* progress.task((handle) => Effect.gen(function* () {
+		const taskId = handle.id;
 		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => wrapTrackedEffect(progress, taskId, effect)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
@@ -1508,10 +1403,13 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 		countDisplay: allCountDisplay(options.mode)
 	});
 })));
+/**
+* Runs `Effect.forEach` under a single parent task and advances the task counters as items finish.
+*/
 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;
+	return yield* progress.task((handle) => Effect.gen(function* () {
+		const taskId = handle.id;
 		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => wrapTrackedEffect(progress, taskId, f(item, index)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
@@ -1533,4 +1431,4 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 })));
 
 //#endregion
-export { Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };
+export { columns_exports as Columns, Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskSnapshotSchema, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };