effective-progress 0.10.0 → 0.11.1

package/dist/index.mjs

@@ -1,11 +1,11 @@
+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 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 { createContext, memo, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { VirtualList } from "ink-virtual-list";
+import stringWidth from "fast-string-width";
 
 //#region src/types.ts
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
@@ -18,6 +18,10 @@ const TaskUnitsSchema = Schema.Struct({
 	processed: Schema.Number,
 	total: Schema.optional(Schema.Number)
 });
+const TaskProgressSampleSchema = Schema.Struct({
+	timestamp: Schema.Number,
+	processed: Schema.Number
+});
 const TaskSnapshotSchema = Schema.Struct({
 	id: TaskIdSchema,
 	parentId: Schema.NullOr(TaskIdSchema),
@@ -27,7 +31,9 @@ const TaskSnapshotSchema = Schema.Struct({
 	transient: Schema.Boolean,
 	units: TaskUnitsSchema,
 	startedAt: Schema.Number,
-	completedAt: Schema.NullOr(Schema.Number)
+	completedAt: Schema.NullOr(Schema.Number),
+	progressSamples: Schema.Array(TaskProgressSampleSchema),
+	metadata: Schema.Unknown
 });
 const TaskSnapshot = (snapshot) => snapshot;
 var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
@@ -62,6 +68,8 @@ const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema
 
 //#endregion
 //#region src/renderer/store.ts
+const ETA_SAMPLE_WINDOW_MILLIS = 3e4;
+const ETA_SAMPLE_MAX_LENGTH = 1e3;
 const hasExplicitTotal = (options) => Object.prototype.hasOwnProperty.call(options, "total");
 const sanitizeTotalOnAdd = (total) => {
 	if (total === void 0) return;
@@ -85,7 +93,25 @@ const normalizeUnits = (counts) => {
 		total: counts.total
 	};
 };
-const updatedSnapshot = (snapshot, options) => {
+/**
+* Returns a new progress sample deque with the latest processed count appended.
+*
+* Samples are retained for the ETA rolling window and capped by count so very chatty tasks do not
+* grow memory without bound.
+*/
+const appendProgressSample = (samples, now, processed) => {
+	const previousSamples = samples ?? [];
+	if (previousSamples.at(-1)?.processed === processed) return previousSamples;
+	const windowStart = now - ETA_SAMPLE_WINDOW_MILLIS;
+	const nextSamples = [...previousSamples, {
+		timestamp: now,
+		processed
+	}];
+	while (nextSamples.length > 2 && (nextSamples.length > ETA_SAMPLE_MAX_LENGTH || nextSamples[1].timestamp < windowStart)) nextSamples.shift();
+	return nextSamples;
+};
+/** Applies mutable task fields and records a progress sample when the processed count changes. */
+const updatedSnapshot = (snapshot, options, now) => {
 	const currentUnits = snapshot.units;
 	const units = options.succeeded === void 0 && options.failed === void 0 && options.total === void 0 && !hasExplicitTotal(options) ? currentUnits : normalizeUnits({
 		succeeded: options.succeeded ?? currentUnits.succeeded,
@@ -93,28 +119,14 @@ const updatedSnapshot = (snapshot, options) => {
 		total: hasExplicitTotal(options) ? sanitizeTotalOnUpdate(options.total) : currentUnits.total
 	});
 	return TaskSnapshot({
-		id: snapshot.id,
-		parentId: snapshot.parentId,
+		...snapshot,
 		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
+		progressSamples: appendProgressSample(snapshot.progressSamples, now, units.processed)
 	});
 };
-const withTransient = (snapshot, transient) => 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,
@@ -156,7 +168,8 @@ const makeProgressRenderStore = () => {
 	let nextTaskId = 0;
 	let state = {
 		tasks: /* @__PURE__ */ new Map(),
-		renderOrder: []
+		renderOrder: [],
+		columns: /* @__PURE__ */ new Map()
 	};
 	let pendingEvents = [];
 	let publishedPublication = {
@@ -245,7 +258,12 @@ const makeProgressRenderStore = () => {
 				transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
 				units,
 				startedAt: now,
-				completedAt: null
+				completedAt: null,
+				progressSamples: [{
+					timestamp: now,
+					processed: units.processed
+				}],
+				metadata: options.metadata
 			});
 			updateState((current) => {
 				const nextTasks = new Map(current.tasks);
@@ -259,7 +277,8 @@ const makeProgressRenderStore = () => {
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: nextRenderOrder
+						renderOrder: nextRenderOrder,
+						columns: options.columns ? new Map(current.columns).set(taskId, options.columns) : current.columns
 					},
 					events: [new TaskAddedEvent({
 						taskId,
@@ -273,14 +292,15 @@ const makeProgressRenderStore = () => {
 			});
 			return taskId;
 		}),
-		updateTask: (taskId, options) => Effect.sync(() => {
+		updateTask: (taskId, options) => Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
 				if (!currentTask) return {
 					state: current,
 					events: []
 				};
-				const nextTask = updatedSnapshot(currentTask, options);
+				const nextTask = updatedSnapshot(currentTask, options, now);
 				const nextTasks = new Map(current.tasks);
 				nextTasks.set(taskId, nextTask);
 				const events = [new TaskUpdatedEvent({
@@ -296,7 +316,10 @@ const makeProgressRenderStore = () => {
 				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);
+					const nextCandidate = TaskSnapshot({
+						...candidate,
+						transient: nextTask.transient
+					});
 					nextTasks.set(candidateId, nextCandidate);
 					events.push(new TaskUpdatedEvent({
 						taskId: candidateId,
@@ -306,39 +329,37 @@ const makeProgressRenderStore = () => {
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: current.renderOrder
+						renderOrder: current.renderOrder,
+						columns: current.columns
 					},
 					events
 				};
 			});
 		}),
-		incrementSucceeded: (taskId, amount = 1) => Effect.sync(() => {
+		incrementSucceeded: (taskId, amount = 1) => Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
 				if (!currentTask) return {
 					state: current,
 					events: []
 				};
+				const units = normalizeUnits({
+					succeeded: currentTask.units.succeeded + amount,
+					failed: currentTask.units.failed,
+					total: currentTask.units.total
+				});
 				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: normalizeUnits({
-						succeeded: currentTask.units.succeeded + amount,
-						failed: currentTask.units.failed,
-						total: currentTask.units.total
-					}),
-					startedAt: currentTask.startedAt,
-					completedAt: currentTask.completedAt
+					...currentTask,
+					units,
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: current.renderOrder
+						renderOrder: current.renderOrder,
+						columns: current.columns
 					},
 					events: [new TaskAdvancedEvent({
 						taskId,
@@ -348,33 +369,30 @@ const makeProgressRenderStore = () => {
 				};
 			});
 		}),
-		incrementFailed: (taskId, amount = 1) => Effect.sync(() => {
+		incrementFailed: (taskId, amount = 1) => Effect.gen(function* () {
+			const now = yield* Clock.currentTimeMillis;
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
 				if (!currentTask) return {
 					state: current,
 					events: []
 				};
+				const units = normalizeUnits({
+					succeeded: currentTask.units.succeeded,
+					failed: currentTask.units.failed + amount,
+					total: currentTask.units.total
+				});
 				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: normalizeUnits({
-						succeeded: currentTask.units.succeeded,
-						failed: currentTask.units.failed + amount,
-						total: currentTask.units.total
-					}),
-					startedAt: currentTask.startedAt,
-					completedAt: currentTask.completedAt
+					...currentTask,
+					units,
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: current.renderOrder
+						renderOrder: current.renderOrder,
+						columns: current.columns
 					},
 					events: [new TaskAdvancedEvent({
 						taskId,
@@ -392,41 +410,46 @@ const makeProgressRenderStore = () => {
 					state: current,
 					events: []
 				};
+				if (currentTask.status !== "running") return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
 				if (currentTask.transient) {
 					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 {
 						state: {
 							tasks: nextTasks,
-							renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
+							columns: nextColumns
 						},
 						events: [new TaskCompletedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
 					};
 				}
+				const units = currentTask.units.total !== void 0 ? currentTask.units.processed < currentTask.units.total ? normalizeUnits({
+					succeeded: currentTask.units.succeeded + (currentTask.units.total - currentTask.units.processed),
+					failed: currentTask.units.failed,
+					total: currentTask.units.total
+				}) : currentTask.units : currentTask.units.processed > 0 ? normalizeUnits({
+					succeeded: currentTask.units.succeeded,
+					failed: currentTask.units.failed,
+					total: currentTask.units.processed
+				}) : currentTask.units;
 				nextTasks.set(taskId, TaskSnapshot({
-					id: currentTask.id,
-					parentId: currentTask.parentId,
-					description: currentTask.description,
+					...currentTask,
 					status: "done",
-					countDisplay: currentTask.countDisplay,
-					transient: currentTask.transient,
-					units: currentTask.units.total !== void 0 ? currentTask.units.processed < currentTask.units.total ? normalizeUnits({
-						succeeded: currentTask.units.succeeded + (currentTask.units.total - currentTask.units.processed),
-						failed: currentTask.units.failed,
-						total: currentTask.units.total
-					}) : currentTask.units : currentTask.units.processed > 0 ? normalizeUnits({
-						succeeded: currentTask.units.succeeded,
-						failed: currentTask.units.failed,
-						total: currentTask.units.processed
-					}) : currentTask.units,
-					startedAt: currentTask.startedAt,
-					completedAt: now
+					units,
+					completedAt: now,
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: current.renderOrder
+						renderOrder: current.renderOrder,
+						columns: current.columns
 					},
 					events: [new TaskCompletedEvent({ taskId })]
 				};
@@ -440,43 +463,146 @@ const makeProgressRenderStore = () => {
 					state: current,
 					events: []
 				};
+				if (currentTask.status !== "running") return {
+					state: current,
+					events: []
+				};
 				const nextTasks = new Map(current.tasks);
 				if (currentTask.transient) {
 					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 {
 						state: {
 							tasks: nextTasks,
-							renderOrder: removeFromRenderOrder(current.renderOrder, taskId)
+							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
+							columns: nextColumns
 						},
 						events: [new TaskFailedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
 					};
 				}
 				nextTasks.set(taskId, TaskSnapshot({
-					id: currentTask.id,
-					parentId: currentTask.parentId,
-					description: currentTask.description,
+					...currentTask,
 					status: "failed",
-					countDisplay: currentTask.countDisplay,
-					transient: currentTask.transient,
-					units: currentTask.units,
-					startedAt: currentTask.startedAt,
 					completedAt: now
 				}));
 				return {
 					state: {
 						tasks: nextTasks,
-						renderOrder: current.renderOrder
+						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({
+					...currentTask,
+					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/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/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;
@@ -497,17 +623,58 @@ const formatDurationSeconds = (seconds) => {
 	const mins = Math.floor(value % 3600 / 60);
 	return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
 };
+const formatClockDurationSeconds = (seconds) => {
+	const value = Math.max(0, Math.floor(seconds));
+	const hours = Math.floor(value / 3600);
+	const mins = Math.floor(value % 3600 / 60);
+	const secs = value % 60;
+	const clock = `${`${mins}`.padStart(2, "0")}:${`${secs}`.padStart(2, "0")}`;
+	return hours > 0 ? `${`${hours}`.padStart(2, "0")}:${clock}` : clock;
+};
+/**
+* Estimates remaining time from the task's retained progress sample deque.
+*
+* Returns undefined until there are at least two samples with positive processed and time deltas.
+*/
+const getSmoothedEtaMillis = (task) => {
+	const { processed, total } = task.units;
+	const remaining = total - processed;
+	if (processed <= 0 || remaining <= 0) return;
+	const samples = task.progressSamples;
+	const lastSample = samples.at(-1);
+	if (lastSample === void 0) return;
+	const firstSample = samples[0];
+	if (firstSample === void 0 || firstSample === lastSample) return;
+	const deltaProcessed = lastSample.processed - firstSample.processed;
+	const deltaMillis = lastSample.timestamp - firstSample.timestamp;
+	if (deltaProcessed <= 0 || deltaMillis <= 0) return;
+	return Math.max(0, Math.floor(remaining * deltaMillis / deltaProcessed));
+};
 const formatElapsed = (task, now) => {
 	return formatDurationSeconds(Math.max(0, (task.completedAt ?? now) - task.startedAt) / 1e3);
 };
+const formatElapsedClock = (task, now) => {
+	return formatClockDurationSeconds(Math.max(0, (task.completedAt ?? now) - task.startedAt) / 1e3);
+};
 const formatEta = (task, now) => {
 	if (task.status !== "running" || !isDeterminate$1(task)) 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 / processed * remaining)) / 1e3);
+	const etaMillis = getSmoothedEtaMillis(task);
+	if (etaMillis === void 0) return "";
+	return formatClockDurationSeconds(etaMillis / 1e3);
+};
+const formatEtaClock = (task, now) => {
+	if (task.status !== "running" || !isDeterminate$1(task)) return;
+	const { processed, total } = task.units;
+	const remaining = total - processed;
+	if (processed <= 0 || remaining <= 0) return;
+	const etaMillis = getSmoothedEtaMillis(task);
+	if (etaMillis === void 0) return;
+	return formatClockDurationSeconds(etaMillis / 1e3);
 };
+const formatElapsedEta = (task, now) => `${formatElapsedClock(task, now)}<${formatEtaClock(task, now) ?? "00:00"}`;
 const formatDeterminateAmountParts = (task) => {
 	if (!isDeterminate$1(task)) return;
 	const totalText = `${task.units.total}`;
@@ -606,38 +773,17 @@ const renderAmount = (task, layout) => {
 		/* @__PURE__ */ jsx(Text, { children: ` ${processed}/${total}` })
 	] });
 };
-const defaultAmountColumnConfig = {
-	minWidth: 4,
-	sticky: true
-};
-const createAmountColumn = (config) => {
-	const resolvedConfig = {
-		...defaultAmountColumnConfig,
-		...config
-	};
-	let amountLayout = emptyAmountLayout;
-	return {
-		Component: ({ row }) => /* @__PURE__ */ jsx(Text, {
-			wrap: "truncate-end",
-			children: renderAmount(row.task, amountLayout)
-		}),
-		measure: ({ rows }) => {
-			amountLayout = measureAmountLayout(rows);
-			return {
-				minWidth: amountLayout.preferredWidth > 0 ? Math.min(resolvedConfig.minWidth, amountLayout.preferredWidth) : 0,
-				preferredWidth: amountLayout.preferredWidth,
-				maxWidth: amountLayout.preferredWidth
-			};
-		},
-		noWrap: false,
-		sticky: resolvedConfig.sticky
-	};
-};
+const AmountCell = ({ task, layout }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
+	children: renderAmount(task, layout)
+});
 
 //#endregion
 //#region src/renderer/columns/bar-column.tsx
-const DEFAULT_BAR_WIDTH = 30;
 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);
@@ -664,94 +810,21 @@ const renderProgressBar = (task, width) => {
 		]
 	});
 };
-const defaultBarColumnConfig = {
-	minWidth: 4,
-	barWidth: DEFAULT_BAR_WIDTH,
-	sticky: true
-};
-const createBarColumn = (config) => {
-	const resolvedConfig = {
-		...defaultBarColumnConfig,
-		...config
-	};
-	return {
-		Component: ({ row, width }) => /* @__PURE__ */ jsx(Text, {
-			wrap: "truncate-end",
-			children: renderProgressBar(row.task, width)
-		}),
-		measure: ({ rows }) => {
-			const hasDeterminateRows = rows.some((row) => row.derived.isDeterminate);
-			const preferredWidth = hasDeterminateRows ? resolvedConfig.barWidth : 0;
-			return {
-				minWidth: hasDeterminateRows ? Math.min(resolvedConfig.minWidth, preferredWidth) : 0,
-				preferredWidth,
-				maxWidth: preferredWidth
-			};
-		},
-		noWrap: false,
-		sticky: resolvedConfig.sticky
-	};
-};
-
-//#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);
+const BarCell = ({ task, width }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
+	children: renderProgressBar(task, width ?? 0)
+});
 
 //#endregion
 //#region src/renderer/columns/description-column.tsx
 const MIN_TREE_DESCRIPTION_TEXT_WIDTH = 6;
-const defaultDescriptionColumnConfig = {
-	minWidth: 1,
-	spinnerType: "dots",
-	sticky: true
-};
+const DEFAULT_SPINNER_TYPE = "dots";
 const isDeterminate = (task) => task.units.total !== void 0;
 const getSpinnerFrame = (tick, spinnerType) => {
 	const frames = cliSpinners[spinnerType].frames;
 	return frames[(tick % frames.length + frames.length) % frames.length] ?? frames[0] ?? "";
 };
-const getTaskIndicator = (task, tick, spinnerType = defaultDescriptionColumnConfig.spinnerType) => {
+const getTaskIndicator = (task, tick, spinnerType = DEFAULT_SPINNER_TYPE) => {
 	if (task.status === "running") return {
 		symbol: getSpinnerFrame(tick, spinnerType),
 		color: "yellow"
@@ -782,412 +855,279 @@ const getTaskIndicator = (task, tick, spinnerType = defaultDescriptionColumnConf
 		color: "green"
 	};
 };
-const TaskIndicatorGlyph = ({ task, spinnerType = defaultDescriptionColumnConfig.spinnerType }) => {
-	const indicator = getTaskIndicator(task, useSpinnerTick(), spinnerType);
+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),
+	preferredWidth: rows.reduce((max, row) => Math.max(max, row.derived.treePrefixWidth + 2 + row.derived.descriptionWidth), 2)
+});
+const TaskIndicatorGlyph = ({ task, tick, spinnerType = DEFAULT_SPINNER_TYPE }) => {
+	const indicator = getTaskIndicator(task, tick, spinnerType);
 	return /* @__PURE__ */ jsx(Text, {
 		color: indicator.color,
 		children: indicator.symbol
 	});
 };
-const createDescriptionColumn = (config) => {
-	const resolvedConfig = {
-		...defaultDescriptionColumnConfig,
-		...config,
-		spinnerType: config?.spinnerType ?? defaultDescriptionColumnConfig.spinnerType
-	};
-	let minTreeWidth = MIN_TREE_DESCRIPTION_TEXT_WIDTH + 2;
-	const Component = ({ row, width }) => {
-		const showTree = width >= minTreeWidth;
-		const treePrefix = showTree ? row.derived.treePrefix : "";
-		if (!showTree && width <= 1) return /* @__PURE__ */ jsx(TaskIndicatorGlyph, {
-			task: row.task,
-			spinnerType: resolvedConfig.spinnerType
-		});
-		if (!showTree && width === 2) return /* @__PURE__ */ jsxs(Text, {
-			wrap: "truncate-end",
-			children: [/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
-				task: row.task,
-				spinnerType: resolvedConfig.spinnerType
-			}), "…"]
-		});
-		return /* @__PURE__ */ jsxs(Text, {
-			wrap: "truncate-end",
-			children: [
-				treePrefix,
-				/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
-					task: row.task,
-					spinnerType: resolvedConfig.spinnerType
-				}),
-				` ${row.task.description}`
-			]
-		});
-	};
-	return {
-		Component,
-		measure: ({ rows }) => {
-			const hasNestedRows = rows.some((row) => row.tree.depth > 0);
-			minTreeWidth = rows.reduce((max, row) => Math.max(max, row.derived.treePrefixWidth + 2 + MIN_TREE_DESCRIPTION_TEXT_WIDTH), MIN_TREE_DESCRIPTION_TEXT_WIDTH + 2);
-			return {
-				minWidth: resolvedConfig.minWidth,
-				preferredWidth: Math.max(rows.reduce((max, row) => Math.max(max, row.derived.treePrefixedDescriptionWidth + 2), resolvedConfig.minWidth), hasNestedRows ? minTreeWidth : resolvedConfig.minWidth),
-				maxWidth: void 0
-			};
-		},
-		noWrap: false,
-		sticky: resolvedConfig.sticky,
-		stickyMaxWidth: resolvedConfig.stickyMaxWidth
-	};
-};
-
-//#endregion
-//#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;
+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
+	});
+	if (!showTree && width !== void 0 && width === 2) return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
+			task: cell.task,
+			tick: spinnerTick
+		}), "…"]
+	});
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			treePrefix,
+			/* @__PURE__ */ jsx(TaskIndicatorGlyph, {
+				task: cell.task,
+				tick: spinnerTick
+			}),
+			` ${cell.task.description}`
+		]
+	});
 };
 
 //#endregion
-//#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
+//#region src/renderer/columns/elapsed-eta-column.tsx
+const ElapsedEtaCell = ({ task, now }) => {
+	return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		color: "gray",
+		children: formatElapsedEta(task, now)
 	});
 };
-const useNow = () => useContext(NowContext);
 
 //#endregion
 //#region src/renderer/columns/elapsed-column.tsx
-const defaultElapsedColumnConfig = {
-	minWidth: 2,
-	justify: "right",
-	sticky: true
-};
-const ElapsedText = ({ task, width }) => {
+const ElapsedCell = ({ task, now }) => {
 	return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
 		color: "gray",
-		children: formatElapsed(task, useNow()).slice(0, Math.max(0, width))
+		children: formatElapsed(task, now)
 	});
 };
-const createElapsedColumn = (config) => {
-	const resolvedConfig = {
-		...defaultElapsedColumnConfig,
-		...config
-	};
-	const Component = ({ row, width }) => /* @__PURE__ */ jsx(ElapsedText, {
-		task: row.task,
-		width
-	});
-	return {
-		Component,
-		measure: ({ rows, now }) => {
-			const width = rows.reduce((max, row) => Math.max(max, formatElapsed(row.task, now).length), resolvedConfig.minWidth);
-			return {
-				minWidth: resolvedConfig.minWidth,
-				preferredWidth: width,
-				maxWidth: width
-			};
-		},
-		getLayoutDependency: ({ rows, now }) => rows.reduce((max, row) => Math.max(max, formatElapsed(row.task, now).length), 0),
-		justify: resolvedConfig.justify,
-		noWrap: true,
-		sticky: resolvedConfig.sticky
-	};
-};
 
 //#endregion
 //#region src/renderer/columns/eta-column.tsx
-const primaryUnit = (duration) => duration.split(" ")[0] ?? duration;
-const cropTextToWidth = (text, width) => {
-	if (width <= 0) return "";
-	return text.slice(0, width);
+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}`
+	});
 };
-const etaDurationText = (row, now) => {
-	const eta = formatEta(row.task, now);
-	return eta === "" ? void 0 : eta;
+
+//#endregion
+//#region src/columns.tsx
+var columns_exports = /* @__PURE__ */ __exportAll({
+	amount: () => amount,
+	bar: () => bar,
+	defaults: () => defaults,
+	description: () => description,
+	elapsed: () => elapsed,
+	elapsedEta: () => elapsedEta,
+	eta: () => eta,
+	resolveColumnSizeValue: () => resolveColumnSizeValue,
+	spacer: () => spacer
+});
+const DEFAULT_BAR_SIZE = 30;
+const resolveBarSize = (size) => {
+	if (size === "fullwidth") return size;
+	if (typeof size !== "number" || !Number.isFinite(size)) return DEFAULT_BAR_SIZE;
+	return Math.max(1, Math.floor(size));
 };
-const renderEtaText = (row, now, width) => {
-	const duration = etaDurationText(row, now);
-	if (duration === void 0) return {
-		mode: "compact",
-		text: ""
-	};
-	const prefixed = `ETA: ${duration}`;
-	if (width >= prefixed.length) return {
-		mode: "prefixed",
-		text: prefixed
-	};
-	if (width >= duration.length) return {
-		mode: "duration",
-		text: duration
-	};
+const spacer = ({ flexGrow, flexShrink, flexBasis, minWidth } = {}) => ({
+	render: () => null,
+	flexGrow,
+	flexShrink,
+	flexBasis,
+	minWidth
+});
+const description = () => ({
+	prepare: prepareDescription,
+	flexShrink: 1,
+	flexBasis: (prepared) => prepared.preferredWidth,
+	minWidth: 1,
+	render: (cell, ctx) => /* @__PURE__ */ jsx(DescriptionCell, {
+		cell,
+		width: ctx.width,
+		minTreeWidth: ctx.prepared.minTreeWidth,
+		spinnerTick: ctx.spinnerTick
+	})
+});
+const bar = ({ size } = {}) => {
+	const resolvedSize = resolveBarSize(size);
 	return {
-		mode: "compact",
-		text: cropTextToWidth(primaryUnit(duration), width)
-	};
-};
-const defaultEtaColumnConfig = {
-	minWidth: 3,
-	justify: "right",
-	sticky: true
-};
-const EtaText = ({ row, width, justify }) => {
-	const rendered = renderEtaText(row, useNow(), width);
-	return /* @__PURE__ */ jsx(Box, {
-		width,
-		justifyContent: rendered.mode === "prefixed" ? justify === "right" ? "flex-end" : "flex-start" : "flex-start",
-		children: /* @__PURE__ */ jsx(Text, {
-			wrap: "truncate-end",
-			color: "gray",
-			children: rendered.text
+		prepare: prepareBar,
+		flexGrow: (prepared) => prepared.hasDeterminateRows && resolvedSize === "fullwidth" ? 1 : 0,
+		flexShrink: (prepared) => prepared.hasDeterminateRows ? 1 : 0,
+		flexBasis: (prepared) => prepared.hasDeterminateRows ? resolvedSize === "fullwidth" ? DEFAULT_BAR_SIZE : resolvedSize : 0,
+		minWidth: (prepared) => prepared.hasDeterminateRows ? resolvedSize === "fullwidth" ? 4 : resolvedSize : 0,
+		render: ({ task }, ctx) => /* @__PURE__ */ jsx(BarCell, {
+			task,
+			width: ctx.width
 		})
-	});
-};
-const createEtaColumn = (config) => {
-	const resolvedConfig = {
-		...defaultEtaColumnConfig,
-		...config
-	};
-	const Component = ({ row, width }) => /* @__PURE__ */ jsx(EtaText, {
-		row,
-		width,
-		justify: resolvedConfig.justify
-	});
-	return {
-		Component,
-		measure: ({ rows, now }) => {
-			const width = rows.reduce((max, row) => {
-				const duration = etaDurationText(row, now);
-				if (duration === void 0) return max;
-				return Math.max(max, `ETA: ${duration}`.length);
-			}, resolvedConfig.minWidth);
-			return {
-				minWidth: resolvedConfig.minWidth,
-				preferredWidth: width,
-				maxWidth: width
-			};
-		},
-		getLayoutDependency: ({ rows, now }) => rows.reduce((max, row) => {
-			const duration = etaDurationText(row, now);
-			if (duration === void 0) return max;
-			return Math.max(max, `ETA: ${duration}`.length);
-		}, 0),
-		justify: resolvedConfig.justify,
-		noWrap: true,
-		sticky: resolvedConfig.sticky
 	};
 };
-
-//#endregion
-//#region src/renderer/default-columns.tsx
-const defaultRendererv2Columns = [
-	createDescriptionColumn(),
-	createBarColumn(),
-	createAmountColumn(),
-	createElapsedColumn(),
-	createEtaColumn()
+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 elapsedEta = () => ({
+	align: "right",
+	flexShrink: 0,
+	minWidth: 11,
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(ElapsedEtaCell, {
+		task,
+		now: ctx.now
+	})
+});
+const eta = () => ({
+	align: "right",
+	flexShrink: 0,
+	minWidth: 8,
+	render: ({ task }, ctx) => /* @__PURE__ */ jsx(EtaCell, {
+		task,
+		now: ctx.now
+	})
+});
+const defaults = () => [
+	description(),
+	bar(),
+	amount(),
+	elapsedEta()
 ];
+const resolveColumnSizeValue = (value, prepared) => {
+	if (typeof value === "function") return value(prepared);
+	return value;
+};
 
 //#endregion
-//#region src/renderer/width-allocator.ts
-const RENDERER_COLUMN_GAP = 1;
-const clampWidth = (width, minWidth, maxWidth) => maxWidth === void 0 ? Math.max(minWidth, width) : Math.max(minWidth, Math.min(maxWidth, width));
-const normalizeMeasurement = (definition, context) => {
-	if (definition.fixedWidth !== void 0) {
-		const width = Math.max(0, definition.fixedWidth);
-		return {
-			definition,
-			minWidth: width,
-			maxWidth: width,
-			preferredWidth: width,
-			sticky: definition.sticky === true,
-			stickyLimit: width
-		};
-	}
-	const measured = definition.measure(context);
-	const minWidth = Math.max(0, measured.minWidth);
-	const maxWidth = measured.maxWidth === void 0 ? void 0 : Math.max(minWidth, measured.maxWidth);
-	const preferredWidth = clampWidth(measured.preferredWidth, minWidth, maxWidth);
-	const stickyLimit = definition.sticky !== true ? void 0 : definition.stickyMaxWidth !== void 0 ? Math.max(minWidth, definition.stickyMaxWidth) : maxWidth;
-	return {
-		definition,
-		minWidth,
-		maxWidth,
-		preferredWidth,
-		sticky: definition.sticky === true,
-		stickyLimit
-	};
-};
-const visibleIndices = (widths) => widths.flatMap((width, index) => width > 0 ? [index] : []);
-const totalVisibleWidth = (widths) => {
-	const indices = visibleIndices(widths);
-	if (indices.length === 0) return 0;
-	return indices.reduce((sum, index, visibleIndex) => {
-		const padding = visibleIndex < indices.length - 1 ? RENDERER_COLUMN_GAP : 0;
-		return sum + widths[index] + padding;
-	}, 0);
-};
-const nextDistinctWidth = (entries, widest) => entries.find((entry) => entry.width < widest)?.width;
-const shrinkWidestFirst = (widths, columns, targetWidth, canShrink) => {
-	while (totalVisibleWidth(widths) > targetWidth) {
-		const shrinkable = widths.map((width, index) => ({
-			index,
-			width,
-			minWidth: columns[index].minWidth
-		})).filter(({ index, width, minWidth }) => width > minWidth && canShrink(index)).sort((left, right) => right.width - left.width || right.index - left.index);
-		if (shrinkable.length === 0) break;
-		const overflow = totalVisibleWidth(widths) - targetWidth;
-		const widest = shrinkable[0].width;
-		const cohort = shrinkable.filter((entry) => entry.width === widest);
-		const maxUniformDrop = widest - Math.max(nextDistinctWidth(shrinkable, widest) ?? 0, ...cohort.map((entry) => entry.minWidth));
-		const uniformDrop = Math.min(maxUniformDrop, Math.floor(overflow / cohort.length));
-		if (uniformDrop > 0) {
-			for (const { index } of cohort) widths[index] = Math.max(columns[index].minWidth, widths[index] - uniformDrop);
-			continue;
-		}
-		let changed = false;
-		for (const { index, minWidth } of cohort) {
-			if (totalVisibleWidth(widths) <= targetWidth) break;
-			if (widths[index] <= minWidth) continue;
-			widths[index] = widths[index] - 1;
-			changed = true;
-		}
-		if (!changed) break;
-	}
-	return widths;
-};
-const forceFitFromRight = (widths, columns, targetWidth, canShrink) => {
-	while (totalVisibleWidth(widths) > targetWidth) {
-		const rightmostVisibleIndex = widths.findLastIndex((width, index) => width > 0 && canShrink(index));
-		if (rightmostVisibleIndex < 0) break;
-		widths[rightmostVisibleIndex] = widths[rightmostVisibleIndex] - 1;
-	}
-	return widths;
-};
-const applyStickyGrowth = (widths, columns, targetWidth, previousStickyWidths) => {
-	const stickyTargets = columns.map((column, index) => {
-		if (!column.sticky) return;
-		return clampWidth(Math.max(previousStickyWidths.get(index) ?? 0, column.preferredWidth), column.minWidth, column.stickyLimit);
+//#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]);
 	});
-	if (targetWidth === void 0) stickyTargets.forEach((target, index) => {
-		if (target !== void 0) widths[index] = Math.max(widths[index], target);
+	const groups = [{
+		key: NO_PREPARE,
+		prepared: void 0
+	}];
+	for (const [key, rows] of groupedRows) groups.push({
+		key,
+		prepared: key(rows)
 	});
-	else {
-		let remaining = targetWidth - totalVisibleWidth(widths);
-		if (remaining > 0) stickyTargets.forEach((target, index) => {
-			if (target === void 0 || remaining <= 0) return;
-			const deficit = Math.max(0, target - widths[index]);
-			const growth = Math.min(deficit, remaining);
-			widths[index] = widths[index] + growth;
-			remaining -= growth;
+	return groups;
+};
+const getPreparedFor = (def, groups) => {
+	if (!def?.prepare) return;
+	return groups.find((group) => group.key === def.prepare)?.prepared;
+};
+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)
 		});
-	}
-	const nextStickyWidths = /* @__PURE__ */ new Map();
-	stickyTargets.forEach((target, index) => {
-		if (target === void 0) return;
-		nextStickyWidths.set(index, clampWidth(Math.max(target, widths[index]), columns[index].minWidth, columns[index].stickyLimit));
+		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)))
+		};
 	});
-	return {
-		widths,
-		nextStickyWidths
-	};
-};
-const planColumnLayout = (definitions, rows, now, terminalColumns, previousStickyWidths) => {
-	const measureContext = {
-		rows,
-		now
-	};
-	const columns = definitions.map((definition) => normalizeMeasurement(definition, measureContext));
-	let widths = columns.map((column) => column.preferredWidth);
-	if (terminalColumns !== void 0) {
-		widths = shrinkWidestFirst([...widths], columns, terminalColumns, (index) => columns[index].definition.fixedWidth === void 0);
-		if (totalVisibleWidth(widths) > terminalColumns) widths = forceFitFromRight([...widths], columns, terminalColumns, (index) => columns[index].definition.fixedWidth === void 0);
-	}
-	const stickyResult = applyStickyGrowth(widths, columns, terminalColumns, previousStickyWidths);
-	return {
-		columns: stickyResult.widths.map((width, index) => ({
-			definition: columns[index].definition,
-			width
-		})).filter(({ width }) => width > 0),
-		nextStickyWidths: stickyResult.nextStickyWidths
-	};
 };
 
 //#endregion
 //#region src/renderer/public-api.tsx
-const ProgressRow = memo(({ row, rowIndex, terminalColumns, columns }) => /* @__PURE__ */ jsx(Box, {
-	flexDirection: "row",
-	width: terminalColumns,
-	columnGap: RENDERER_COLUMN_GAP,
-	children: columns.map((column, columnIndex) => {
-		const Component = column.definition.Component;
-		return /* @__PURE__ */ jsx(Box, {
-			height: 1,
-			width: column.width,
-			minWidth: column.width,
-			flexBasis: column.width,
-			flexGrow: 0,
-			flexShrink: 0,
-			justifyContent: column.definition.justify === "right" ? "flex-end" : "flex-start",
-			children: /* @__PURE__ */ jsx(Component, {
-				row,
-				rowIndex,
-				width: column.width
-			})
-		}, columnIndex);
-	})
-}), (previousProps, nextProps) => previousProps.row === nextProps.row && previousProps.rowIndex === nextProps.rowIndex && previousProps.terminalColumns === nextProps.terminalColumns && previousProps.columns === nextProps.columns);
-const layoutDependencyKeyFor = (columns, context) => columns.map((column, index) => `${index}:${column.getLayoutDependency?.(context) ?? "static"}`).join("|");
-const CreateProgressRenderer = (columns) => {
-	return ({ rows, terminalColumns, terminalRows }) => {
-		const stickyWidthsRef = useRef(/* @__PURE__ */ new Map());
-		const now = useNow();
-		const layout = useMemo(() => rows.length === 0 ? {
-			columns: [],
-			nextStickyWidths: /* @__PURE__ */ new Map()
-		} : planColumnLayout(columns, rows, now, terminalColumns, stickyWidthsRef.current), [
-			columns,
-			layoutDependencyKeyFor(columns, {
-				rows,
-				now
-			}),
-			rows,
-			terminalColumns
-		]);
-		useEffect(() => {
-			stickyWidthsRef.current = rows.length === 0 ? /* @__PURE__ */ new Map() : layout.nextStickyWidths;
-		}, [layout.nextStickyWidths, rows.length]);
-		if (layout.columns.length === 0) return null;
-		return /* @__PURE__ */ jsx(VirtualList, {
-			items: rows,
-			keyExtractor: (row) => `${row.task.id}`,
-			selectedIndex: Math.max(0, rows.length - 1),
-			height: terminalRows ?? "auto",
-			itemHeight: 1,
-			showOverflowIndicators: true,
-			renderItem: ({ item: row, index: rowIndex }) => /* @__PURE__ */ jsx(ProgressRow, {
-				row,
-				rowIndex,
-				terminalColumns,
-				columns: layout.columns
-			})
-		});
-	};
+const justifyContentForAlign = (align) => {
+	if (align === "right") return "flex-end";
+	if (align === "center") return "center";
+	return "flex-start";
+};
+const renderNode = (node) => {
+	if (typeof node === "string" || typeof node === "number") return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		children: node
+	});
+	return node;
+};
+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 ProgressRenderer = ({ rows, columns }) => {
+	if (rows.length === 0) return null;
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "row",
+		columnGap: 1,
+		overflow: "hidden",
+		children: resolveColumns(rows, columns).map((position) => /* @__PURE__ */ jsx(ColumnPosition, { position }, position.index))
+	});
 };
 
 //#endregion
@@ -1292,31 +1232,22 @@ const useProgressRenderView = (store) => {
 //#endregion
 //#region src/renderer/renderer-service.tsx
 const MAX_FPS = 24;
-const CreateProgressRoot = (columns) => {
-	const ProgressRenderer = CreateProgressRenderer(columns);
-	return ({ store, getTerminalColumns, getTerminalRows }) => {
-		const { renderSnapshot, hasRunningTasks } = useProgressRenderView(store);
-		return /* @__PURE__ */ jsx(SpinnerProvider, {
+const ProgressRoot = ({ store }) => {
+	const { renderSnapshot, hasRunningTasks, publication } = useProgressRenderView(store);
+	return /* @__PURE__ */ jsx(SpinnerProvider, {
+		active: hasRunningTasks,
+		children: /* @__PURE__ */ jsx(NowProvider, {
 			active: hasRunningTasks,
-			children: /* @__PURE__ */ jsx(NowProvider, {
-				active: hasRunningTasks,
-				children: /* @__PURE__ */ jsx(ProgressRenderer, {
-					rows: renderSnapshot.rows,
-					terminalColumns: getTerminalColumns(),
-					terminalRows: getTerminalRows()
-				})
+			children: /* @__PURE__ */ jsx(ProgressRenderer, {
+				rows: renderSnapshot.rows,
+				columns: publication.snapshot.columns
 			})
-		});
-	};
+		})
+	});
 };
-const makeRendererv2InkRendererService = (columns) => {
-	const ProgressRoot = CreateProgressRoot(columns);
-	return { run: (store, stdio, isTTY) => {
-		const proot = /* @__PURE__ */ jsx(ProgressRoot, {
-			store,
-			getTerminalColumns: () => isTTY ? stdio.stderr.columns : void 0,
-			getTerminalRows: () => isTTY ? stdio.stderr.rows : void 0
-		});
+const makeRendererv2InkRendererService = () => {
+	return { run: (store, stdio) => {
+		const proot = /* @__PURE__ */ jsx(ProgressRoot, { store });
 		return Effect.sync(() => render(proot, {
 			stdout: stdio.stdout,
 			stderr: stdio.stderr,
@@ -1337,7 +1268,7 @@ const makeRendererv2InkRendererService = (columns) => {
 //#endregion
 //#region src/services/ink-renderer.tsx
 var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")() {
-	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeRendererv2InkRendererService(defaultRendererv2Columns)));
+	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeRendererv2InkRendererService()));
 };
 
 //#endregion
@@ -1352,16 +1283,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);
@@ -1377,7 +1308,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({
@@ -1397,17 +1348,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);
 });
@@ -1439,9 +1402,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)]));
@@ -1464,10 +1435,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,
@@ -1490,10 +1465,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,
@@ -1515,4 +1493,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, TaskSnapshotSchema, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };
+export { columns_exports as Columns, Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskProgressSampleSchema, TaskRemovedEvent, TaskSnapshot, TaskSnapshotSchema, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };