effective-progress 0.2.0 → 0.2.2

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/effective-progress)](https://www.npmjs.com/package/effective-progress)
 
 > [!WARNING]
-> Pre-`1.0.0`, breaking changes may happen in any release. SemVer guarantees will begin at `1.0.0`.
+> Pre-`1.0.0`, breaking changes may happen in any release. SemVer guarantees will begin at `1.0.0`.  
 > I recommend using only the `Progress.all` and `Progress.forEach` APIs for now, as they will likely change the least. The lower-level APIs for manual progress bar control are more likely to see breaking changes as I iterate on the design.
 >
 > Please open an issue or reach out if you have any questions or want to contribute!
@@ -115,6 +115,22 @@ const configured = program.pipe(
 Effect.runPromise(configured);
 ```
 
+Task-level `progressbar` config is optional and inherits from its parent task (or from global `ProgressBarConfig` for root tasks):
+
+```ts
+yield *
+  progress.withTask(Effect.sleep("1 second"), {
+    description: "Worker pipeline",
+    progressbar: {
+      barWidth: 20,
+      spinnerFrames: [".", "o", "O", "0"],
+      colors: {
+        spinner: { kind: "named", value: "magentaBright" },
+      },
+    },
+  });
+```
+
 ## Terminal service and mocking
 
 `effective-progress` now exposes a `ProgressTerminal` service that controls terminal detection and I/O:
@@ -125,7 +141,7 @@ Effect.runPromise(configured);
 - `writeStderr(text)`
 - `withRawInputCapture(effect)`
 
-You can provide a mock in tests instead of monkeypatching global process streams:
+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";
@@ -139,45 +155,23 @@ const mockTerminal: Progress.ProgressTerminalService = {
   withRawInputCapture: (effect) => effect,
 };
 
-const program = Progress.withTask({ description: "work" }, Effect.sleep("100 millis")).pipe(
+const program = Progress.task(Effect.sleep("100 millis"), { description: "work" }).pipe(
   Effect.provideService(Progress.ProgressTerminal, mockTerminal),
 );
 ```
 
-## Migration note
+## Manual task control
 
-`RendererConfig.isTTY` has been removed.
-TTY mode is now sourced from `ProgressTerminal.isTTY`.
-
-Task-level `progressbar` config is optional and inherits from its parent task (or from global `ProgressBarConfig` for root tasks):
+For manual usage, `task` captures logs implicitly and provides the current `Task` context:
 
 ```ts
-yield *
-  progress.withTask(
-    {
-      description: "Worker pipeline",
-      progressbar: {
-        barWidth: 20,
-        spinnerFrames: [".", "o", "O", "0"],
-        colors: {
-          spinner: { kind: "named", value: "magentaBright" },
-        },
-      },
-    },
-    Effect.sleep("1 second"),
-  );
-```
-
-For manual usage, `withTask` captures logs implicitly and provides the current `Task` context:
-
-```ts
-const program = Progress.withTask(
-  { description: "Manual task" },
+const program = Progress.task(
   Effect.gen(function* () {
     const currentTask = yield* Progress.Task;
     yield* Console.log("This log is rendered through progress output", { taskId: currentTask });
     yield* Effect.sleep("1 second");
   }),
+  { description: "Manual task" },
 );
 ```
 

package/package.json

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

package/src/api.ts

@@ -1,4 +1,5 @@
-import { Effect } from "effect";
+import { Effect, Exit } from "effect";
+import { dual } from "effect/Function";
 import type { Concurrency } from "effect/Types";
 import { Progress, provideProgressService } from "./runtime";
 import { Task } from "./types";
@@ -20,9 +21,10 @@ export type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions
 export type AllReturn<
   Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
   O extends EffectAllExecutionOptions,
-> =
-  [Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>] extends
-    [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>>
+> = [Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>] extends [
+  Effect.Effect<infer A, infer E, infer R>,
+]
+  ? Effect.Effect<A, E, Exclude<R, Progress | Task>>
   : never;
 
 export interface ForEachExecutionOptions extends EffectExecutionOptions {
@@ -31,81 +33,143 @@ export interface ForEachExecutionOptions extends EffectExecutionOptions {
 
 export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
-export const withTask = <A, E, R>(
-  options: AddTaskOptions,
-  effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, Exclude<R, Progress | Task>> =>
-  provideProgressService(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
-      return yield* progress.withTask(options, effect);
-    }),
-  ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+export const task: {
+  <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+    options: AddTaskOptions,
+  ): Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+  <A, E, R>(
+    options: AddTaskOptions,
+  ): (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Progress | Task>>;
+} = dual(
+  2,
+  <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
+    provideProgressService(
+      Effect.gen(function* () {
+        const progress = yield* Progress;
+        return yield* progress.withTask(effect, options);
+      }),
+    ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>,
+);
 
-export const all = <
-  const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
-  O extends EffectAllExecutionOptions,
->(
-  effects: Arg,
-  options: Omit<TrackOptions, "total"> & O,
-): AllReturn<Arg, O> =>
-  provideProgressService(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
-      return yield* progress.withTask(
-        {
-          description: options.description,
-          total: effects.length,
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        Effect.gen(function* () {
-          const taskId = yield* Task;
-          return yield* Effect.all(
-            effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
-            {
-              concurrency: options.concurrency,
-              batching: options.batching,
-              discard: options.discard,
-              mode: options.mode,
-              concurrentFinalizers: options.concurrentFinalizers,
-            },
-          );
-        }),
-      );
-    }),
-  ) as AllReturn<Arg, O>;
+export const all: {
+  <
+    const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
+    O extends EffectAllExecutionOptions,
+  >(
+    effects: Arg,
+    options: Omit<TrackOptions, "total"> & O,
+  ): AllReturn<Arg, O>;
+  <O extends EffectAllExecutionOptions>(
+    options: Omit<TrackOptions, "total"> & O,
+  ): <const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>>(
+    effects: Arg,
+  ) => AllReturn<Arg, O>;
+} = dual(
+  2,
+  <
+    const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
+    O extends EffectAllExecutionOptions,
+  >(
+    effects: Arg,
+    options: Omit<TrackOptions, "total"> & O,
+  ) =>
+    provideProgressService(
+      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(
+                effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
+                {
+                  concurrency: options.concurrency,
+                  batching: options.batching,
+                  discard: options.discard,
+                  mode: options.mode,
+                  concurrentFinalizers: options.concurrentFinalizers,
+                },
+              ),
+            );
+
+            if (Exit.isSuccess(exit)) {
+              yield* progress.completeTask(taskId);
+            } else {
+              yield* progress.failTask(taskId);
+            }
+
+            return yield* Exit.match(exit, {
+              onFailure: Effect.failCause,
+              onSuccess: Effect.succeed,
+            });
+          }),
+          {
+            description: options.description,
+            total: effects.length,
+            transient: options.transient,
+            progressbar: options.progressbar,
+          },
+        );
+      }),
+    ) as AllReturn<Arg, O>,
+);
+
+export 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>>;
+} = dual(
+  3,
+  <A, B, E, R>(
+    iterable: Iterable<A>,
+    f: (item: A, index: number) => Effect.Effect<B, E, R>,
+    options: ForEachOptions,
+  ) =>
+    provideProgressService(
+      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)),
+                {
+                  concurrency: options.concurrency,
+                  batching: options.batching,
+                  discard: options.discard,
+                  concurrentFinalizers: options.concurrentFinalizers,
+                },
+              ),
+            );
 
-export 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>> =>
-  provideProgressService(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
+            if (Exit.isSuccess(exit)) {
+              yield* progress.completeTask(taskId);
+            } else {
+              yield* progress.failTask(taskId);
+            }
 
-      return yield* progress.withTask(
-        {
-          description: options.description,
-          total: options.total ?? inferTotal(iterable),
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        Effect.gen(function* () {
-          const taskId = yield* Task;
-          return yield* Effect.forEach(
-            iterable,
-            (item, index) =>
-              Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
-            {
-              concurrency: options.concurrency,
-              batching: options.batching,
-              discard: options.discard,
-              concurrentFinalizers: options.concurrentFinalizers,
-            },
-          );
-        }),
-      );
-    }),
-  ) as Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
+            return yield* Exit.match(exit, {
+              onFailure: Effect.failCause,
+              onSuccess: Effect.succeed,
+            });
+          }),
+          {
+            description: options.description,
+            total: options.total ?? inferTotal(iterable),
+            transient: options.transient,
+            progressbar: options.progressbar,
+          },
+        );
+      }),
+    ) as Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>,
+);

package/src/console.ts

@@ -12,7 +12,7 @@ export const makeProgressConsole = (
 
   const delegate = (effect: Effect.Effect<void, never, never>) => effect;
 
-  return {
+  return Console.Console.of({
     [Console.TypeId]: Console.TypeId,
     assert(condition, ...args) {
       return condition ? Effect.void : log("Assertion failed:", ...args);
@@ -81,5 +81,5 @@ export const makeProgressConsole = (
         unsafeLog(...args);
       },
     },
-  };
+  });
 };

package/src/renderer.ts

@@ -5,8 +5,8 @@ import {
   ProgressBarColorsSchema,
 } from "./colors";
 import type { ProgressTerminalService } from "./terminal";
-import type { ProgressBarConfigShape, RendererConfigShape } from "./types";
-import { DeterminateTaskUnits, TaskId, TaskSnapshot } from "./types";
+import type { ProgressBarConfigShape, RendererConfigShape, TaskStore } from "./types";
+import { DeterminateTaskUnits, TaskSnapshot } from "./types";
 
 const HIDE_CURSOR = "\x1b[?25l";
 const SHOW_CURSOR = "\x1b[?25h";
@@ -33,7 +33,7 @@ const buildTaskLine = (
   tick: number,
   colors: CompiledProgressBarColors,
 ): string => {
-  const progressbar = snapshot.progressbar;
+  const progressbar = snapshot.config;
   const prefix = `${"  ".repeat(depth)}- ${snapshot.description}: `;
 
   if (snapshot.status === "failed") {
@@ -57,31 +57,8 @@ const buildTaskLine = (
   return `${prefix}${colors.spinner(frame)}`;
 };
 
-const orderTasksForRender = (
-  tasks: ReadonlyArray<TaskSnapshot>,
-): ReadonlyArray<{ snapshot: TaskSnapshot; depth: number }> => {
-  const byParent = new Map<number | null, Array<TaskSnapshot>>();
-  for (const task of tasks) {
-    const bucket = byParent.get(task.parentId) ?? [];
-    bucket.push(task);
-    byParent.set(task.parentId, bucket);
-  }
-
-  const ordered: Array<{ snapshot: TaskSnapshot; depth: number }> = [];
-  const visit = (parentId: number | null, depth: number) => {
-    const children = byParent.get(parentId) ?? [];
-    for (const child of children) {
-      ordered.push({ snapshot: child, depth });
-      visit(child.id, depth + 1);
-    }
-  };
-
-  visit(null, 0);
-  return ordered;
-};
-
 export const runProgressServiceRenderer = (
-  tasksRef: Ref.Ref<Map<TaskId, TaskSnapshot>>,
+  storeRef: Ref.Ref<TaskStore>,
   logsRef: Ref.Ref<ReadonlyArray<string>>,
   pendingLogsRef: Ref.Ref<ReadonlyArray<string>>,
   dirtyRef: Ref.Ref<boolean>,
@@ -187,14 +164,16 @@ export const runProgressServiceRenderer = (
   const renderFrame = (mode: "tick" | "final") =>
     Effect.gen(function* () {
       const drainedLogs = yield* Ref.getAndSet(pendingLogsRef, []);
-      const snapshots = Array.from((yield* Ref.get(tasksRef)).values()).filter(
-        (task) => !(task.transient && task.status !== "running"),
-      );
-      const ordered = orderTasksForRender(snapshots);
+      const store = yield* Ref.get(storeRef);
+      const ordered = store.renderOrder.flatMap((row) => {
+        const snapshot = store.tasks.get(row.id);
+        if (!snapshot || (snapshot.transient && snapshot.status !== "running")) return [];
+        return [{ snapshot, depth: row.depth }];
+      });
       const frameTick = mode === "final" ? tick + 1 : tick;
       const taskLines = ordered.map(({ snapshot, depth }) => {
         const lineTick = isTTY ? frameTick : 0;
-        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.progressbar));
+        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.config));
       });
 
       if (isTTY) {
@@ -248,7 +227,7 @@ export const runProgressServiceRenderer = (
 
     while (true) {
       const dirty = yield* Ref.getAndSet(dirtyRef, false);
-      const tasks = Array.from((yield* Ref.get(tasksRef)).values()).filter(
+      const tasks = Array.from((yield* Ref.get(storeRef)).tasks.values()).filter(
         (task) => !(task.transient && task.status !== "running"),
       );
       const hasActiveSpinners = tasks.some(

package/src/runtime.ts

@@ -1,11 +1,18 @@
 import { Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
+import { dual } from "effect/Function";
 import { mergeWith } from "es-toolkit/object";
 import { formatWithOptions } from "node:util";
 import type { PartialDeep } from "type-fest";
 import { makeProgressConsole } from "./console";
 import { runProgressServiceRenderer } from "./renderer";
 import { ProgressTerminal } from "./terminal";
-import type { AddTaskOptions, ProgressService, UpdateTaskOptions } from "./types";
+import type {
+  AddTaskOptions,
+  ProgressService,
+  RenderRow,
+  TaskStore,
+  UpdateTaskOptions,
+} from "./types";
 import {
   decodeProgressBarConfigSync,
   decodeRendererConfigSync,
@@ -19,7 +26,6 @@ import {
   TaskId,
   TaskSnapshot,
 } from "./types";
-import { inferTotal } from "./utils";
 
 const mergeConfig = <T extends Record<PropertyKey, any>>(
   base: T,
@@ -75,10 +81,39 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     status: snapshot.status,
     transient: options.transient ?? snapshot.transient,
     units,
-    progressbar: snapshot.progressbar,
+    config: snapshot.config,
   });
 };
 
+const findInsertionIndex = (
+  renderOrder: ReadonlyArray<RenderRow>,
+  parentId: TaskId | null,
+): { index: number; depth: number } => {
+  if (parentId === null) {
+    return { index: renderOrder.length, depth: 0 };
+  }
+  const parentIdx = renderOrder.findIndex((row) => row.id === parentId);
+  if (parentIdx === -1) return { index: renderOrder.length, depth: 0 };
+  const parentDepth = renderOrder[parentIdx]!.depth;
+  let i = parentIdx + 1;
+  while (i < renderOrder.length && renderOrder[i]!.depth > parentDepth) i++;
+  return { index: i, depth: parentDepth + 1 };
+};
+
+const removeFromRenderOrder = (
+  renderOrder: ReadonlyArray<RenderRow>,
+  taskId: TaskId,
+): ReadonlyArray<RenderRow> => {
+  const idx = renderOrder.findIndex((row) => row.id === taskId);
+  if (idx === -1) return renderOrder;
+  const taskDepth = renderOrder[idx]!.depth;
+  let end = idx + 1;
+  while (end < renderOrder.length && renderOrder[end]!.depth > taskDepth) end++;
+  const next = [...renderOrder];
+  next.splice(idx, end - idx);
+  return next;
+};
+
 const makeProgressService = Effect.gen(function* () {
   const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
   const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
@@ -100,7 +135,10 @@ const makeProgressService = Effect.gen(function* () {
   const maxRetainedLogLines = Math.max(0, Math.floor(rendererConfig.maxLogLines ?? 0));
 
   const nextTaskIdRef = yield* Ref.make(0);
-  const tasksRef = yield* Ref.make(new Map<TaskId, TaskSnapshot>());
+  const storeRef = yield* Ref.make<TaskStore>({
+    tasks: new Map<TaskId, TaskSnapshot>(),
+    renderOrder: [],
+  });
   const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const dirtyRef = yield* Ref.make(true);
@@ -109,7 +147,7 @@ const makeProgressService = Effect.gen(function* () {
 
   yield* Effect.forkIn(
     runProgressServiceRenderer(
-      tasksRef,
+      storeRef,
       logsRef,
       pendingLogsRef,
       dirtyRef,
@@ -125,7 +163,7 @@ const makeProgressService = Effect.gen(function* () {
 
   const addTask = (options: AddTaskOptions) =>
     Effect.gen(function* () {
-      const parentId =
+      const resolvedParentId =
         options.parentId === undefined
           ? yield* FiberRef.get(currentParentRef)
           : Option.some(options.parentId);
@@ -134,27 +172,33 @@ const makeProgressService = Effect.gen(function* () {
         options.total === undefined || options.total <= 0
           ? new IndeterminateTaskUnits({ spinnerFrame: 0 })
           : new DeterminateTaskUnits({ completed: 0, total: Math.max(0, options.total) });
-      const tasks = yield* Ref.get(tasksRef);
-      const parentSnapshot = Option.isSome(parentId) ? tasks.get(parentId.value) : undefined;
-      const inheritedProgressBarConfig = parentSnapshot?.progressbar ?? progressBarConfig;
+      const store = yield* Ref.get(storeRef);
+      const parentSnapshot = Option.isSome(resolvedParentId)
+        ? store.tasks.get(resolvedParentId.value)
+        : undefined;
+      const inheritedProgressBarConfig = parentSnapshot?.config ?? progressBarConfig;
       const resolvedProgressBarConfig = decodeProgressBarConfigSync(
         mergeConfig(inheritedProgressBarConfig, options.progressbar),
       );
 
+      const parentIdValue = Option.getOrNull(resolvedParentId);
       const snapshot = new TaskSnapshot({
         id: taskId,
-        parentId: Option.getOrNull(parentId),
+        parentId: parentIdValue,
         description: options.description,
         status: "running",
         transient: options.transient ?? false,
         units,
-        progressbar: resolvedProgressBarConfig,
+        config: resolvedProgressBarConfig,
       });
 
-      yield* Ref.update(tasksRef, (tasks) => {
-        const next = new Map(tasks);
-        next.set(taskId, snapshot);
-        return next;
+      yield* Ref.update(storeRef, (s) => {
+        const nextTasks = new Map(s.tasks);
+        nextTasks.set(taskId, snapshot);
+        const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
+        const nextOrder = [...s.renderOrder];
+        nextOrder.splice(index, 0, { id: taskId, depth });
+        return { tasks: nextTasks, renderOrder: nextOrder };
       });
       yield* markDirty;
 
@@ -162,25 +206,19 @@ const makeProgressService = Effect.gen(function* () {
     });
 
   const updateTask = (taskId: TaskId, options: UpdateTaskOptions) =>
-    Ref.update(tasksRef, (tasks) => {
-      const snapshot = tasks.get(taskId);
-      if (!snapshot) {
-        return tasks;
-      }
-
-      const next = new Map(tasks);
-      next.set(taskId, updatedSnapshot(snapshot, options));
-      return next;
+    Ref.update(storeRef, (store) => {
+      const snapshot = store.tasks.get(taskId);
+      if (!snapshot) return store;
+      const nextTasks = new Map(store.tasks);
+      nextTasks.set(taskId, updatedSnapshot(snapshot, options));
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const advanceTask = (taskId: TaskId, amount = 1) =>
-    Ref.update(tasksRef, (tasks) => {
-      const snapshot = tasks.get(taskId);
-      if (!snapshot) {
-        return tasks;
-      }
+    Ref.update(storeRef, (store) => {
+      const snapshot = store.tasks.get(taskId);
+      if (!snapshot) return store;
 
-      const next = new Map(tasks);
       const units =
         snapshot.units._tag === "DeterminateTaskUnits"
           ? new DeterminateTaskUnits({
@@ -191,7 +229,8 @@ const makeProgressService = Effect.gen(function* () {
               spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount),
             });
 
-      next.set(
+      const nextTasks = new Map(store.tasks);
+      nextTasks.set(
         taskId,
         new TaskSnapshot({
           id: snapshot.id,
@@ -200,27 +239,25 @@ const makeProgressService = Effect.gen(function* () {
           status: snapshot.status,
           transient: snapshot.transient,
           units,
-          progressbar: snapshot.progressbar,
+          config: snapshot.config,
         }),
       );
 
-      return next;
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
-    Ref.update(tasksRef, (tasks) => {
-      const snapshot = tasks.get(taskId);
-      if (!snapshot) {
-        return tasks;
-      }
+    Ref.update(storeRef, (store) => {
+      const snapshot = store.tasks.get(taskId);
+      if (!snapshot) return store;
 
-      const next = new Map(tasks);
+      const nextTasks = new Map(store.tasks);
       if (snapshot.transient) {
-        next.delete(taskId);
-        return next;
+        nextTasks.delete(taskId);
+        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
       }
 
-      next.set(
+      nextTasks.set(
         taskId,
         new TaskSnapshot({
           id: snapshot.id,
@@ -235,26 +272,24 @@ const makeProgressService = Effect.gen(function* () {
                   total: snapshot.units.total,
                 })
               : snapshot.units,
-          progressbar: snapshot.progressbar,
+          config: snapshot.config,
         }),
       );
-      return next;
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const failTask = (taskId: TaskId) =>
-    Ref.update(tasksRef, (tasks) => {
-      const snapshot = tasks.get(taskId);
-      if (!snapshot) {
-        return tasks;
-      }
+    Ref.update(storeRef, (store) => {
+      const snapshot = store.tasks.get(taskId);
+      if (!snapshot) return store;
 
-      const next = new Map(tasks);
+      const nextTasks = new Map(store.tasks);
       if (snapshot.transient) {
-        next.delete(taskId);
-        return next;
+        nextTasks.delete(taskId);
+        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
       }
 
-      next.set(
+      nextTasks.set(
         taskId,
         new TaskSnapshot({
           id: snapshot.id,
@@ -263,10 +298,10 @@ const makeProgressService = Effect.gen(function* () {
           status: "failed",
           transient: snapshot.transient,
           units: snapshot.units,
-          progressbar: snapshot.progressbar,
+          config: snapshot.config,
         }),
       );
-      return next;
+      return { tasks: nextTasks, renderOrder: store.renderOrder };
     }).pipe(Effect.zipRight(markDirty));
 
   const appendLog = (args: ReadonlyArray<unknown>) =>
@@ -275,6 +310,7 @@ const makeProgressService = Effect.gen(function* () {
         return;
       }
 
+      // TODO: Might wanna replace this or make it configurable. Look for other options.
       const message = formatWithOptions(
         {
           colors: isTTY,
@@ -297,67 +333,61 @@ const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
-  const log = (...args: ReadonlyArray<unknown>) =>
-    Effect.gen(function* () {
-      yield* appendLog(args);
-    });
+  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
 
   const getTask = (taskId: TaskId) =>
-    Ref.get(tasksRef).pipe(Effect.map((tasks) => Option.fromNullable(tasks.get(taskId))));
+    Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
 
-  const listTasks = Ref.get(tasksRef).pipe(Effect.map((tasks) => Array.from(tasks.values())));
+  const listTasks = Ref.get(storeRef).pipe(Effect.map((store) => Array.from(store.tasks.values())));
 
-  const withTask: ProgressService["withTask"] = (options, effect) =>
-    Effect.gen(function* () {
-      const outerConsole = yield* Effect.console;
-      const inheritedParentId = yield* FiberRef.get(currentParentRef);
-      const resolvedParentId =
-        options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
-
-      const taskId = yield* addTask({
-        ...options,
-        parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
-        transient: options.transient ?? Option.isSome(resolvedParentId),
-      });
+  const runTask: ProgressService["runTask"] = dual(
+    2,
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
+      Effect.gen(function* () {
+        const outerConsole = yield* Effect.console;
+        const inheritedParentId = yield* FiberRef.get(currentParentRef);
+        const resolvedParentId =
+          options.parentId === undefined ? inheritedParentId : Option.some(options.parentId);
+
+        const taskId = yield* addTask({
+          ...options,
+          parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : undefined,
+          transient: options.transient ?? Option.isSome(resolvedParentId),
+        });
 
-      const exit = yield* Effect.exit(
-        Effect.locally(
+        return yield* Effect.locally(
           Effect.withConsole(
             Effect.provideService(effect, Task, taskId),
             makeProgressConsole(log, outerConsole),
           ),
           currentParentRef,
           Option.some(taskId),
-        ),
-      );
-
-      if (Exit.isSuccess(exit)) {
-        yield* completeTask(taskId);
-      } else {
-        yield* failTask(taskId);
-      }
-
-      return yield* Exit.match(exit, {
-        onFailure: Effect.failCause,
-        onSuccess: Effect.succeed,
-      });
-    });
-
-  const trackIterable: ProgressService["trackIterable"] = (iterable, options, f) =>
-    withTask(
-      {
-        description: options.description,
-        total: options.total ?? inferTotal(iterable),
-        transient: options.transient,
-        progressbar: options.progressbar,
-      },
-      Effect.gen(function* () {
-        const taskId = yield* Task;
-        return yield* Effect.forEach(iterable, (item, index) =>
-          Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
         );
       }),
-    );
+  );
+
+  const withTask: ProgressService["withTask"] = dual(
+    2,
+    <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
+      runTask(
+        Effect.gen(function* () {
+          const taskId = yield* Task;
+          const exit = yield* Effect.exit(effect);
+
+          if (Exit.isSuccess(exit)) {
+            yield* completeTask(taskId);
+          } else {
+            yield* failTask(taskId);
+          }
+
+          return yield* Exit.match(exit, {
+            onFailure: Effect.failCause,
+            onSuccess: Effect.succeed,
+          });
+        }),
+        options,
+      ),
+  );
 
   const service: ProgressService = {
     addTask,
@@ -368,8 +398,8 @@ const makeProgressService = Effect.gen(function* () {
     log,
     getTask,
     listTasks,
+    runTask,
     withTask,
-    trackIterable,
   };
 
   return Progress.of(service);

package/src/terminal.ts

@@ -5,9 +5,7 @@ export interface ProgressTerminalService {
   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>;
+  readonly withRawInputCapture: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 }
 
 const withRawInputCapture: ProgressTerminalService["withRawInputCapture"] = (effect) =>

package/src/types.ts

@@ -102,9 +102,19 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   status: TaskStatusSchema,
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
-  progressbar: ProgressBarConfigSchema,
+  config: ProgressBarConfigSchema,
 }) {}
 
+export interface RenderRow {
+  readonly id: TaskId;
+  readonly depth: number;
+}
+
+export interface TaskStore {
+  readonly tasks: Map<TaskId, TaskSnapshot>;
+  readonly renderOrder: ReadonlyArray<RenderRow>;
+}
+
 export interface ProgressService {
   readonly addTask: (options: AddTaskOptions) => Effect.Effect<TaskId>;
   readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void>;
@@ -114,15 +124,24 @@ export interface ProgressService {
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
   readonly getTask: (taskId: TaskId) => Effect.Effect<Option.Option<TaskSnapshot>>;
   readonly listTasks: Effect.Effect<ReadonlyArray<TaskSnapshot>>;
-  readonly withTask: <A, E, R>(
-    options: AddTaskOptions,
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E, Exclude<R, Task>>;
-  readonly trackIterable: <A, B, E, R>(
-    iterable: Iterable<A>,
-    options: TrackOptions,
-    f: (item: A, index: number) => Effect.Effect<B, E, R>,
-  ) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Task>>;
+  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>>;
+  };
+  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>>;
+  };
 }
 
 export class Task extends Context.Tag("stromseng.dev/Task")<Task, TaskId>() {}