effective-progress 0.6.1 → 0.7.0

package/README.md

@@ -83,12 +83,15 @@ Support for `either`/`validate` modes of `Effect.all` and render the amount of s
 - In fail-fast runs, unresolved units remain unprocessed.
 - `mode: "either"` and `mode: "validate"` run all effects and keep mixed outcomes in the task counters.
 - Mixed outcomes can still finalize as `done` when all units are accounted for.
+- Empty collections are valid inputs for `Progress.all` / `Progress.forEach` and render as `0/0` instead of failing.
 
 ### Other examples
 
 - `examples/simpleExample.ts` - low-boilerplate real-world flow
 - `examples/advancedExample.ts` - full API usage and manual task control
 - `examples/mixedOutcomes.ts` - fail-fast vs `either`/`validate` with mixed success/failure counters
+- `examples/cliProgressSemantics.ts` - zero totals, negative totals, overflow counts, and empty `all` / `forEach`
+- `examples/unknownTotalCounting.ts` - count successes/failures without a known total and render `processed/?`
 - `examples/showcase.ts` - nested concurrent tasks, spinner workloads, and mixed Effect/Console logging
 - `examples/performance.ts` - stress-style run with high log volume and deeply nested progress updates
 
@@ -106,6 +109,8 @@ Support for `either`/`validate` modes of `Effect.all` and render the amount of s
 - Built-in columns are: description, bar, amount/spinner, elapsed, and ETA.
 - Determinate bars are segmented by outcome: succeeded (green), failed (red), and remaining (neutral).
 - 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.
 - Column widths are shared per frame (widest visible cell wins), so rows stay aligned.
 - Elapsed and ETA reserve stable widths to reduce jitter while tasks transition states.
 - Layout uses a 100-column baseline and grows when content requires more space.
@@ -131,6 +136,12 @@ const program = Progress.task(
 );
 ```
 
+Manual total behavior follows cli-progress-style semantics:
+
+- negative totals on task creation fall back to `100`
+- negative totals on later `updateTask` calls are ignored
+- explicit `total: undefined` on `updateTask` clears the total and switches back to indeterminate rendering
+
 ## Column customization
 
 Custom column APIs are not part of the first Ink release. The renderer ships with built-in columns only, and old renderer config APIs (`RendererConfig`, `ProgressBarConfig`, custom column definitions) are intentionally removed in this iteration.

package/dist/index.d.mts

@@ -26,20 +26,12 @@ interface UpdateTaskOptions {
   readonly countDisplay?: TaskCountDisplay;
 }
 type TrackOptions = Exclude<AddTaskOptions, "parentId">;
-declare const DeterminateTaskUnits_base: Schema.TaggedClass<DeterminateTaskUnits, "DeterminateTaskUnits", {
-  readonly _tag: Schema.tag<"DeterminateTaskUnits">;
-} & {
+declare const TaskUnitsSchema: Schema.Struct<{
   succeeded: typeof Schema.Number;
   failed: typeof Schema.Number;
   processed: typeof Schema.Number;
-  total: typeof Schema.Number;
-}>;
-declare class DeterminateTaskUnits extends DeterminateTaskUnits_base {}
-declare const IndeterminateTaskUnits_base: Schema.TaggedClass<IndeterminateTaskUnits, "IndeterminateTaskUnits", {
-  readonly _tag: Schema.tag<"IndeterminateTaskUnits">;
+  total: Schema.optional<typeof Schema.Number>;
 }>;
-declare class IndeterminateTaskUnits extends IndeterminateTaskUnits_base {}
-declare const TaskUnitsSchema: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
 type TaskUnits = typeof TaskUnitsSchema.Type;
 declare const TaskSnapshot_base: Schema.TaggedClass<TaskSnapshot, "TaskSnapshot", {
   readonly _tag: Schema.tag<"TaskSnapshot">;
@@ -50,7 +42,12 @@ declare const TaskSnapshot_base: Schema.TaggedClass<TaskSnapshot, "TaskSnapshot"
   status: Schema.Literal<["running", "done", "failed"]>;
   countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
   transient: typeof Schema.Boolean;
-  units: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
+  units: Schema.Struct<{
+    succeeded: typeof Schema.Number;
+    failed: typeof Schema.Number;
+    processed: typeof Schema.Number;
+    total: Schema.optional<typeof Schema.Number>;
+  }>;
   startedAt: typeof Schema.Number;
   completedAt: Schema.NullOr<typeof Schema.Number>;
 }>;
@@ -185,4 +182,4 @@ declare class ProgressStdio extends ProgressStdio_base {
   static readonly Default: Layer.Layer<ProgressStdio, never, never>;
 }
 //#endregion
-export { AddTaskOptions, AllOptions, AllReturn, DeterminateTaskUnits, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, IndeterminateTaskUnits, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };
+export { AddTaskOptions, AllOptions, AllReturn, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };

package/dist/index.mjs

@@ -10,14 +10,12 @@ const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 const TaskId = Brand.nominal();
 const TaskStatusSchema = Schema.Literal("running", "done", "failed");
 const TaskCountDisplaySchema = Schema.Literal("processedOnly", "detailed");
-var DeterminateTaskUnits = class extends Schema.TaggedClass()("DeterminateTaskUnits", {
+const TaskUnitsSchema = Schema.Struct({
 	succeeded: Schema.Number,
 	failed: Schema.Number,
 	processed: Schema.Number,
-	total: Schema.Number
-}) {};
-var IndeterminateTaskUnits = class extends Schema.TaggedClass()("IndeterminateTaskUnits", {}) {};
-const TaskUnitsSchema = Schema.Union(DeterminateTaskUnits, IndeterminateTaskUnits);
+	total: Schema.optional(Schema.Number)
+});
 var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
 	id: TaskIdSchema,
 	parentId: Schema.NullOr(TaskIdSchema),
@@ -114,40 +112,37 @@ const toRenderSnapshot = (store) => {
 
 //#endregion
 //#region src/ink-renderer/store.ts
-const normalizeDeterminateCounts = (counts) => {
-	const total = Math.max(0, counts.total);
-	const failed = Math.min(total, Math.max(0, counts.failed));
-	const succeeded = Math.min(total - failed, Math.max(0, counts.succeeded));
-	return new DeterminateTaskUnits({
+const hasExplicitTotal = (options) => Object.prototype.hasOwnProperty.call(options, "total");
+const DEFAULT_TOTAL = 100;
+const sanitizeTotalOnAdd = (total) => {
+	if (total === void 0) return;
+	return total < 0 ? DEFAULT_TOTAL : total;
+};
+const sanitizeTotalOnUpdate = (currentTotal, nextTotal) => {
+	if (nextTotal === void 0) return;
+	return nextTotal < 0 ? currentTotal : nextTotal;
+};
+const normalizeUnits = (counts) => {
+	const succeeded = Math.max(0, counts.succeeded);
+	const failed = Math.max(0, counts.failed);
+	return counts.total === void 0 ? {
+		succeeded,
+		failed,
+		processed: succeeded + failed
+	} : {
 		succeeded,
 		failed,
 		processed: succeeded + failed,
-		total
-	});
+		total: counts.total
+	};
 };
-const updateDeterminateCounts = (units, options) => normalizeDeterminateCounts({
-	succeeded: options.succeeded ?? units.succeeded,
-	failed: options.failed ?? units.failed,
-	total: options.total ?? units.total
-});
 const updatedSnapshot = (snapshot, options) => {
 	const currentUnits = snapshot.units;
-	const units = (() => {
-		if (options.total !== void 0) {
-			if (options.total <= 0) return new IndeterminateTaskUnits({});
-			if (currentUnits._tag === "DeterminateTaskUnits") return updateDeterminateCounts(currentUnits, options);
-			return normalizeDeterminateCounts({
-				succeeded: options.succeeded ?? 0,
-				failed: options.failed ?? 0,
-				total: options.total
-			});
-		}
-		if (currentUnits._tag === "DeterminateTaskUnits") {
-			if (options.succeeded === void 0 && options.failed === void 0) return currentUnits;
-			return updateDeterminateCounts(currentUnits, options);
-		}
-		return currentUnits;
-	})();
+	const units = options.succeeded === void 0 && options.failed === void 0 && options.total === void 0 && !hasExplicitTotal(options) ? currentUnits : normalizeUnits({
+		succeeded: options.succeeded ?? currentUnits.succeeded,
+		failed: options.failed ?? currentUnits.failed,
+		total: hasExplicitTotal(options) ? sanitizeTotalOnUpdate(currentUnits.total, options.total) : currentUnits.total
+	});
 	return new TaskSnapshot({
 		id: snapshot.id,
 		parentId: snapshot.parentId,
@@ -265,10 +260,10 @@ const makeProgressRenderStore = () => {
 		},
 		addTask: (options) => Effect.gen(function* () {
 			const taskId = TaskId(++nextTaskId);
-			const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({}) : normalizeDeterminateCounts({
+			const units = normalizeUnits({
 				succeeded: 0,
 				failed: 0,
-				total: options.total
+				total: sanitizeTotalOnAdd(options.total)
 			});
 			const parentSnapshot = options.parentId === void 0 ? void 0 : state.tasks.get(options.parentId);
 			const now = yield* Clock.currentTimeMillis;
@@ -301,12 +296,13 @@ const makeProgressRenderStore = () => {
 			});
 			return taskId;
 		}),
-		updateTask: (taskId, options) => Effect.sync(() => {
+		updateTask: (taskId, options) => Effect.gen(function* () {
+			const currentTask = state.tasks.get(taskId);
+			if (!currentTask) return;
+			const nextTask = updatedSnapshot(currentTask, options);
 			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return current;
+				if (!current.tasks.get(taskId)) return current;
 				const nextTasks = new Map(current.tasks);
-				const nextTask = updatedSnapshot(currentTask, options);
 				nextTasks.set(taskId, nextTask);
 				if (options.transient !== void 0) for (const [candidateId, candidate] of current.tasks.entries()) {
 					if (candidateId === taskId) continue;
@@ -330,7 +326,7 @@ const makeProgressRenderStore = () => {
 		incrementSucceeded: (taskId, amount = 1) => Effect.sync(() => {
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask || currentTask.units._tag !== "DeterminateTaskUnits") return current;
+				if (!currentTask) return current;
 				const nextTasks = new Map(current.tasks);
 				nextTasks.set(taskId, new TaskSnapshot({
 					id: currentTask.id,
@@ -339,7 +335,7 @@ const makeProgressRenderStore = () => {
 					status: currentTask.status,
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: normalizeDeterminateCounts({
+					units: normalizeUnits({
 						succeeded: currentTask.units.succeeded + amount,
 						failed: currentTask.units.failed,
 						total: currentTask.units.total
@@ -356,7 +352,7 @@ const makeProgressRenderStore = () => {
 		incrementFailed: (taskId, amount = 1) => Effect.sync(() => {
 			updateState((current) => {
 				const currentTask = current.tasks.get(taskId);
-				if (!currentTask || currentTask.units._tag !== "DeterminateTaskUnits") return current;
+				if (!currentTask) return current;
 				const nextTasks = new Map(current.tasks);
 				nextTasks.set(taskId, new TaskSnapshot({
 					id: currentTask.id,
@@ -365,7 +361,7 @@ const makeProgressRenderStore = () => {
 					status: currentTask.status,
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: normalizeDeterminateCounts({
+					units: normalizeUnits({
 						succeeded: currentTask.units.succeeded,
 						failed: currentTask.units.failed + amount,
 						total: currentTask.units.total
@@ -399,10 +395,14 @@ const makeProgressRenderStore = () => {
 					status: "done",
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: currentTask.units._tag === "DeterminateTaskUnits" ? normalizeDeterminateCounts({
-						succeeded: currentTask.units.total - currentTask.units.failed,
+					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
@@ -462,6 +462,8 @@ const SPINNER_FRAMES = [
 	"⠇",
 	"⠏"
 ];
+const isDeterminate$1 = (task) => task.units.total !== void 0;
+const showsUnknownTotalCounts = (task) => task.units.total === void 0 && task.units.processed > 0;
 const formatDurationSeconds = (seconds) => {
 	const value = Math.max(0, Math.floor(seconds));
 	if (value < 60) return `${value}s`;
@@ -478,7 +480,7 @@ const formatElapsed = (task, now) => {
 	return formatDurationSeconds(Math.max(0, (task.completedAt ?? now) - task.startedAt) / 1e3);
 };
 const formatEta = (task, now) => {
-	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return "";
+	if (task.status !== "running" || !isDeterminate$1(task)) return "";
 	const { processed, total } = task.units;
 	const remaining = total - processed;
 	if (processed <= 0 || remaining <= 0) return "";
@@ -494,7 +496,7 @@ const getTaskIndicator = (task, tick) => {
 		symbol: "✗",
 		color: "red"
 	};
-	if (task.units._tag !== "DeterminateTaskUnits") return {
+	if (!isDeterminate$1(task)) return {
 		symbol: "✓",
 		color: "green"
 	};
@@ -517,7 +519,7 @@ const getTaskIndicator = (task, tick) => {
 	};
 };
 const formatDeterminateAmountParts = (task) => {
-	if (task.units._tag !== "DeterminateTaskUnits") return;
+	if (!isDeterminate$1(task)) return;
 	const totalText = `${task.units.total}`;
 	const width = totalText.length;
 	const processedText = `${task.units.processed}`;
@@ -529,19 +531,23 @@ const formatDeterminateAmountParts = (task) => {
 	};
 };
 const formatAmount = (task, _tick) => {
-	if (task.units._tag === "DeterminateTaskUnits") {
+	if (isDeterminate$1(task)) {
 		const parts = formatDeterminateAmountParts(task);
 		if (parts === void 0) return "";
 		if (task.countDisplay === "detailed") return `${parts.succeeded} ${parts.failed} ${parts.processed}/${parts.total}`;
 		return `${parts.processed}/${parts.total}`;
 	}
-	if (task.status === "running" && task.units._tag === "IndeterminateTaskUnits") return "";
+	if (showsUnknownTotalCounts(task)) {
+		if (task.countDisplay === "detailed") return `${task.units.succeeded} ${task.units.failed} ${task.units.processed}/?`;
+		return `${task.units.processed}/?`;
+	}
+	if (task.status === "running") return "";
 	return task.status === "failed" ? "✗" : "";
 };
 
 //#endregion
 //#region src/ink-renderer/columns/determinate.ts
-const isDeterminate = (task) => task.units._tag === "DeterminateTaskUnits";
+const isDeterminate = (task) => task.units.total !== void 0;
 const hasDeterminateRows = (rows) => rows.some((row) => isDeterminate(row.task));
 
 //#endregion
@@ -578,10 +584,11 @@ const resolveColumnSpecs = (specs, resistance) => specs.flatMap((spec) => spec.v
 const padLeft = (value, width) => value.padStart(Math.max(0, width), " ");
 const padRight = (value, width) => value.padEnd(Math.max(0, width), " ");
 const blank = (width) => " ".repeat(Math.max(0, width));
-const shouldShowDetailedCounts = (task) => task.units._tag === "DeterminateTaskUnits" && task.countDisplay === "detailed";
+const shouldShowCountAmount = (task) => task.units.total !== void 0 || task.units.processed > 0;
+const shouldShowDetailedCounts = (task) => shouldShowCountAmount(task) && task.countDisplay === "detailed";
 const SucceededCountColumn = ({ task, width }) => {
 	if (width <= 0) return null;
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	return /* @__PURE__ */ jsx(Text, {
 		color: "green",
@@ -590,7 +597,7 @@ const SucceededCountColumn = ({ task, width }) => {
 };
 const FailedCountColumn = ({ task, width }) => {
 	if (width <= 0) return null;
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	return /* @__PURE__ */ jsx(Text, {
 		color: "red",
@@ -599,11 +606,11 @@ const FailedCountColumn = ({ task, width }) => {
 };
 const ProcessedCountColumn = ({ task, width }) => {
 	if (width <= 0) return null;
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	return /* @__PURE__ */ jsx(Text, { children: padLeft(`${task.units.processed}`, width) });
 };
 const AmountSeparatorColumn = ({ task, tick }) => {
-	if (task.units._tag === "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: "/" });
+	if (shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: "/" });
 	const symbol = formatAmount(task, tick);
 	if (task.status === "failed") return /* @__PURE__ */ jsx(Text, {
 		color: "red",
@@ -617,8 +624,8 @@ const AmountSeparatorColumn = ({ task, tick }) => {
 };
 const TotalCountColumn = ({ task, width }) => {
 	if (width <= 0) return null;
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
-	return /* @__PURE__ */ jsx(Text, { children: padRight(`${task.units.total}`, width) });
+	if (!shouldShowCountAmount(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, { children: padRight(isDeterminate(task) ? `${task.units.total}` : "?", width) });
 };
 const AmountColumn = ({ task, tick, layout }) => {
 	if (layout.kind === "text") {
@@ -682,44 +689,47 @@ const AmountColumn = ({ task, tick, layout }) => {
 	});
 };
 const computeAmountMetrics = (rows, tick) => {
-	let hasDeterminate = false;
+	let hasStructuredCounts = false;
 	let hasDetailed = false;
-	let totalDigits = 0;
+	let countDigits = 0;
+	let totalWidth = 0;
 	let simpleTextWidth = 0;
 	for (const row of rows) {
 		const { task } = row;
-		if (isDeterminate(task)) {
-			hasDeterminate = true;
-			totalDigits = Math.max(totalDigits, textWidth(`${task.units.total}`));
+		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, tick)));
 	}
 	return {
-		hasDeterminate,
+		hasStructuredCounts,
 		hasDetailed,
-		totalDigits: Math.max(1, totalDigits),
+		countDigits: Math.max(1, countDigits),
+		totalWidth: Math.max(1, totalWidth),
 		simpleTextWidth
 	};
 };
 const detailedAmountLayout = (metrics) => ({
 	kind: "detailed",
-	succeededWidth: metrics.hasDetailed ? metrics.totalDigits : 0,
-	failedWidth: metrics.hasDetailed ? metrics.totalDigits : 0,
-	processedWidth: metrics.totalDigits,
-	totalWidth: metrics.totalDigits
+	succeededWidth: metrics.hasDetailed ? metrics.countDigits : 0,
+	failedWidth: metrics.hasDetailed ? metrics.countDigits : 0,
+	processedWidth: metrics.countDigits,
+	totalWidth: metrics.totalWidth
 });
 const processedAmountLayout = (metrics) => ({
 	kind: "processed",
-	processedWidth: metrics.totalDigits,
-	totalWidth: metrics.totalDigits
+	processedWidth: metrics.countDigits,
+	totalWidth: metrics.totalWidth
 });
-const detailedAmountWidth = (metrics) => metrics.totalDigits + 1 + metrics.totalDigits + (metrics.hasDetailed ? metrics.totalDigits + 1 + metrics.totalDigits + 1 : 0);
-const processedAmountWidth = (metrics) => metrics.totalDigits + 1 + metrics.totalDigits;
+const detailedAmountWidth = (metrics) => metrics.countDigits + 1 + metrics.totalWidth + (metrics.hasDetailed ? metrics.countDigits + 1 + metrics.countDigits + 1 : 0);
+const processedAmountWidth = (metrics) => metrics.countDigits + 1 + metrics.totalWidth;
 const createAmountColumnSpec = (context) => {
 	const metrics = computeAmountMetrics(context.rows, context.tick);
-	if (!metrics.hasDeterminate && metrics.simpleTextWidth <= 0) return;
+	if (!metrics.hasStructuredCounts && metrics.simpleTextWidth <= 0) return;
 	const detailedLayout = detailedAmountLayout(metrics);
 	const processedLayout = processedAmountLayout(metrics);
 	const detailedWidth = detailedAmountWidth(metrics);
@@ -728,7 +738,7 @@ const createAmountColumnSpec = (context) => {
 		id: "amount",
 		grow: 0,
 		canHide: true,
-		variants: metrics.hasDeterminate && metrics.hasDetailed ? [{
+		variants: metrics.hasStructuredCounts && metrics.hasDetailed ? [{
 			id: "detailed",
 			minWidth: detailedWidth,
 			idealWidth: detailedWidth,
@@ -746,7 +756,7 @@ const createAmountColumnSpec = (context) => {
 				tick: context.tick,
 				layout: processedLayout
 			})
-		}] : metrics.hasDeterminate ? [{
+		}] : metrics.hasStructuredCounts ? [{
 			id: "processed",
 			minWidth: processedWidth,
 			idealWidth: processedWidth,
@@ -773,13 +783,14 @@ const createAmountColumnSpec = (context) => {
 const DEFAULT_BAR_WIDTH = 30;
 const MIN_BAR_WIDTH = 8;
 const segmentLengths = (width, total, succeeded, failed) => {
-	if (total <= 0) return {
-		succeeded: 0,
+	if (total === 0) return {
+		succeeded: width,
 		failed: 0,
-		remaining: width
+		remaining: 0
 	};
-	const succeededEnd = Math.round(succeeded / total * width);
-	const failedEnd = Math.round((succeeded + failed) / total * width);
+	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 {
@@ -789,7 +800,7 @@ const segmentLengths = (width, total, succeeded, failed) => {
 	};
 };
 const BarColumn = ({ task, width }) => {
-	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
+	if (!isDeterminate(task)) return /* @__PURE__ */ jsx(Text, {});
 	const lengths = segmentLengths(Math.max(1, Math.floor(width)), task.units.total, task.units.succeeded, task.units.failed);
 	return /* @__PURE__ */ jsxs(Text, {
 		wrap: "truncate-end",
@@ -1555,9 +1566,9 @@ const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* ()
 });
 const isTaskFullyProcessed = (progress, taskId) => Effect.gen(function* () {
 	const taskOption = yield* progress.getTask(taskId);
-	if (Option.isNone(taskOption) || taskOption.value.units._tag !== "DeterminateTaskUnits") return false;
+	if (Option.isNone(taskOption)) return false;
 	const { processed, total } = taskOption.value.units;
-	return processed >= total;
+	return total !== void 0 && processed >= total;
 });
 const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* () {
 	const progress = yield* Progress;
@@ -1610,4 +1621,4 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 })));
 
 //#endregion
-export { DeterminateTaskUnits, IndeterminateTaskUnits, Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };
+export { Progress, ProgressStdio, ProgressTaskEventSchema, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplaySchema, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {