effective-progress 0.2.1 → 0.2.2

package/README.md

@@ -119,19 +119,16 @@ Task-level `progressbar` config is optional and inherits from its parent task (o
 
 ```ts
 yield *
-  progress.withTask(
-    Effect.sleep("1 second"),
-    {
-      description: "Worker pipeline",
-      progressbar: {
-        barWidth: 20,
-        spinnerFrames: [".", "o", "O", "0"],
-        colors: {
-          spinner: { kind: "named", value: "magentaBright" },
-        },
+  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
@@ -158,17 +155,17 @@ const mockTerminal: Progress.ProgressTerminalService = {
   withRawInputCapture: (effect) => effect,
 };
 
-const program = Progress.withTask(Effect.sleep("100 millis"), { description: "work" }).pipe(
+const program = Progress.task(Effect.sleep("100 millis"), { description: "work" }).pipe(
   Effect.provideService(Progress.ProgressTerminal, mockTerminal),
 );
 ```
 
 ## Manual task control
 
-For manual usage, `withTask` captures logs implicitly and provides the current `Task` context:
+For manual usage, `task` captures logs implicitly and provides the current `Task` context:
 
 ```ts
-const program = Progress.withTask(
+const program = Progress.task(
   Effect.gen(function* () {
     const currentTask = yield* Progress.Task;
     yield* Console.log("This log is rendered through progress output", { taskId: currentTask });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.2.1",
+  "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,4 @@
-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";
@@ -21,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 {
@@ -32,7 +33,7 @@ export interface ForEachExecutionOptions extends EffectExecutionOptions {
 
 export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
-export const withTask: {
+export const task: {
   <A, E, R>(
     effect: Effect.Effect<A, E, R>,
     options: AddTaskOptions,
@@ -40,48 +41,68 @@ export const withTask: {
   <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>>,
+} = 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>(
+  <
+    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
-  >;
+  ): <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>(
+  <
+    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.withTask(
+        return yield* progress.runTask(
           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,
-              },
+            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,
@@ -103,9 +124,7 @@ export const forEach: {
   <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>>;
+  ): (iterable: Iterable<A>) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>>;
 } = dual(
   3,
   <A, B, E, R>(
@@ -117,20 +136,32 @@ export const forEach: {
       Effect.gen(function* () {
         const progress = yield* Progress;
 
-        return yield* progress.withTask(
+        return yield* progress.runTask(
           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,
-              },
+            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,
+                },
+              ),
             );
+
+            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,

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

@@ -6,7 +6,13 @@ 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,
@@ -20,7 +26,6 @@ import {
   TaskId,
   TaskSnapshot,
 } from "./types";
-import { inferTotal } from "./utils";
 
 const mergeConfig = <T extends Record<PropertyKey, any>>(
   base: T,
@@ -76,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);
@@ -101,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);
@@ -110,7 +147,7 @@ const makeProgressService = Effect.gen(function* () {
 
   yield* Effect.forkIn(
     runProgressServiceRenderer(
-      tasksRef,
+      storeRef,
       logsRef,
       pendingLogsRef,
       dirtyRef,
@@ -126,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);
@@ -135,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;
 
@@ -163,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({
@@ -192,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,
@@ -201,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,
@@ -236,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,
@@ -264,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>) =>
@@ -302,11 +336,11 @@ const makeProgressService = Effect.gen(function* () {
   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"] = dual(
+  const runTask: ProgressService["runTask"] = dual(
     2,
     <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
       Effect.gen(function* () {
@@ -321,45 +355,39 @@ const makeProgressService = Effect.gen(function* () {
           transient: options.transient ?? Option.isSome(resolvedParentId),
         });
 
-        const exit = yield* Effect.exit(
-          Effect.locally(
-            Effect.withConsole(
-              Effect.provideService(effect, Task, taskId),
-              makeProgressConsole(log, outerConsole),
-            ),
-            currentParentRef,
-            Option.some(taskId),
+        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(
-      Effect.gen(function* () {
-        const taskId = yield* Task;
-        return yield* Effect.forEach(iterable, (item, index) =>
-          Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
-        );
-      }),
-      {
-        description: options.description,
-        total: options.total ?? inferTotal(iterable),
-        transient: options.transient,
-        progressbar: options.progressbar,
-      },
-    );
+  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,
@@ -370,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,6 +124,15 @@ 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 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>,
@@ -123,11 +142,6 @@ export interface ProgressService {
       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>>;
 }
 
 export class Task extends Context.Tag("stromseng.dev/Task")<Task, TaskId>() {}