effective-progress 0.5.2 → 0.5.4

package/README.md

@@ -11,7 +11,7 @@
 
 <img alt="Showcase output" src="docs/images/showcase.gif" width="600" />
 
-`effective-progress` is an [Effect](https://effect.website/)-first terminal progress-bar library with:
+`effective-progress` is an [Effect](https://effect.website/)-native CLI progress bar library with:
 
 - multiple nested tree-like progress bars
 - spinner support for “we have no idea how long this takes” work
@@ -79,10 +79,17 @@ Effect.runPromise(program);
 
 <img alt="Nested example output" src="docs/images/nesting.gif" width="600" />
 
+### Effect.all modes
+
+We support the `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" />
+
 ### 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/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
 
@@ -98,11 +105,20 @@ Effect.runPromise(program);
 
 - Rendering is powered by [Ink](https://github.com/vadimdemedes/ink).
 - 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>`.
 - 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.
 - 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`:
@@ -110,11 +126,16 @@ For manual usage, `task` still provides the current `Task` context, while logs c
 ```ts
 const program = Progress.task(
   Effect.gen(function* () {
+    const progress = yield* Progress.Progress;
     const currentTask = yield* 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* Effect.sleep("1 second");
   }),
-  { description: "Manual task" },
+  { description: "Manual task", total: 10 },
 );
 ```
 
@@ -122,35 +143,6 @@ const program = Progress.task(
 
 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.
 
-## Terminal service and mocking
-
-`effective-progress` now exposes a `ProgressTerminal` service that controls terminal detection and I/O:
-
-- `isTTY`
-- `stderrRows`
-- `stderrColumns`
-- `writeStderr(text)`
-- `withRawInputCapture(effect)`
-
-You can provide a mock if you want to alter the behavior of terminal detection or if you want to capture the output for testing:
-
-```ts
-import { Effect } from "effect";
-import * as Progress from "effective-progress";
-
-const mockTerminal: Progress.ProgressTerminalService = {
-  isTTY: Effect.succeed(true),
-  stderrRows: Effect.succeed(40),
-  stderrColumns: Effect.succeed(120),
-  writeStderr: (_text) => Effect.void,
-  withRawInputCapture: (effect) => effect,
-};
-
-const program = Progress.task(Effect.sleep("100 millis"), { description: "work" }).pipe(
-  Effect.provideService(Progress.ProgressTerminal, mockTerminal),
-);
-```
-
 ## Notes
 
 - As Effect 4.0 is around the corner with some changes to logging, there may be some adjustments needed to align with the new Effect APIs.

package/dist/index.d.mts

@@ -8,23 +8,30 @@ type TaskId = typeof TaskIdSchema.Type;
 declare const TaskId: Brand.Brand.Constructor<number & Brand.Brand<"TaskId">>;
 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;
 interface AddTaskOptions {
   readonly description: string;
   readonly total?: number;
   readonly transient?: boolean;
   readonly parentId?: TaskId;
+  readonly countDisplay?: TaskCountDisplay;
 }
 interface UpdateTaskOptions {
   readonly description?: string;
-  readonly completed?: number;
+  readonly succeeded?: number;
+  readonly failed?: number;
   readonly total?: number;
   readonly transient?: boolean;
+  readonly countDisplay?: TaskCountDisplay;
 }
 type TrackOptions = Exclude<AddTaskOptions, "parentId">;
 declare const DeterminateTaskUnits_base: Schema.TaggedClass<DeterminateTaskUnits, "DeterminateTaskUnits", {
   readonly _tag: Schema.tag<"DeterminateTaskUnits">;
 } & {
-  completed: typeof Schema.Number;
+  succeeded: typeof Schema.Number;
+  failed: typeof Schema.Number;
+  processed: typeof Schema.Number;
   total: typeof Schema.Number;
 }>;
 declare class DeterminateTaskUnits extends DeterminateTaskUnits_base {}
@@ -43,6 +50,7 @@ declare const TaskSnapshot_base: Schema.TaggedClass<TaskSnapshot, "TaskSnapshot"
   parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
   description: typeof Schema.String;
   status: Schema.Literal<["running", "done", "failed"]>;
+  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
   transient: typeof Schema.Boolean;
   units: Schema.Union<[typeof DeterminateTaskUnits, typeof IndeterminateTaskUnits]>;
   startedAt: typeof Schema.Number;
@@ -61,6 +69,7 @@ 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 completeTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly failTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
@@ -85,6 +94,7 @@ declare const TaskAddedEvent_base: Schema.TaggedClass<TaskAddedEvent, "TaskAdded
   description: typeof Schema.String;
   total: Schema.optional<typeof Schema.Number>;
   transient: typeof Schema.Boolean;
+  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
 }>;
 declare class TaskAddedEvent extends TaskAddedEvent_base {}
 declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskUpdated", {
@@ -92,9 +102,12 @@ declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskU
 } & {
   taskId: Schema.brand<typeof Schema.Number, "TaskId">;
   description: Schema.optional<typeof Schema.String>;
-  completed: Schema.optional<typeof Schema.Number>;
+  succeeded: Schema.optional<typeof Schema.Number>;
+  failed: Schema.optional<typeof Schema.Number>;
+  processed: Schema.optional<typeof Schema.Number>;
   total: Schema.optional<typeof Schema.Number>;
   transient: Schema.optional<typeof Schema.Boolean>;
+  countDisplay: Schema.optional<Schema.Literal<["processedOnly", "detailed"]>>;
 }>;
 declare class TaskUpdatedEvent extends TaskUpdatedEvent_base {}
 declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "TaskAdvanced", {
@@ -102,6 +115,7 @@ declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "Tas
 } & {
   taskId: Schema.brand<typeof Schema.Number, "TaskId">;
   amount: typeof Schema.Number;
+  kind: Schema.Literal<["succeeded", "failed"]>;
 }>;
 declare class TaskAdvancedEvent extends TaskAdvancedEvent_base {}
 declare const TaskCompletedEvent_base: Schema.TaggedClass<TaskCompletedEvent, "TaskCompleted", {
@@ -142,12 +156,12 @@ interface EffectAllExecutionOptions extends EffectExecutionOptions {
   readonly discard?: boolean;
   readonly mode?: "default" | "validate" | "either";
 }
-type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
+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;
 interface ForEachExecutionOptions extends EffectExecutionOptions {
   readonly discard?: false | undefined;
 }
-type ForEachOptions = TrackOptions & ForEachExecutionOptions;
+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>>;
@@ -155,25 +169,22 @@ declare const task: {
 };
 type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
 declare const all: {
-  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(effects: Arg, options: Omit<TrackOptions, "total"> & O): AllReturn<Arg, O>;
-  <O extends EffectAllExecutionOptions>(options: Omit<TrackOptions, "total"> & O): <const Arg extends AllArg>(effects: Arg) => AllReturn<Arg, O>;
+  <const Arg extends AllArg, O extends EffectAllExecutionOptions>(effects: Arg, options: Omit<TrackOptions, "total" | "countDisplay"> & O): AllReturn<Arg, O>;
+  <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>>;
 };
 //#endregion
-//#region src/terminal.d.ts
-interface ProgressTerminalService {
-  readonly isTTY: Effect.Effect<boolean>;
-  readonly stderrRows: Effect.Effect<number | undefined>;
-  readonly stderrColumns: Effect.Effect<number | undefined>;
-  readonly writeStderr: (text: string) => Effect.Effect<void>;
-  readonly withRawInputCapture: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//#region src/stdio.d.ts
+interface ProgressStdioService {
+  readonly stdout: NodeJS.WriteStream;
+  readonly stderr: NodeJS.WriteStream;
 }
-declare const ProgressTerminal_base: Context.TagClass<ProgressTerminal, "stromseng.dev/ProgressTerminal", ProgressTerminalService>;
-declare class ProgressTerminal extends ProgressTerminal_base {
-  static readonly Default: Layer.Layer<ProgressTerminal, never, never>;
+declare const ProgressStdio_base: Context.TagClass<ProgressStdio, "stromseng.dev/effective-progress/ProgressStdio", ProgressStdioService>;
+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, ProgressTaskEvent, ProgressTaskEventSchema, ProgressTerminal, ProgressTerminalService, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskOptions, TaskRemovedEvent, TaskSnapshot, TaskStatus, TaskStatusSchema, TaskStore, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task };
+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 };

package/dist/index.mjs

@@ -1,8 +1,7 @@
-import { Brand, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref, Schema } from "effect";
+import { Brand, Cause, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref, Schema } from "effect";
 import { dual } from "effect/Function";
-import { Writable } from "node:stream";
 import { Box, Text, render } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/ink-renderer/format.ts
 const SPINNER_FRAMES = [
@@ -34,19 +33,64 @@ const formatElapsed = (task, now) => {
 };
 const formatEta = (task, now) => {
 	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return "";
-	const { completed, total } = task.units;
-	const remaining = total - completed;
-	if (completed <= 0 || remaining <= 0) 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 / completed * remaining)) / 1e3);
+	return formatDurationSeconds(Math.max(0, Math.floor(elapsedMillis / processed * remaining)) / 1e3);
 };
-const formatAmount = (task, tick) => {
+const getTaskIndicator = (task, tick) => {
+	if (task.status === "running") return {
+		symbol: SPINNER_FRAMES[tick % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0],
+		color: "yellow"
+	};
+	if (task.status === "failed") return {
+		symbol: "✗",
+		color: "red"
+	};
+	if (task.units._tag !== "DeterminateTaskUnits") return {
+		symbol: "✓",
+		color: "green"
+	};
+	const { succeeded, failed, processed, total } = task.units;
+	if (failed === 0 && processed === total) return {
+		symbol: "✓",
+		color: "green"
+	};
+	if (failed > 0 && succeeded > 0) return {
+		symbol: "~",
+		color: "yellow"
+	};
+	if (failed > 0 && succeeded === 0) return {
+		symbol: "✗",
+		color: "red"
+	};
+	return {
+		symbol: "✓",
+		color: "green"
+	};
+};
+const formatDeterminateAmountParts = (task) => {
+	if (task.units._tag !== "DeterminateTaskUnits") return;
+	const totalText = `${task.units.total}`;
+	const width = totalText.length;
+	const processedText = `${task.units.processed}`;
+	return {
+		succeeded: task.countDisplay === "detailed" ? `${task.units.succeeded}`.padStart(width, " ") : "",
+		failed: task.countDisplay === "detailed" ? `${task.units.failed}`.padStart(width, " ") : "",
+		processed: processedText,
+		total: totalText
+	};
+};
+const formatAmount = (task, _tick) => {
 	if (task.units._tag === "DeterminateTaskUnits") {
-		const totalText = `${task.units.total}`;
-		return `${`${task.units.completed}`.padStart(totalText.length, " ")}/${totalText}`;
+		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") return SPINNER_FRAMES[(task.units.spinnerFrame + tick) % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0];
-	return task.status === "done" ? "✓" : "✗";
+	if (task.status === "running" && task.units._tag === "IndeterminateTaskUnits") return "";
+	return task.status === "failed" ? "✗" : "";
 };
 
 //#endregion
@@ -90,11 +134,11 @@ const computeTreeInfo = (ordered) => {
 
 //#endregion
 //#region src/ink-renderer/layout.ts
-const DEFAULT_BAR_WIDTH = 20;
+const DEFAULT_BAR_WIDTH = 30;
 const MIN_DESCRIPTION_WIDTH = 8;
 const MIN_BAR_WIDTH = 8;
-const MIN_ELAPSED_WIDTH = 3;
-const MIN_AMOUNT_WIDTH = 1;
+const MIN_ELAPSED_WIDTH = 2;
+const MIN_AMOUNT_WIDTH = 0;
 const BASELINE_ROW_WIDTH = 100;
 const MIN_DESCRIPTION_COLUMNS_FOR_TREE = 24;
 const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
@@ -102,29 +146,49 @@ const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
 const textWidth = (text) => Array.from(text).length;
 const computeWidths = (rows, now, tick, terminalColumns, includeTree = true) => {
 	let hasDeterminate = false;
+	let hasDetailedDeterminate = false;
 	let description = MIN_DESCRIPTION_WIDTH;
-	let amount = 1;
-	let elapsed = RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR;
-	let eta = RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR;
+	let amount = 0;
+	let amountSucceeded = 0;
+	let amountFailed = 0;
+	let amountProcessed = 0;
+	let amountTotal = 0;
+	let elapsedContentWidth = MIN_ELAPSED_WIDTH;
+	let etaContentWidth = 0;
 	for (const row of rows) {
 		const { task, tree } = row;
 		const treePrefix = includeTree ? renderTreePrefix(tree) : "";
-		description = Math.max(description, textWidth(`${treePrefix}${task.description}`));
-		if (task.units._tag === "DeterminateTaskUnits") hasDeterminate = true;
-		amount = Math.max(amount, textWidth(formatAmount(task, tick)));
-		elapsed = Math.max(elapsed, textWidth(formatElapsed(task, now)));
+		description = Math.max(description, textWidth(`${treePrefix}${task.description}`) + 2);
+		if (task.units._tag === "DeterminateTaskUnits") {
+			hasDeterminate = true;
+			const totalDigits = textWidth(`${task.units.total}`);
+			if (task.countDisplay === "detailed") {
+				hasDetailedDeterminate = true;
+				amountSucceeded = Math.max(amountSucceeded, totalDigits);
+				amountFailed = Math.max(amountFailed, totalDigits);
+			}
+			amountProcessed = Math.max(amountProcessed, totalDigits);
+			amountTotal = Math.max(amountTotal, totalDigits);
+		} else amount = Math.max(amount, textWidth(formatAmount(task, tick)));
+		elapsedContentWidth = Math.max(elapsedContentWidth, textWidth(formatElapsed(task, now)));
 		if (task.status === "running" && task.units._tag === "DeterminateTaskUnits") {
 			const etaValue = formatEta(task, now);
 			const etaText = `ETA: ${etaValue.length > 0 ? etaValue : "--"}`;
-			eta = Math.max(eta, textWidth(etaText));
+			etaContentWidth = Math.max(etaContentWidth, textWidth(etaText));
 		}
 	}
+	const structuredAmount = hasDeterminate ? amountProcessed + 1 + amountTotal + (hasDetailedDeterminate ? amountSucceeded + 1 + amountFailed + 1 : 0) : 0;
+	if (hasDeterminate) amount = structuredAmount;
 	let widths = {
 		description,
 		bar: hasDeterminate ? DEFAULT_BAR_WIDTH : 0,
 		amount,
-		elapsed,
-		eta
+		amountSucceeded,
+		amountFailed,
+		amountProcessed,
+		amountTotal,
+		elapsed: hasDeterminate ? Math.max(elapsedContentWidth, RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR) : elapsedContentWidth,
+		eta: etaContentWidth > 0 ? Math.max(etaContentWidth, RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR) : 0
 	};
 	const visible = (w) => [
 		w.description,
@@ -137,7 +201,7 @@ const computeWidths = (rows, now, tick, terminalColumns, includeTree = true) =>
 		const cols = visible(w);
 		return cols.reduce((sum, width) => sum + width, 0) + Math.max(0, cols.length - 1);
 	};
-	const baselineTarget = Math.max(BASELINE_ROW_WIDTH, total(widths));
+	const baselineTarget = hasDeterminate ? Math.max(BASELINE_ROW_WIDTH, total(widths)) : total(widths);
 	const target = terminalColumns === void 0 ? baselineTarget : Math.max(1, Math.min(Math.max(1, Math.floor(terminalColumns)), baselineTarget));
 	if (total(widths) < target) widths.description += target - total(widths);
 	else if (total(widths) > target) {
@@ -154,20 +218,28 @@ const computeWidths = (rows, now, tick, terminalColumns, includeTree = true) =>
 			};
 			overflow -= delta;
 		};
-		reduceBy("description", MIN_DESCRIPTION_WIDTH);
-		reduceBy("eta", 0);
+		reduceBy("eta", etaContentWidth);
+		reduceBy("elapsed", elapsedContentWidth);
 		reduceBy("bar", MIN_BAR_WIDTH);
+		reduceBy("eta", 0);
 		reduceBy("bar", 0);
 		reduceBy("elapsed", MIN_ELAPSED_WIDTH);
+		reduceBy("description", MIN_DESCRIPTION_WIDTH);
 		reduceBy("amount", MIN_AMOUNT_WIDTH);
 		reduceBy("description", 0);
 		if (total(widths) < target) widths.description += target - total(widths);
 	}
+	const rowWidth = total(widths);
+	const useStructuredAmount = hasDeterminate && widths.amount >= structuredAmount;
 	return {
-		row: total(widths),
+		row: rowWidth,
 		description: widths.description,
 		bar: widths.bar,
 		amount: widths.amount,
+		amountSucceeded: useStructuredAmount ? widths.amountSucceeded : 0,
+		amountFailed: useStructuredAmount ? widths.amountFailed : 0,
+		amountProcessed: useStructuredAmount ? widths.amountProcessed : 0,
+		amountTotal: useStructuredAmount ? widths.amountTotal : 0,
 		elapsed: widths.elapsed,
 		eta: widths.eta
 	};
@@ -186,42 +258,161 @@ const computeSharedColumnWidths = (rows, now, tick, terminalColumns) => {
 
 //#endregion
 //#region src/ink-renderer/columns/amount-column.tsx
-const AmountColumn = ({ task, tick }) => {
-	const text = formatAmount(task, tick);
+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 SucceededCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
 	return /* @__PURE__ */ jsx(Text, {
-		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : task.units._tag === "DeterminateTaskUnits" ? "whiteBright" : "yellow",
-		children: text
+		color: "green",
+		children: padLeft(`${task.units.succeeded}`, width)
+	});
+};
+const FailedCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	if (!shouldShowDetailedCounts(task)) return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, {
+		color: "red",
+		children: padLeft(`${task.units.failed}`, width)
+	});
+};
+const ProcessedCountColumn = ({ task, width }) => {
+	if (width <= 0) return null;
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: blank(width) });
+	return /* @__PURE__ */ jsx(Text, { children: padLeft(`${task.units.processed}`, width) });
+};
+const AmountSeparatorColumn = ({ task, showStructured, tick }) => {
+	if (!showStructured) return null;
+	if (task.units._tag === "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, { children: "/" });
+	const symbol = formatAmount(task, tick);
+	if (task.status === "failed") return /* @__PURE__ */ jsx(Text, {
+		color: "red",
+		children: symbol
+	});
+	if (task.status === "running") return /* @__PURE__ */ jsx(Text, {
+		color: "yellow",
+		children: symbol
+	});
+	return /* @__PURE__ */ jsx(Text, { children: symbol });
+};
+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) });
+};
+const AmountColumn = ({ task, tick, amountSucceededWidth, amountFailedWidth, amountProcessedWidth, amountTotalWidth }) => {
+	const showStructured = amountProcessedWidth > 0 && amountTotalWidth > 0;
+	if (!showStructured) {
+		const text = formatAmount(task, tick);
+		if (task.status === "failed") return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			color: "red",
+			children: text
+		});
+		if (task.status === "running") return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			color: "yellow",
+			children: text
+		});
+		return /* @__PURE__ */ jsx(Text, {
+			wrap: "truncate-end",
+			children: text
+		});
+	}
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "row",
+		children: [
+			amountSucceededWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(SucceededCountColumn, {
+				task,
+				width: amountSucceededWidth
+			}), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
+			amountFailedWidth > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(FailedCountColumn, {
+				task,
+				width: amountFailedWidth
+			}), /* @__PURE__ */ jsx(Text, { children: ` ` })] }) : null,
+			/* @__PURE__ */ jsx(ProcessedCountColumn, {
+				task,
+				width: amountProcessedWidth
+			}),
+			/* @__PURE__ */ jsx(AmountSeparatorColumn, {
+				task,
+				showStructured,
+				tick
+			}),
+			/* @__PURE__ */ jsx(TotalCountColumn, {
+				task,
+				width: amountTotalWidth
+			})
+		]
 	});
 };
 
 //#endregion
 //#region src/ink-renderer/columns/bar-column.tsx
-const clamp = (value, minimum, maximum) => Math.min(Math.max(value, minimum), maximum);
+const segmentLengths = (width, total, succeeded, failed) => {
+	if (total <= 0) return {
+		succeeded: 0,
+		failed: 0,
+		remaining: width
+	};
+	const succeededEnd = Math.round(succeeded / total * width);
+	const failedEnd = Math.round((succeeded + failed) / total * width);
+	const succeededLength = Math.max(0, Math.min(width, succeededEnd));
+	const failedLength = Math.max(0, Math.min(width, failedEnd) - succeededLength);
+	return {
+		succeeded: succeededLength,
+		failed: failedLength,
+		remaining: Math.max(0, width - succeededLength - failedLength)
+	};
+};
 const BarColumn = ({ task, width }) => {
 	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
-	const barWidth = Math.max(1, Math.floor(width));
-	const safeTotal = Math.max(1, task.units.total);
-	const ratio = task.status === "done" ? 1 : clamp(task.units.completed / safeTotal, 0, 1);
-	const filled = Math.round(barWidth * ratio);
-	const empty = Math.max(0, barWidth - filled);
-	const bar = `${"━".repeat(filled)}${"─".repeat(empty)}`;
-	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",
-		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : "blue",
-		children: bar
+		children: [
+			/* @__PURE__ */ jsx(Text, {
+				color: "green",
+				children: "━".repeat(lengths.succeeded)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "red",
+				children: "━".repeat(lengths.failed)
+			}),
+			/* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: "─".repeat(lengths.remaining)
+			})
+		]
 	});
 };
 
 //#endregion
 //#region src/ink-renderer/columns/description-column.tsx
-const DescriptionColumn = ({ task, tree, showTree }) => /* @__PURE__ */ jsx(Text, {
-	wrap: "truncate-end",
-	children: `${showTree ? renderTreePrefix(tree) : ""}${task.description}`
-});
+const DescriptionColumn = ({ task, tree, showTree, tick }) => {
+	const treePrefix = showTree ? renderTreePrefix(tree) : "";
+	const indicator = getTaskIndicator(task, tick);
+	return /* @__PURE__ */ jsxs(Text, {
+		wrap: "truncate-end",
+		children: [
+			treePrefix,
+			/* @__PURE__ */ jsx(Text, {
+				color: indicator.color,
+				children: indicator.symbol
+			}),
+			` ${task.description}`
+		]
+	});
+};
 
 //#endregion
 //#region src/ink-renderer/columns/elapsed-column.tsx
 const ElapsedColumn = ({ task, now }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
 	color: "gray",
 	children: formatElapsed(task, now)
 });
@@ -247,7 +438,11 @@ const TaskRow = ({ row, now, tick, isTTY, widths }) => {
 		now,
 		tick,
 		isTTY,
-		showTree: widths.showTree
+		showTree: widths.showTree,
+		amountSucceededWidth: widths.amountSucceeded,
+		amountFailedWidth: widths.amountFailed,
+		amountProcessedWidth: widths.amountProcessed,
+		amountTotalWidth: widths.amountTotal
 	};
 	return /* @__PURE__ */ jsxs(Box, {
 		flexDirection: "row",
@@ -268,12 +463,12 @@ const TaskRow = ({ row, now, tick, isTTY, widths }) => {
 					width: Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))
 				})
 			}) : null,
-			/* @__PURE__ */ jsx(Box, {
+			widths.amount > 0 ? /* @__PURE__ */ jsx(Box, {
 				width: widths.amount,
 				flexShrink: 0,
 				marginRight: 1,
 				children: /* @__PURE__ */ jsx(AmountColumn, { ...props })
-			}),
+			}) : null,
 			/* @__PURE__ */ jsx(Box, {
 				width: widths.elapsed,
 				flexShrink: 0,
@@ -324,17 +519,7 @@ const toTaskRows = (store) => computeTreeInfo(orderedVisibleTasks(store)).map((e
 //#region src/ink-renderer/service.tsx
 const RENDER_INTERVAL_MILLIS = 100;
 const hasRunningSpinners = (tasks) => tasks.some((task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits");
-const createInkWritable = (terminal) => new Writable({ write(chunk, _encoding, callback) {
-	try {
-		const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
-		Effect.runSync(terminal.writeStderr(text));
-		callback();
-	} catch (error) {
-		callback(error);
-	}
-} });
-const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, terminal, isTTY) => Effect.gen(function* () {
-	const output = createInkWritable(terminal);
+const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, stdio, isTTY) => Effect.gen(function* () {
 	let instance;
 	let tick = 0;
 	let rendererActive = false;
@@ -348,8 +533,8 @@ const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, terminal, isTT
 		});
 		if (instance === void 0) {
 			instance = render(app, {
-				stdout: output,
-				stderr: output,
+				stdout: stdio.stdout,
+				stderr: stdio.stderr,
 				patchConsole: true,
 				exitOnCtrlC: false,
 				debug: false
@@ -364,12 +549,12 @@ const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, terminal, isTT
 			const dirty = yield* Ref.getAndSet(dirtyRef, false);
 			const store = yield* Ref.get(storeRef);
 			const tasks = Array.from(store.tasks.values()).filter((task) => !(task.transient && task.status !== "running"));
-			if (dirty || hasRunningSpinners(tasks)) yield* renderStore(store, yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
+			if (dirty || hasRunningSpinners(tasks)) yield* renderStore(store, yield* Clock.currentTimeMillis, isTTY ? stdio.stderr.columns : void 0);
 			tick += 1;
 			yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
 		}
 	}).pipe(Effect.ensuring(Effect.gen(function* () {
-		if (rendererActive) yield* renderStore(yield* Ref.get(storeRef), yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
+		if (rendererActive) yield* renderStore(yield* Ref.get(storeRef), yield* Clock.currentTimeMillis, isTTY ? stdio.stderr.columns : void 0);
 		yield* Effect.sync(() => {
 			instance?.unmount();
 		});
@@ -380,37 +565,13 @@ var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective
 };
 
 //#endregion
-//#region src/terminal.ts
-const withRawInputCapture = (effect) => Effect.suspend(() => {
-	if (!process.stdin.isTTY) return effect;
-	const stdin = process.stdin;
-	const wasRaw = Boolean(stdin.isRaw);
-	const onData = (chunk) => {
-		if (chunk.length === 1 && chunk[0] === 3) process.kill(process.pid, "SIGINT");
-	};
-	return Effect.acquireUseRelease(Effect.sync(() => {
-		stdin.resume();
-		stdin.setRawMode?.(true);
-		stdin.on("data", onData);
-	}), () => effect, () => Effect.sync(() => {
-		try {
-			stdin.off("data", onData);
-			stdin.setRawMode?.(wasRaw);
-			stdin.pause();
-		} catch {}
-	}));
-});
-const defaultTerminalService = {
-	isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
-	stderrRows: Effect.sync(() => process.stderr.rows),
-	stderrColumns: Effect.sync(() => process.stderr.columns),
-	writeStderr: (text) => Effect.sync(() => {
-		process.stderr.write(text);
-	}),
-	withRawInputCapture
+//#region src/stdio.ts
+const defaultStdioService = {
+	stdout: process.stdout,
+	stderr: process.stderr
 };
-var ProgressTerminal = class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")() {
-	static Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
+var ProgressStdio = class ProgressStdio extends Context.Tag("stromseng.dev/effective-progress/ProgressStdio")() {
+	static Default = Layer.succeed(ProgressStdio, defaultStdioService);
 };
 
 //#endregion
@@ -418,8 +579,11 @@ var ProgressTerminal = class ProgressTerminal extends Context.Tag("stromseng.dev
 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", {
-	completed: Schema.Number,
+	succeeded: Schema.Number,
+	failed: Schema.Number,
+	processed: Schema.Number,
 	total: Schema.Number
 }) {};
 var IndeterminateTaskUnits = class extends Schema.TaggedClass()("IndeterminateTaskUnits", { spinnerFrame: Schema.Number }) {};
@@ -429,6 +593,7 @@ var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
 	parentId: Schema.NullOr(TaskIdSchema),
 	description: Schema.String,
 	status: TaskStatusSchema,
+	countDisplay: TaskCountDisplaySchema,
 	transient: Schema.Boolean,
 	units: TaskUnitsSchema,
 	startedAt: Schema.Number,
@@ -440,18 +605,23 @@ var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
 	parentId: Schema.NullOr(TaskIdSchema),
 	description: Schema.String,
 	total: Schema.optional(Schema.Number),
-	transient: Schema.Boolean
+	transient: Schema.Boolean,
+	countDisplay: TaskCountDisplaySchema
 }) {};
 var TaskUpdatedEvent = class extends Schema.TaggedClass()("TaskUpdated", {
 	taskId: TaskIdSchema,
 	description: Schema.optional(Schema.String),
-	completed: Schema.optional(Schema.Number),
+	succeeded: Schema.optional(Schema.Number),
+	failed: Schema.optional(Schema.Number),
+	processed: Schema.optional(Schema.Number),
 	total: Schema.optional(Schema.Number),
-	transient: Schema.optional(Schema.Boolean)
+	transient: Schema.optional(Schema.Boolean),
+	countDisplay: Schema.optional(TaskCountDisplaySchema)
 }) {};
 var TaskAdvancedEvent = class extends Schema.TaggedClass()("TaskAdvanced", {
 	taskId: TaskIdSchema,
-	amount: Schema.Number
+	amount: Schema.Number,
+	kind: Schema.Literal("succeeded", "failed")
 }) {};
 var TaskCompletedEvent = class extends Schema.TaggedClass()("TaskCompleted", { taskId: TaskIdSchema }) {};
 var TaskFailedEvent = class extends Schema.TaggedClass()("TaskFailed", { taskId: TaskIdSchema }) {};
@@ -461,23 +631,37 @@ const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema
 
 //#endregion
 //#region src/runtime.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({
+		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({ spinnerFrame: 0 });
-			const completed = options.completed ?? (currentUnits._tag === "DeterminateTaskUnits" ? currentUnits.completed : 0);
-			return new DeterminateTaskUnits({
-				completed: Math.max(0, completed),
-				total: Math.max(0, options.total)
+			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.completed === void 0) return currentUnits;
-			return new DeterminateTaskUnits({
-				completed: Math.max(0, options.completed),
-				total: currentUnits.total
-			});
+			if (options.succeeded === void 0 && options.failed === void 0) return currentUnits;
+			return updateDeterminateCounts(currentUnits, options);
 		}
 		return currentUnits;
 	})();
@@ -486,6 +670,7 @@ const updatedSnapshot = (snapshot, options) => {
 		parentId: snapshot.parentId,
 		description: options.description ?? snapshot.description,
 		status: snapshot.status,
+		countDisplay: options.countDisplay ?? snapshot.countDisplay,
 		transient: options.transient ?? snapshot.transient,
 		units,
 		startedAt: snapshot.startedAt,
@@ -497,6 +682,7 @@ const withTransient = (snapshot, transient) => new TaskSnapshot({
 	parentId: snapshot.parentId,
 	description: snapshot.description,
 	status: snapshot.status,
+	countDisplay: snapshot.countDisplay,
 	transient,
 	units: snapshot.units,
 	startedAt: snapshot.startedAt,
@@ -531,10 +717,10 @@ const removeFromRenderOrder = (renderOrder, taskId) => {
 	return next;
 };
 const makeProgressService = Effect.gen(function* () {
-	const terminal = yield* ProgressTerminal;
+	const stdio = yield* ProgressStdio;
 	const inkRenderer = yield* InkRenderer;
 	const outerConsole = yield* Effect.console;
-	const isTTY = yield* terminal.isTTY;
+	const isTTY = Boolean(stdio.stderr.isTTY);
 	const nextTaskIdRef = yield* Ref.make(0);
 	const storeRef = yield* Ref.make({
 		tasks: /* @__PURE__ */ new Map(),
@@ -545,25 +731,28 @@ const makeProgressService = Effect.gen(function* () {
 	const scope = yield* Effect.scope;
 	const markDirty = Ref.set(dirtyRef, true);
 	const log = (...args) => args.length === 0 ? Effect.void : outerConsole.log(...args);
-	yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
+	yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, stdio, isTTY), 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);
 		const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
-		const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({ spinnerFrame: 0 }) : new DeterminateTaskUnits({
-			completed: 0,
-			total: Math.max(0, options.total)
+		const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({ spinnerFrame: 0 }) : normalizeDeterminateCounts({
+			succeeded: 0,
+			failed: 0,
+			total: options.total
 		});
 		const store = yield* Ref.get(storeRef);
 		const parentSnapshot = Option.isSome(resolvedParentId) ? store.tasks.get(resolvedParentId.value) : void 0;
 		const now = yield* Clock.currentTimeMillis;
 		const parentIdValue = Option.getOrNull(resolvedParentId);
+		const countDisplay = options.countDisplay ?? parentSnapshot?.countDisplay ?? "detailed";
 		const snapshot = new TaskSnapshot({
 			id: taskId,
 			parentId: parentIdValue,
 			description: options.description,
 			status: "running",
-			transient: parentSnapshot?.transient ?? options.transient ?? false,
+			countDisplay,
+			transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
 			units,
 			startedAt: now,
 			completedAt: null
@@ -612,8 +801,9 @@ const makeProgressService = Effect.gen(function* () {
 	const advanceTask = (taskId, amount = 1) => Ref.update(storeRef, (store) => {
 		const snapshot = store.tasks.get(taskId);
 		if (!snapshot) return store;
-		const units = snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
-			completed: Math.min(snapshot.units.total, snapshot.units.completed + amount),
+		const units = snapshot.units._tag === "DeterminateTaskUnits" ? normalizeDeterminateCounts({
+			succeeded: snapshot.units.succeeded + amount,
+			failed: snapshot.units.failed,
 			total: snapshot.units.total
 		}) : new IndeterminateTaskUnits({ spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount) });
 		const nextTasks = new Map(store.tasks);
@@ -622,6 +812,33 @@ const makeProgressService = Effect.gen(function* () {
 			parentId: snapshot.parentId,
 			description: snapshot.description,
 			status: snapshot.status,
+			countDisplay: snapshot.countDisplay,
+			transient: snapshot.transient,
+			units,
+			startedAt: snapshot.startedAt,
+			completedAt: snapshot.completedAt
+		}));
+		return {
+			tasks: nextTasks,
+			renderOrder: store.renderOrder
+		};
+	}).pipe(Effect.zipRight(markDirty));
+	const advanceTaskFailed = (taskId, amount = 1) => Ref.update(storeRef, (store) => {
+		const snapshot = store.tasks.get(taskId);
+		if (!snapshot) return store;
+		if (snapshot.units._tag !== "DeterminateTaskUnits") return store;
+		const units = normalizeDeterminateCounts({
+			succeeded: snapshot.units.succeeded,
+			failed: snapshot.units.failed + amount,
+			total: snapshot.units.total
+		});
+		const nextTasks = new Map(store.tasks);
+		nextTasks.set(taskId, new TaskSnapshot({
+			id: snapshot.id,
+			parentId: snapshot.parentId,
+			description: snapshot.description,
+			status: snapshot.status,
+			countDisplay: snapshot.countDisplay,
 			transient: snapshot.transient,
 			units,
 			startedAt: snapshot.startedAt,
@@ -650,9 +867,11 @@ const makeProgressService = Effect.gen(function* () {
 				parentId: snapshot.parentId,
 				description: snapshot.description,
 				status: "done",
+				countDisplay: snapshot.countDisplay,
 				transient: snapshot.transient,
-				units: snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
-					completed: snapshot.units.total,
+				units: snapshot.units._tag === "DeterminateTaskUnits" ? normalizeDeterminateCounts({
+					succeeded: snapshot.units.total - snapshot.units.failed,
+					failed: snapshot.units.failed,
 					total: snapshot.units.total
 				}) : snapshot.units,
 				startedAt: snapshot.startedAt,
@@ -683,6 +902,7 @@ const makeProgressService = Effect.gen(function* () {
 				parentId: snapshot.parentId,
 				description: snapshot.description,
 				status: "failed",
+				countDisplay: snapshot.countDisplay,
 				transient: snapshot.transient,
 				units: snapshot.units,
 				startedAt: snapshot.startedAt,
@@ -711,6 +931,7 @@ const makeProgressService = Effect.gen(function* () {
 		addTask,
 		updateTask,
 		advanceTask,
+		advanceTaskFailed,
 		completeTask,
 		failTask,
 		log,
@@ -732,11 +953,11 @@ const makeProgressService = Effect.gen(function* () {
 });
 var Progress = class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")() {
 	static Default = Layer.unwrapEffect(Effect.gen(function* () {
-		const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
+		const stdioOption = yield* Effect.serviceOption(ProgressStdio);
 		const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
 		let layer = Layer.scoped(Progress, makeProgressService);
 		if (Option.isNone(inkRendererOption)) layer = layer.pipe(Layer.provide(InkRenderer.Default));
-		if (Option.isNone(terminalOption)) layer = layer.pipe(Layer.provide(ProgressTerminal.Default));
+		if (Option.isNone(stdioOption)) layer = layer.pipe(Layer.provide(ProgressStdio.Default));
 		return layer;
 	}));
 };
@@ -765,11 +986,29 @@ const task = dual(2, (effect, options) => {
 });
 const wrapEffects = (effects, tap) => Array.isArray(effects) ? effects.map(tap) : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
 const countEffects = (effects) => Array.isArray(effects) ? effects.length : Object.keys(effects).length;
+const isCollectAllMode = (mode) => mode === "either" || mode === "validate";
+const allCountDisplay = (mode) => isCollectAllMode(mode) ? "detailed" : "processedOnly";
+const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* () {
+	const exit = yield* Effect.exit(effect);
+	if (Exit.isSuccess(exit)) {
+		yield* progress.advanceTask(taskId, 1);
+		return exit.value;
+	}
+	if (Cause.isInterruptedOnly(exit.cause)) return yield* Effect.failCause(exit.cause);
+	yield* progress.advanceTaskFailed(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;
+	const { processed, total } = taskOption.value.units;
+	return processed >= total;
+});
 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;
-		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))), {
+		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => wrapTrackedEffect(progress, taskId, effect)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
 			discard: options.discard,
@@ -777,6 +1016,8 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 			concurrentFinalizers: options.concurrentFinalizers
 		}));
 		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
+		else if (!isCollectAllMode(options.mode)) yield* progress.failTask(taskId);
+		else if (yield* isTaskFullyProcessed(progress, taskId)) yield* progress.completeTask(taskId);
 		else yield* progress.failTask(taskId);
 		return yield* Exit.match(exit, {
 			onFailure: Effect.failCause,
@@ -785,14 +1026,15 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 	}), {
 		description: options.description,
 		total: countEffects(effects),
-		transient: options.transient
+		transient: options.transient,
+		countDisplay: allCountDisplay(options.mode)
 	});
 })));
 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;
-		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)), {
+		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => wrapTrackedEffect(progress, taskId, f(item, index)), {
 			concurrency: options.concurrency,
 			batching: options.batching,
 			discard: options.discard,
@@ -807,9 +1049,10 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 	}), {
 		description: options.description,
 		total: options.total ?? inferTotal(iterable),
-		transient: options.transient
+		transient: options.transient,
+		countDisplay: "processedOnly"
 	});
 })));
 
 //#endregion
-export { DeterminateTaskUnits, IndeterminateTaskUnits, Progress, ProgressTaskEventSchema, ProgressTerminal, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };
+export { DeterminateTaskUnits, IndeterminateTaskUnits, 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.5.2",
+  "version": "0.5.4",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -43,13 +43,13 @@
     "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@types/react": "^19.2.14",
     "ink": "^6.8.0",
     "react": "^19.2.4"
   },
   "devDependencies": {
     "@effect/language-service": "^0.73.1",
     "@types/bun": "latest",
+    "@types/react": "^19.2.14",
     "effect": "^3.19.17",
     "oxfmt": "^0.32.0",
     "oxlint": "^1.47.0",