effective-progress 0.11.0 → 0.11.1

package/README.md

@@ -6,6 +6,8 @@
 > Pre-`1.0.0`, breaking changes may happen in any minor release. SemVer guarantees will begin at `1.0.0`.  
 > I recommend using only the `Progress.all` and `Progress.forEach` APIs for now, as they will likely change the least. The lower-level APIs for manual progress bar control are more likely to see breaking changes as I iterate on the design.
 >
+> I am currently waiting on https://github.com/anomalyco/opentui/issues/204 to swap the renderer to opentui.
+>
 > Please open an issue or reach out if you have any questions or want to contribute!
 > Feedback and contributions are very welcome!
 
@@ -145,8 +147,10 @@ Effect.runPromise(program);
 ### Ink renderer behavior
 
 - Rendering is powered by [Ink](https://github.com/vadimdemedes/ink).
-- Built-in columns are exposed as `Progress.Columns.description()`, `bar()`, `amount()`, `elapsed()`, `eta()`, `spacer()`, and `defaults()`.
+- Built-in columns are exposed as `Progress.Columns.description()`, `bar()`, `amount()`, `elapsedEta()`, `elapsed()`, `eta()`, `spacer()`, and `defaults()`.
+- `elapsedEta()` renders a compact clock-style column as `elapsed<eta` using the shape `00:00<00:00`; `defaults()` now uses that combined column.
 - Determinate bars are segmented by outcome: succeeded (green), failed (red), and remaining (neutral).
+- `bar()` defaults to a fixed width of `30`; pass `bar({ size: "fullwidth" })` to consume remaining row width or `bar({ size: 12 })` for an explicit width.
 - Determinate amount text shows counters without prefixes: `<succeeded> <failed> <processed>/<total>`.
 - Counts can exceed `total`; the amount text keeps those raw values (for example `12/10`) while the bar stays visually clamped at full.
 - `total: 0` is valid for determinate tasks and renders as a full bar by default.

package/dist/index.d.mts

@@ -108,6 +108,11 @@ declare const TaskUnitsSchema: Schema.Struct<{
   total: Schema.optional<typeof Schema.Number>;
 }>;
 type TaskUnits = typeof TaskUnitsSchema.Type;
+declare const TaskProgressSampleSchema: Schema.Struct<{
+  timestamp: typeof Schema.Number;
+  processed: typeof Schema.Number;
+}>;
+type TaskProgressSample = typeof TaskProgressSampleSchema.Type;
 declare const TaskSnapshotSchema: Schema.Struct<{
   id: Schema.brand<typeof Schema.Number, "TaskId">;
   parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
@@ -123,6 +128,10 @@ declare const TaskSnapshotSchema: Schema.Struct<{
   }>;
   startedAt: typeof Schema.Number;
   completedAt: Schema.NullOr<typeof Schema.Number>;
+  progressSamples: Schema.Array$<Schema.Struct<{
+    timestamp: typeof Schema.Number;
+    processed: typeof Schema.Number;
+  }>>;
   metadata: typeof Schema.Unknown;
 }>;
 type TaskSnapshot = typeof TaskSnapshotSchema.Type;
@@ -296,9 +305,10 @@ interface BarPrepared {
 //#region src/renderer/columns/description-column.d.ts
 interface DescriptionPrepared {
   readonly minTreeWidth: number;
+  readonly preferredWidth: number;
 }
 declare namespace columns_d_exports {
-  export { AmountLayout, BarPrepared, DescriptionPrepared, SpacerOptions, amount, bar, defaults, description, elapsed, eta, resolveColumnSizeValue, spacer };
+  export { AmountLayout, BarOptions, BarPrepared, DescriptionPrepared, SpacerOptions, amount, bar, defaults, description, elapsed, elapsedEta, eta, resolveColumnSizeValue, spacer };
 }
 interface SpacerOptions {
   readonly flexGrow?: number;
@@ -306,6 +316,9 @@ interface SpacerOptions {
   readonly flexBasis?: number;
   readonly minWidth?: number;
 }
+interface BarOptions {
+  readonly size?: number | "fullwidth";
+}
 declare const spacer: <M = unknown>({
   flexGrow,
   flexShrink,
@@ -313,9 +326,12 @@ declare const spacer: <M = unknown>({
   minWidth
 }?: SpacerOptions) => ColumnDef<M>;
 declare const description: () => ColumnDef<any, DescriptionPrepared>;
-declare const bar: () => ColumnDef<any, BarPrepared>;
+declare const bar: ({
+  size
+}?: BarOptions) => ColumnDef<any, BarPrepared>;
 declare const amount: () => ColumnDef<any, AmountLayout>;
 declare const elapsed: () => ColumnDef<any>;
+declare const elapsedEta: () => ColumnDef<any>;
 declare const eta: () => ColumnDef<any>;
 declare const defaults: () => ReadonlyArray<ColumnDef<any, any>>;
 declare const resolveColumnSizeValue: <P>(value: ColumnSizeValue<P> | undefined, prepared: P) => number | undefined;
@@ -330,4 +346,4 @@ declare class ProgressStdio extends ProgressStdio_base {
   static readonly Default: Layer.Layer<ProgressStdio, never, never>;
 }
 //#endregion
-export { AddTaskOptions, AllOptions, AllReturn, CellInfo, ColumnAlign, ColumnDef, ColumnRenderContext, ColumnSizeValue, columns_d_exports as Columns, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskHandle, TaskId, TaskOptions, TaskRemovedEvent, TaskRowDerived, TaskSnapshot, TaskSnapshotSchema, TaskStatus, TaskStatusSchema, TaskStore, TaskTreeInfo, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task$1 as task };
+export { AddTaskOptions, AllOptions, AllReturn, CellInfo, ColumnAlign, ColumnDef, ColumnRenderContext, ColumnSizeValue, columns_d_exports as Columns, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskHandle, TaskId, TaskOptions, TaskProgressSample, TaskProgressSampleSchema, TaskRemovedEvent, TaskRowDerived, TaskSnapshot, TaskSnapshotSchema, TaskStatus, TaskStatusSchema, TaskStore, TaskTreeInfo, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task$1 as task };

package/dist/index.mjs

@@ -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),
@@ -28,6 +32,7 @@ const TaskSnapshotSchema = Schema.Struct({
 	units: TaskUnitsSchema,
 	startedAt: Schema.Number,
 	completedAt: Schema.NullOr(Schema.Number),
+	progressSamples: Schema.Array(TaskProgressSampleSchema),
 	metadata: Schema.Unknown
 });
 const TaskSnapshot = (snapshot) => snapshot;
@@ -63,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;
@@ -86,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,
@@ -94,30 +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,
-		metadata: snapshot.metadata
+		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,
-	metadata: snapshot.metadata
-});
 const findInsertionIndex = (renderOrder, parentId) => {
 	if (parentId === null) return {
 		index: renderOrder.length,
@@ -250,6 +259,10 @@ const makeProgressRenderStore = () => {
 				units,
 				startedAt: now,
 				completedAt: null,
+				progressSamples: [{
+					timestamp: now,
+					processed: units.processed
+				}],
 				metadata: options.metadata
 			});
 			updateState((current) => {
@@ -279,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({
@@ -302,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,
@@ -319,29 +336,24 @@ const makeProgressRenderStore = () => {
 				};
 			});
 		}),
-		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,
-					metadata: currentTask.metadata
+					...currentTask,
+					units,
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
@@ -357,29 +369,24 @@ 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,
-					metadata: currentTask.metadata
+					...currentTask,
+					units,
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
@@ -422,25 +429,21 @@ const makeProgressRenderStore = () => {
 						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,
+					units,
 					completedAt: now,
-					metadata: currentTask.metadata
+					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
 				}));
 				return {
 					state: {
@@ -480,16 +483,9 @@ const makeProgressRenderStore = () => {
 					};
 				}
 				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,
-					metadata: currentTask.metadata
+					completedAt: now
 				}));
 				return {
 					state: {
@@ -512,15 +508,7 @@ const makeProgressRenderStore = () => {
 				};
 				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,
+					...currentTask,
 					metadata
 				}));
 				return {
@@ -635,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}`;
@@ -826,7 +855,10 @@ const getTaskIndicator = (task, tick, spinnerType = DEFAULT_SPINNER_TYPE) => {
 		color: "green"
 	};
 };
-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 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, {
@@ -861,6 +893,16 @@ const DescriptionCell = ({ cell, width, minTreeWidth, spinnerTick }) => {
 	});
 };
 
+//#endregion
+//#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)
+	});
+};
+
 //#endregion
 //#region src/renderer/columns/elapsed-column.tsx
 const ElapsedCell = ({ task, now }) => {
@@ -891,10 +933,17 @@ var columns_exports = /* @__PURE__ */ __exportAll({
 	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 spacer = ({ flexGrow, flexShrink, flexBasis, minWidth } = {}) => ({
 	render: () => null,
 	flexGrow,
@@ -904,8 +953,8 @@ const spacer = ({ flexGrow, flexShrink, flexBasis, minWidth } = {}) => ({
 });
 const description = () => ({
 	prepare: prepareDescription,
-	flexGrow: 1,
 	flexShrink: 1,
+	flexBasis: (prepared) => prepared.preferredWidth,
 	minWidth: 1,
 	render: (cell, ctx) => /* @__PURE__ */ jsx(DescriptionCell, {
 		cell,
@@ -914,16 +963,20 @@ const description = () => ({
 		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 bar = ({ size } = {}) => {
+	const resolvedSize = resolveBarSize(size);
+	return {
+		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 amount = () => ({
 	prepare: measureAmountLayout,
 	align: "right",
@@ -940,9 +993,19 @@ const elapsed = () => ({
 		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
@@ -952,8 +1015,7 @@ const defaults = () => [
 	description(),
 	bar(),
 	amount(),
-	elapsed(),
-	eta()
+	elapsedEta()
 ];
 const resolveColumnSizeValue = (value, prepared) => {
 	if (typeof value === "function") return value(prepared);
@@ -1431,4 +1493,4 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 })));
 
 //#endregion
-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 };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -44,7 +44,7 @@
   "dependencies": {
     "cli-spinners": "^3.4.0",
     "fast-string-width": "^3.0.2",
-    "ink": "^6.8.0",
+    "ink": "^7.0.1",
     "react": "^19.2.4"
   },
   "devDependencies": {
@@ -64,8 +64,5 @@
   },
   "engines": {
     "node": ">=20.12.0"
-  },
-  "patchedDependencies": {
-    "ink@6.8.0": "patches/ink@6.8.0.patch"
   }
 }