effective-progress 0.6.0 → 0.6.2

package/README.md

@@ -17,7 +17,7 @@
 - spinner support for “we have no idea how long this takes” work
 - keep using `Console.log` / `Effect.logInfo` while progress rendering is active
 - familiar `.all` and `.forEach` APIs — swap `Effect` for `Progress`, get progress bars basically for free
-- flicker-free rendering (in theory) by drawing everything in a single terminal frame
+- flicker-free rendering with [Ink](https://github.com/vadimdemedes/ink)
 
 ## Install
 
@@ -27,7 +27,7 @@ bun add effective-progress
 
 ## Usage
 
-This shows the simplest usage: iterate items with a single progress bar.
+Iterate items with a single progress bar.
 
 ```ts
 import { Console, Effect } from "effect";
@@ -50,13 +50,7 @@ Effect.runPromise(program);
 
 ### Nested example
 
-Run:
-
-```bash
-bun examples/nesting.ts
-```
-
-This demonstrates nested multibar behavior where parent tasks each run their own child progress bars.
+Nested progress bars with tree-style rendering that highlights parent tasks and their subtasks
 
 ```ts
 import { Effect } from "effect";
@@ -81,15 +75,21 @@ Effect.runPromise(program);
 
 ### Effect.all modes
 
-We support the `either`/`validate` modes of `Effect.all` and render the amount of sucesses/failures.
+Support for `either`/`validate` modes of `Effect.all` and render the amount of sucesses/failures.
 
 <img alt="Mixed outcomes modes output" src="docs/images/mixedOutcomes.gif" width="600" />
 
+- `Progress.all` in default mode (`mode: "default"`) remains fail-fast.
+- 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.
+
 ### 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/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
 
@@ -112,13 +112,6 @@ We support the `either`/`validate` modes of `Effect.all` and render the amount o
 - Layout uses a 100-column baseline and grows when content requires more space.
 - On narrow terminals, layout compacts to fit available width and tree prefixes are suppressed when description space is too tight.
 
-### Mixed outcomes and `mode`
-
-- `Progress.all` in default mode (`mode: "default"`) remains fail-fast.
-- 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.
-
 ## Manual task control
 
 For manual usage, `task` still provides the current `Task` context, while logs continue through your outer `Console`:
@@ -131,8 +124,8 @@ const program = Progress.task(
     yield* Console.log("This log is handled by the outer Console", { taskId: currentTask });
 
     // Manual determinate updates:
-    yield* progress.advanceTask(currentTask, 3);
-    yield* progress.advanceTaskFailed(currentTask, 1);
+    yield* progress.incrementSucceeded(currentTask, 3);
+    yield* progress.incrementFailed(currentTask, 1);
     yield* Effect.sleep("1 second");
   }),
   { description: "Manual task", total: 10 },

package/dist/index.d.mts

@@ -10,6 +10,13 @@ declare const TaskStatusSchema: Schema.Literal<["running", "done", "failed"]>;
 type TaskStatus = typeof TaskStatusSchema.Type;
 declare const TaskCountDisplaySchema: Schema.Literal<["processedOnly", "detailed"]>;
 type TaskCountDisplay = typeof TaskCountDisplaySchema.Type;
+declare const InvalidTaskTotalError_base: Schema.TaggedErrorClass<InvalidTaskTotalError, "InvalidTaskTotalError", {
+  readonly _tag: Schema.tag<"InvalidTaskTotalError">;
+} & {
+  total: typeof Schema.Number;
+  message: typeof Schema.String;
+}>;
+declare class InvalidTaskTotalError extends InvalidTaskTotalError_base {}
 interface AddTaskOptions {
   readonly description: string;
   readonly total?: number;
@@ -26,20 +33,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 +49,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>;
 }>;
@@ -64,22 +68,22 @@ interface TaskStore {
   readonly renderOrder: ReadonlyArray<RenderRow>;
 }
 interface ProgressService {
-  readonly addTask: (options: AddTaskOptions) => Effect.Effect<TaskId>;
-  readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void>;
-  readonly advanceTask: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
-  readonly advanceTaskFailed: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
+  readonly addTask: (options: AddTaskOptions) => Effect.Effect<TaskId, InvalidTaskTotalError>;
+  readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void, InvalidTaskTotalError>;
+  readonly incrementSucceeded: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
+  readonly incrementFailed: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
   readonly completeTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly failTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
   readonly getTask: (taskId: TaskId) => Effect.Effect<Option.Option<TaskSnapshot>>;
   readonly listTasks: Effect.Effect<ReadonlyArray<TaskSnapshot>>;
   readonly runTask: {
-    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E, Exclude<R, Task>>;
-    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Task>>;
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Task>>;
+    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Task>>;
   };
   readonly withTask: {
-    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E, Exclude<R, Task>>;
-    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Task>>;
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions): Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Task>>;
+    <A, E, R>(options: AddTaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Task>>;
   };
 }
 declare const Task_base: Context.TagClass<Task, "stromseng.dev/effective-progress/Task", number & Brand.Brand<"TaskId">>;
@@ -155,15 +159,15 @@ interface EffectAllExecutionOptions extends EffectExecutionOptions {
   readonly mode?: "default" | "validate" | "either";
 }
 type AllOptions = Omit<TrackOptions, "total" | "countDisplay"> & EffectAllExecutionOptions;
-type AllReturn<Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions> = [[Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>> : never;
+type AllReturn<Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>, O extends EffectAllExecutionOptions> = [[Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Progress | Task>> : never;
 interface ForEachExecutionOptions extends EffectExecutionOptions {
   readonly discard?: false | undefined;
 }
 type ForEachOptions = Omit<TrackOptions, "countDisplay"> & ForEachExecutionOptions;
 type TaskOptions = AddTaskOptions;
 declare const task: {
-  <A, E, R>(effect: Effect.Effect<A, E, R>, options: TaskOptions): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
-  <A, E, R>(options: TaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+  <A, E, R>(effect: Effect.Effect<A, E, R>, options: TaskOptions): Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Progress | Task>>;
+  <A, E, R>(options: TaskOptions): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | InvalidTaskTotalError, Exclude<R, Progress | Task>>;
 };
 type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
 declare const all: {
@@ -171,8 +175,8 @@ declare const all: {
   <O extends EffectAllExecutionOptions>(options: Omit<TrackOptions, "total" | "countDisplay"> & O): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
 };
 declare const forEach: {
-  <A, B, E, R>(iterable: Iterable<A>, f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
-  <A, B, E, R>(f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): (iterable: Iterable<A>) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+  <A, B, E, R>(iterable: Iterable<A>, f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): Effect.Effect<ReadonlyArray<B>, E | InvalidTaskTotalError, Exclude<R, Progress | Task>>;
+  <A, B, E, R>(f: (item: A, index: number) => Effect.Effect<B, E, R>, options: ForEachOptions): (iterable: Iterable<A>) => Effect.Effect<ReadonlyArray<B>, E | InvalidTaskTotalError, Exclude<R, Progress | Task>>;
 };
 //#endregion
 //#region src/services/stdio.d.ts
@@ -185,4 +189,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, InvalidTaskTotalError, 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

@@ -2,7 +2,7 @@ import { Brand, Cause, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Sc
 import { dual } from "effect/Function";
 import { Box, Text, render } from "ink";
 import { useEffect, useState, useSyncExternalStore } from "react";
-import stringWidth from "string-width";
+import stringWidth from "fast-string-width";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/types.ts
@@ -10,14 +10,16 @@ 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", {
+var InvalidTaskTotalError = class extends Schema.TaggedError()("InvalidTaskTotalError", {
+	total: Schema.Number,
+	message: Schema.String
+}) {};
+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,51 +116,75 @@ const toRenderSnapshot = (store) => {
 
 //#endregion
 //#region src/ink-renderer/store.ts
-const normalizeDeterminateCounts = (counts) => {
-	const total = Math.max(0, counts.total);
+const hasExplicitTotal = (options) => Object.prototype.hasOwnProperty.call(options, "total");
+const INVALID_TASK_TOTAL_MESSAGE = "Task total must be greater than 0 when provided.";
+const normalizeTotal = (total) => {
+	if (total <= 0) return Effect.fail(new InvalidTaskTotalError({
+		total,
+		message: INVALID_TASK_TOTAL_MESSAGE
+	}));
+	return Effect.succeed(total);
+};
+const normalizeUnits = (counts) => {
+	const total = counts.total;
+	if (total === void 0) {
+		const succeeded = Math.max(0, counts.succeeded);
+		const failed = Math.max(0, counts.failed);
+		return Effect.succeed({
+			succeeded,
+			failed,
+			processed: succeeded + failed
+		});
+	}
+	return Effect.map(normalizeTotal(total), (normalizedTotal) => {
+		const failed = Math.min(normalizedTotal, Math.max(0, counts.failed));
+		const succeeded = Math.min(normalizedTotal - failed, Math.max(0, counts.succeeded));
+		return {
+			succeeded,
+			failed,
+			processed: succeeded + failed,
+			total: normalizedTotal
+		};
+	});
+};
+const normalizeUnitsUnsafe = (counts) => {
+	const total = counts.total;
+	if (total === void 0) {
+		const succeeded = Math.max(0, counts.succeeded);
+		const failed = Math.max(0, counts.failed);
+		return {
+			succeeded,
+			failed,
+			processed: succeeded + failed
+		};
+	}
 	const failed = Math.min(total, Math.max(0, counts.failed));
 	const succeeded = Math.min(total - failed, Math.max(0, counts.succeeded));
-	return new DeterminateTaskUnits({
+	return {
 		succeeded,
 		failed,
 		processed: succeeded + failed,
 		total
-	});
+	};
 };
-const updateDeterminateCounts = (units, options) => normalizeDeterminateCounts({
-	succeeded: options.succeeded ?? units.succeeded,
-	failed: options.failed ?? units.failed,
-	total: options.total ?? units.total
-});
 const updatedSnapshot = (snapshot, options) => {
 	const currentUnits = snapshot.units;
-	const units = (() => {
-		if (options.total !== void 0) {
-			if (options.total <= 0) return new IndeterminateTaskUnits({});
-			if (currentUnits._tag === "DeterminateTaskUnits") return updateDeterminateCounts(currentUnits, options);
-			return normalizeDeterminateCounts({
-				succeeded: options.succeeded ?? 0,
-				failed: options.failed ?? 0,
-				total: options.total
-			});
-		}
-		if (currentUnits._tag === "DeterminateTaskUnits") {
-			if (options.succeeded === void 0 && options.failed === void 0) return currentUnits;
-			return updateDeterminateCounts(currentUnits, options);
-		}
-		return currentUnits;
-	})();
-	return new TaskSnapshot({
+	const units = options.succeeded === void 0 && options.failed === void 0 && options.total === void 0 && !hasExplicitTotal(options) ? Effect.succeed(currentUnits) : normalizeUnits({
+		succeeded: options.succeeded ?? currentUnits.succeeded,
+		failed: options.failed ?? currentUnits.failed,
+		total: hasExplicitTotal(options) ? options.total : currentUnits.total
+	});
+	return Effect.map(units, (resolvedUnits) => new TaskSnapshot({
 		id: snapshot.id,
 		parentId: snapshot.parentId,
 		description: options.description ?? snapshot.description,
 		status: snapshot.status,
 		countDisplay: options.countDisplay ?? snapshot.countDisplay,
 		transient: options.transient ?? snapshot.transient,
-		units,
+		units: resolvedUnits,
 		startedAt: snapshot.startedAt,
 		completedAt: snapshot.completedAt
-	});
+	}));
 };
 const withTransient = (snapshot, transient) => new TaskSnapshot({
 	id: snapshot.id,
@@ -265,7 +291,7 @@ 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 = yield* normalizeUnits({
 				succeeded: 0,
 				failed: 0,
 				total: options.total
@@ -301,12 +327,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 = yield* 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;
@@ -327,10 +354,10 @@ const makeProgressRenderStore = () => {
 				};
 			});
 		}),
-		addSuccess: (taskId, amount = 1) => Effect.sync(() => {
+		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 +366,7 @@ const makeProgressRenderStore = () => {
 					status: currentTask.status,
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: normalizeDeterminateCounts({
+					units: normalizeUnitsUnsafe({
 						succeeded: currentTask.units.succeeded + amount,
 						failed: currentTask.units.failed,
 						total: currentTask.units.total
@@ -353,10 +380,10 @@ const makeProgressRenderStore = () => {
 				};
 			});
 		}),
-		addFailure: (taskId, amount = 1) => Effect.sync(() => {
+		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 +392,7 @@ const makeProgressRenderStore = () => {
 					status: currentTask.status,
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: normalizeDeterminateCounts({
+					units: normalizeUnitsUnsafe({
 						succeeded: currentTask.units.succeeded,
 						failed: currentTask.units.failed + amount,
 						total: currentTask.units.total
@@ -399,10 +426,14 @@ const makeProgressRenderStore = () => {
 					status: "done",
 					countDisplay: currentTask.countDisplay,
 					transient: currentTask.transient,
-					units: currentTask.units._tag === "DeterminateTaskUnits" ? normalizeDeterminateCounts({
+					units: currentTask.units.total !== void 0 ? normalizeUnitsUnsafe({
 						succeeded: currentTask.units.total - currentTask.units.failed,
 						failed: currentTask.units.failed,
 						total: currentTask.units.total
+					}) : currentTask.units.processed > 0 ? normalizeUnitsUnsafe({
+						succeeded: currentTask.units.succeeded,
+						failed: currentTask.units.failed,
+						total: currentTask.units.processed
 					}) : currentTask.units,
 					startedAt: currentTask.startedAt,
 					completedAt: now
@@ -462,6 +493,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 +511,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 +527,7 @@ const getTaskIndicator = (task, tick) => {
 		symbol: "✗",
 		color: "red"
 	};
-	if (task.units._tag !== "DeterminateTaskUnits") return {
+	if (!isDeterminate$1(task)) return {
 		symbol: "✓",
 		color: "green"
 	};
@@ -517,7 +550,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 +562,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 +615,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 +628,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 +637,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 +655,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 +720,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 +769,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 +787,7 @@ const createAmountColumnSpec = (context) => {
 				tick: context.tick,
 				layout: processedLayout
 			})
-		}] : metrics.hasDeterminate ? [{
+		}] : metrics.hasStructuredCounts ? [{
 			id: "processed",
 			minWidth: processedWidth,
 			idealWidth: processedWidth,
@@ -789,7 +830,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",
@@ -1466,8 +1507,8 @@ const makeProgressService = Effect.gen(function* () {
 		});
 	});
 	const updateTask = store.updateTask;
-	const advanceTask = store.addSuccess;
-	const advanceTaskFailed = store.addFailure;
+	const incrementSucceeded = store.incrementSucceeded;
+	const incrementFailed = store.incrementFailed;
 	const completeTask = store.completeTask;
 	const failTask = store.failTask;
 	const getTask = store.getTask;
@@ -1485,8 +1526,8 @@ const makeProgressService = Effect.gen(function* () {
 	const service = {
 		addTask,
 		updateTask,
-		advanceTask,
-		advanceTaskFailed,
+		incrementSucceeded,
+		incrementFailed,
 		completeTask,
 		failTask,
 		log,
@@ -1546,18 +1587,18 @@ const allCountDisplay = (mode) => isCollectAllMode(mode) ? "detailed" : "process
 const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* () {
 	const exit = yield* Effect.exit(effect);
 	if (Exit.isSuccess(exit)) {
-		yield* progress.advanceTask(taskId, 1);
+		yield* progress.incrementSucceeded(taskId, 1);
 		return exit.value;
 	}
 	if (Cause.isInterruptedOnly(exit.cause)) return yield* Effect.failCause(exit.cause);
-	yield* progress.advanceTaskFailed(taskId, 1);
+	yield* progress.incrementFailed(taskId, 1);
 	return yield* Effect.failCause(exit.cause);
 });
 const isTaskFullyProcessed = (progress, taskId) => Effect.gen(function* () {
 	const taskOption = yield* progress.getTask(taskId);
-	if (Option.isNone(taskOption) || taskOption.value.units._tag !== "DeterminateTaskUnits") return false;
+	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 +1651,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 { InvalidTaskTotalError, 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.0",
+  "version": "0.6.2",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -27,9 +27,6 @@
       "default": "./dist/index.mjs"
     }
   },
-  "engines": {
-    "node": ">=20.12.0"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -43,9 +40,9 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
+    "fast-string-width": "^3.0.2",
     "ink": "^6.8.0",
-    "react": "^19.2.4",
-    "string-width": "^8.2.0"
+    "react": "^19.2.4"
   },
   "devDependencies": {
     "@effect/language-service": "^0.73.1",
@@ -59,5 +56,8 @@
   },
   "peerDependencies": {
     "effect": "^3.19.17"
+  },
+  "engines": {
+    "node": ">=20.12.0"
   }
 }