effective-progress 0.1.2 → 0.2.0

package/README.md

@@ -1,11 +1,23 @@
 # effective-progress
 
+[![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`.
+> 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!
+> Feedback and contributions are very welcome!
+
+<img alt="Showcase output" src="docs/images/showcase.gif" width="600" />
+
 `effective-progress` is an [Effect](https://effect.website/)-first terminal progress library with:
 
 - multiple progress bars
 - nested child progress bars
 - spinner support for indeterminate work
 - clean log rendering alongside progress output, allowing you to simply use Effects `Console.log` or `Effect.logInfo`.
+- simple to use `.all` and `.forEach` APIs similar to the ones you already know and love from `effect`. Just swap `Effect` for `Progress` and get progress bars for free!
 
 ## Install
 
@@ -32,12 +44,7 @@ const program = Progress.all(
 Effect.runPromise(program);
 ```
 
-```bash
-bun run examples/basic.ts
-Completed task 1
-Completed task 2
-- Running tasks in parallel: ━━━━━━━━━━━━────────────────── 2/5  40%
-```
+<img alt="Basic example output" src="docs/images/basic.gif" width="600" />
 
 ## Nested example
 
@@ -68,25 +75,151 @@ const program = Progress.all(
 Effect.runPromise(program);
 ```
 
-```bash
-❯ bun run examples/nesting.ts
-- Running tasks in parallel: ━━━━━━━━━━━━────────────────── 2/5  40%
-  - Running subtasks for task 3: ━━━━━━━━────────────────────── 4/15  27%
-  - Running subtasks for task 4: ━━━━━━━━────────────────────── 4/15  27%
-```
+<img alt="Nested example output" src="docs/images/nesting.gif" width="600" />
 
 ## Other examples
 
 - `examples/simpleExample.ts` - low-boilerplate real-world flow
 - `examples/advancedExample.ts` - full API usage with custom config and manual task control
+- `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
 
 ## Log retention
 
-- `maxLogLines` controls in-memory log retention.
-- `maxLogLines` omitted or set to `0` means no log history is kept in memory.
+- `maxLogLines` on `RendererConfig` controls in-memory log retention.
+- Omitted or set to `0` means no log history is kept in memory.
 - `maxLogLines > 0` keeps only the latest `N` log lines in memory.
 
+## Configuring renderer and progress bars
+
+Configure global renderer behavior once, and a global base progress bar style:
+
+```ts
+import { Effect } from "effect";
+import * as Progress from "effective-progress";
+
+const configured = program.pipe(
+  Effect.provideService(Progress.RendererConfig, {
+    maxLogLines: 12,
+    nonTtyUpdateStep: 2,
+  }),
+  Effect.provideService(Progress.ProgressBarConfig, {
+    barWidth: 36,
+    colors: {
+      fill: { kind: "hex", value: "#00b894" },
+      spinner: { kind: "ansi256", value: 214 },
+    },
+  }),
+);
+
+Effect.runPromise(configured);
+```
+
+## 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 in tests instead of monkeypatching global process streams:
+
+```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.withTask({ description: "work" }, Effect.sleep("100 millis")).pipe(
+  Effect.provideService(Progress.ProgressTerminal, mockTerminal),
+);
+```
+
+## Migration note
+
+`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):
+
+```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" },
+  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");
+  }),
+);
+```
+
+## Progress bar colors
+
+`progressbar.colors` is configured with typed color tokens that are validated by Effect Schema.
+
+```ts
+progressbar: {
+  spinnerFrames: ["-", "\\", "|", "/"],
+  barWidth: 30,
+  fillChar: "━",
+  emptyChar: "─",
+  leftBracket: "",
+  rightBracket: "",
+  colors: {
+    fill: { kind: "named", value: "cyan" },
+    empty: { kind: "hex", value: "#9ca3af", modifiers: ["dim"] },
+    brackets: { kind: "rgb", value: { r: 156, g: 163, b: 175 } },
+    percent: { kind: "named", value: "whiteBright", modifiers: ["bold"] },
+    spinner: { kind: "ansi256", value: 214 },
+    done: { kind: "named", value: "greenBright" },
+    failed: { kind: "named", value: "redBright", modifiers: ["bold"] },
+  },
+}
+```
+
+Supported color styles:
+
+- `named` (for example `cyan`, `greenBright`)
+- `hex` (for example `#00b894`)
+- `rgb` (for example `{ r: 0, g: 184, b: 148 }`)
+- `ansi256` (for example `214`)
+
+Supported modifiers:
+
+- `bold`, `dim`, `italic`, `underline`, `inverse`, `hidden`, `strikethrough`
+
+## Dependencies & package size
+
+This library is designed for CLI workflows, where package size is typically a lower-priority concern. Alongside `effect`, it relies on two mature runtime dependencies: `chalk` and `es-toolkit`.
+
 ## Notes
 
-- This is a WIP library, so expect breaking changes. Feedback and contributions are very welcome!
 - 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effective-progress",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -31,7 +31,9 @@
   },
   "dependencies": {
     "chalk": "^5.6.2",
-    "effect": "^3.19.16"
+    "effect": "^3.19.17",
+    "es-toolkit": "^1.44.0",
+    "type-fest": "^5.4.4"
   },
   "devDependencies": {
     "@effect/language-service": "^0.73.1",

package/src/api.ts

@@ -1,9 +1,8 @@
-import { Console, Effect, Option } from "effect";
+import { Effect } from "effect";
 import type { Concurrency } from "effect/Types";
-import { makeProgressConsole } from "./console";
-import { makeProgressService } from "./runtime";
-import { Progress } from "./types";
-import type { TrackOptions } from "./types";
+import { Progress, provideProgressService } from "./runtime";
+import { Task } from "./types";
+import type { AddTaskOptions, TrackOptions } from "./types";
 import { inferTotal } from "./utils";
 
 export interface EffectExecutionOptions {
@@ -23,7 +22,7 @@ export type AllReturn<
   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>>
+    [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>>
   : never;
 
 export interface ForEachExecutionOptions extends EffectExecutionOptions {
@@ -32,26 +31,16 @@ export interface ForEachExecutionOptions extends EffectExecutionOptions {
 
 export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
-export const withProgressService = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-  Effect.gen(function* () {
-    const outerConsole = yield* Console.consoleWith((console) => Effect.succeed(console));
-    const existing = yield* Effect.serviceOption(Progress);
-    if (Option.isSome(existing)) {
-      const console = makeProgressConsole(existing.value, outerConsole);
-      return yield* Effect.withConsole(
-        Effect.provideService(effect, Progress, existing.value),
-        console,
-      );
-    }
-
-    return yield* Effect.scoped(
-      Effect.gen(function* () {
-        const service = yield* makeProgressService;
-        const console = makeProgressConsole(service, outerConsole);
-        return yield* Effect.withConsole(Effect.provideService(effect, Progress, service), console);
-      }),
-    );
-  });
+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 all = <
   const Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
@@ -60,7 +49,7 @@ export const all = <
   effects: Arg,
   options: Omit<TrackOptions, "total"> & O,
 ): AllReturn<Arg, O> =>
-  withProgressService(
+  provideProgressService(
     Effect.gen(function* () {
       const progress = yield* Progress;
       return yield* progress.withTask(
@@ -68,9 +57,11 @@ export const all = <
           description: options.description,
           total: effects.length,
           transient: options.transient,
+          progressbar: options.progressbar,
         },
-        (taskId) =>
-          Effect.all(
+        Effect.gen(function* () {
+          const taskId = yield* Task;
+          return yield* Effect.all(
             effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
             {
               concurrency: options.concurrency,
@@ -79,7 +70,8 @@ export const all = <
               mode: options.mode,
               concurrentFinalizers: options.concurrentFinalizers,
             },
-          ),
+          );
+        }),
       );
     }),
   ) as AllReturn<Arg, O>;
@@ -88,8 +80,8 @@ 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>> =>
-  withProgressService(
+): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress | Task>> =>
+  provideProgressService(
     Effect.gen(function* () {
       const progress = yield* Progress;
 
@@ -98,18 +90,22 @@ export const forEach = <A, B, E, R>(
           description: options.description,
           total: options.total ?? inferTotal(iterable),
           transient: options.transient,
+          progressbar: options.progressbar,
         },
-        (taskId) =>
-          Effect.forEach(
+        Effect.gen(function* () {
+          const taskId = yield* Task;
+          return yield* Effect.forEach(
             iterable,
-            (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
+            (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>>;

package/src/colors.ts

@@ -0,0 +1,156 @@
+import chalk from "chalk";
+import type { ChalkInstance } from "chalk";
+import { Schema } from "effect";
+
+export const StyleModifierSchema = Schema.Literal(
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "inverse",
+  "hidden",
+  "strikethrough",
+);
+export type StyleModifier = typeof StyleModifierSchema.Type;
+
+export const NamedColorSchema = Schema.Literal(
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "blackBright",
+  "redBright",
+  "greenBright",
+  "yellowBright",
+  "blueBright",
+  "magentaBright",
+  "cyanBright",
+  "whiteBright",
+);
+export type NamedColor = typeof NamedColorSchema.Type;
+
+const HexColorSchema = Schema.String.pipe(Schema.pattern(/^#(?:[A-Fa-f0-9]{3}|[A-Fa-f0-9]{6})$/));
+const ColorChannelSchema = Schema.Number.pipe(
+  Schema.int(),
+  Schema.greaterThanOrEqualTo(0),
+  Schema.lessThanOrEqualTo(255),
+);
+const Ansi256Schema = Schema.Number.pipe(
+  Schema.int(),
+  Schema.greaterThanOrEqualTo(0),
+  Schema.lessThanOrEqualTo(255),
+);
+const ModifiersSchema = Schema.optional(Schema.Array(StyleModifierSchema));
+
+export const NamedColorStyleSchema = Schema.Struct({
+  kind: Schema.Literal("named"),
+  value: NamedColorSchema,
+  modifiers: ModifiersSchema,
+});
+
+export const HexColorStyleSchema = Schema.Struct({
+  kind: Schema.Literal("hex"),
+  value: HexColorSchema,
+  modifiers: ModifiersSchema,
+});
+
+export const RgbColorStyleSchema = Schema.Struct({
+  kind: Schema.Literal("rgb"),
+  value: Schema.Struct({
+    r: ColorChannelSchema,
+    g: ColorChannelSchema,
+    b: ColorChannelSchema,
+  }),
+  modifiers: ModifiersSchema,
+});
+
+export const Ansi256ColorStyleSchema = Schema.Struct({
+  kind: Schema.Literal("ansi256"),
+  value: Ansi256Schema,
+  modifiers: ModifiersSchema,
+});
+
+export const ColorStyleSchema = Schema.Union(
+  NamedColorStyleSchema,
+  HexColorStyleSchema,
+  RgbColorStyleSchema,
+  Ansi256ColorStyleSchema,
+);
+export type ColorStyle = typeof ColorStyleSchema.Type;
+
+export const ProgressBarColorsSchema = Schema.Struct({
+  fill: ColorStyleSchema,
+  empty: ColorStyleSchema,
+  brackets: ColorStyleSchema,
+  percent: ColorStyleSchema,
+  spinner: ColorStyleSchema,
+  done: ColorStyleSchema,
+  failed: ColorStyleSchema,
+});
+export type ProgressBarColors = typeof ProgressBarColorsSchema.Type;
+
+export const defaultProgressBarColors: ProgressBarColors = {
+  fill: { kind: "named", value: "cyan" },
+  empty: { kind: "named", value: "white", modifiers: ["dim"] },
+  brackets: { kind: "named", value: "white", modifiers: ["dim"] },
+  percent: { kind: "named", value: "white", modifiers: ["bold"] },
+  spinner: { kind: "named", value: "yellow" },
+  done: { kind: "named", value: "green" },
+  failed: { kind: "named", value: "red" },
+};
+
+const applyModifier = (instance: ChalkInstance, modifier: StyleModifier): ChalkInstance =>
+  instance[modifier] as ChalkInstance;
+
+const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance =>
+  instance[color] as ChalkInstance;
+
+const resolveBaseStyle = (style: ColorStyle): ChalkInstance => {
+  switch (style.kind) {
+    case "named":
+      return applyNamedColor(chalk, style.value);
+    case "hex":
+      return chalk.hex(style.value);
+    case "rgb":
+      return chalk.rgb(style.value.r, style.value.g, style.value.b);
+    case "ansi256":
+      return chalk.ansi256(style.value);
+  }
+};
+
+const applyModifiers = (instance: ChalkInstance, modifiers: ReadonlyArray<StyleModifier>) => {
+  let styled = instance;
+  for (const modifier of modifiers) {
+    styled = applyModifier(styled, modifier);
+  }
+  return styled;
+};
+
+export const applyColorStyle = (style: ColorStyle, text: string): string => {
+  const styled = applyModifiers(resolveBaseStyle(style), style.modifiers ?? []);
+  return styled(text);
+};
+
+export interface CompiledProgressBarColors {
+  readonly fill: (text: string) => string;
+  readonly empty: (text: string) => string;
+  readonly brackets: (text: string) => string;
+  readonly percent: (text: string) => string;
+  readonly spinner: (text: string) => string;
+  readonly done: (text: string) => string;
+  readonly failed: (text: string) => string;
+}
+
+export const compileProgressBarColors = (colors: ProgressBarColors): CompiledProgressBarColors => ({
+  fill: (text) => applyColorStyle(colors.fill, text),
+  empty: (text) => applyColorStyle(colors.empty, text),
+  brackets: (text) => applyColorStyle(colors.brackets, text),
+  percent: (text) => applyColorStyle(colors.percent, text),
+  spinner: (text) => applyColorStyle(colors.spinner, text),
+  done: (text) => applyColorStyle(colors.done, text),
+  failed: (text) => applyColorStyle(colors.failed, text),
+});

package/src/console.ts

@@ -1,14 +1,13 @@
 import { Console, Effect } from "effect";
 import { formatWithOptions } from "node:util";
-import type { ProgressService } from "./types";
 
 export const makeProgressConsole = (
-  progress: ProgressService,
+  progressLog: (...args: ReadonlyArray<unknown>) => Effect.Effect<void, never, never>,
   outerConsole: Console.Console,
 ): Console.Console => {
-  const log = (...args: ReadonlyArray<unknown>) => progress.log(...args);
+  const log = (...args: ReadonlyArray<unknown>) => progressLog(...args);
   const unsafeLog = (...args: ReadonlyArray<unknown>) => {
-    Effect.runFork(progress.log(...args));
+    Effect.runFork(progressLog(...args));
   };
 
   const delegate = (effect: Effect.Effect<void, never, never>) => effect;

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from "./api";
-export * from "./runtime";
+export * from "./colors";
+export { Progress } from "./runtime";
+export * from "./terminal";
 export * from "./types";

package/src/renderer.ts

@@ -1,49 +1,60 @@
-import { Effect, Ref } from "effect";
-import chalk from "chalk";
-import type { ProgressBarConfigShape } from "./types";
+import { Effect, Ref, Schema } from "effect";
+import {
+  type CompiledProgressBarColors,
+  compileProgressBarColors,
+  ProgressBarColorsSchema,
+} from "./colors";
+import type { ProgressTerminalService } from "./terminal";
+import type { ProgressBarConfigShape, RendererConfigShape } from "./types";
 import { DeterminateTaskUnits, TaskId, TaskSnapshot } from "./types";
 
 const HIDE_CURSOR = "\x1b[?25l";
 const SHOW_CURSOR = "\x1b[?25h";
 const CLEAR_LINE = "\x1b[2K";
 const MOVE_UP_ONE = "\x1b[1A";
-const RENDER_INTERVAL = "80 millis";
+const encodeProgressBarColorsKey = Schema.encodeSync(Schema.parseJson(ProgressBarColorsSchema));
 
-const renderDeterminate = (units: DeterminateTaskUnits, config: ProgressBarConfigShape): string => {
+const renderDeterminate = (
+  units: DeterminateTaskUnits,
+  progressbar: ProgressBarConfigShape,
+  colors: CompiledProgressBarColors,
+): string => {
   const safeTotal = units.total <= 0 ? 1 : units.total;
   const ratio = Math.min(1, Math.max(0, units.completed / safeTotal));
-  const filled = Math.round(ratio * config.barWidth);
-  const bar = `${chalk.cyan(config.fillChar.repeat(filled))}${chalk.dim(config.emptyChar.repeat(config.barWidth - filled))}`;
+  const filled = Math.round(ratio * progressbar.barWidth);
+  const bar = `${colors.fill(progressbar.fillChar.repeat(filled))}${colors.empty(progressbar.emptyChar.repeat(progressbar.barWidth - filled))}`;
   const percent = String(Math.round(ratio * 100)).padStart(3, " ");
-  return `${chalk.dim(config.leftBracket)}${bar}${chalk.dim(config.rightBracket)} ${units.completed}/${units.total} ${chalk.bold(percent + "%")}`;
+  return `${colors.brackets(progressbar.leftBracket)}${bar}${colors.brackets(progressbar.rightBracket)} ${units.completed}/${units.total} ${colors.percent(percent + "%")}`;
 };
 
 const buildTaskLine = (
   snapshot: TaskSnapshot,
   depth: number,
   tick: number,
-  config: ProgressBarConfigShape,
+  colors: CompiledProgressBarColors,
 ): string => {
+  const progressbar = snapshot.progressbar;
   const prefix = `${"  ".repeat(depth)}- ${snapshot.description}: `;
 
   if (snapshot.status === "failed") {
-    return `${prefix}${chalk.red("[failed]")}`;
+    return `${prefix}${colors.failed("[failed]")}`;
   }
 
   if (snapshot.status === "done") {
     if (snapshot.units._tag === "DeterminateTaskUnits") {
-      return `${prefix}${chalk.green("[done]")} ${snapshot.units.completed}/${snapshot.units.total}`;
+      return `${prefix}${colors.done("[done]")} ${snapshot.units.completed}/${snapshot.units.total}`;
     }
-    return `${prefix}${chalk.green("[done]")}`;
+    return `${prefix}${colors.done("[done]")}`;
   }
 
   if (snapshot.units._tag === "DeterminateTaskUnits") {
-    return prefix + renderDeterminate(snapshot.units, config);
+    return prefix + renderDeterminate(snapshot.units, progressbar, colors);
   }
 
-  const frames = config.spinnerFrames;
+  const frames = progressbar.spinnerFrames;
   const frameIndex = (snapshot.units.spinnerFrame + tick) % frames.length;
-  return `${prefix}${chalk.yellow(frames[frameIndex])}`;
+  const frame = frames[frameIndex] ?? frames[0]!;
+  return `${prefix}${colors.spinner(frame)}`;
 };
 
 const orderTasksForRender = (
@@ -74,28 +85,72 @@ export const runProgressServiceRenderer = (
   logsRef: Ref.Ref<ReadonlyArray<string>>,
   pendingLogsRef: Ref.Ref<ReadonlyArray<string>>,
   dirtyRef: Ref.Ref<boolean>,
-  config: ProgressBarConfigShape,
+  terminal: ProgressTerminalService,
+  isTTY: boolean,
+  rendererConfig: RendererConfigShape,
   maxRetainedLogLines: number,
 ) => {
-  const isTTY = config.isTTY;
   const retainLogHistory = maxRetainedLogLines > 0;
+  const colorCache = new Map<string, CompiledProgressBarColors>();
   let previousLineCount = 0;
-  let previousTaskLineCount = 0;
   let nonTTYTaskSignatureById = new Map<number, string>();
   let tick = 0;
-  let teardownInput: (() => void) | undefined;
+  let rendererActive = false;
+  let sessionActive = false;
+
+  const getCompiledColors = (progressbar: ProgressBarConfigShape): CompiledProgressBarColors => {
+    const key = encodeProgressBarColorsKey(progressbar.colors);
+    const cached = colorCache.get(key);
+    if (cached) {
+      return cached;
+    }
 
-  const clearTTYLines = (lineCount: number) => {
-    if (lineCount <= 0) {
+    const compiled = compileProgressBarColors(progressbar.colors);
+    colorCache.set(key, compiled);
+    return compiled;
+  };
+
+  const clipTTYFrameLines = (lines: ReadonlyArray<string>) =>
+    Effect.gen(function* () {
+      const terminalRows = yield* terminal.stderrRows;
+      if (terminalRows === undefined) {
+        return lines;
+      }
+
+      const visibleLineLimit = Math.max(1, terminalRows - 1);
+      if (lines.length <= visibleLineLimit) {
+        return lines;
+      }
+
+      if (visibleLineLimit === 1) {
+        return [`... ${lines.length} lines hidden`];
+      }
+
+      const hiddenLineCount = lines.length - visibleLineLimit + 1;
+      return [
+        `... ${hiddenLineCount} lines hidden (showing latest lines)`,
+        ...lines.slice(lines.length - (visibleLineLimit - 1)),
+      ];
+    });
+
+  const startTTYSession = Effect.gen(function* () {
+    if (!isTTY || sessionActive) {
       return;
     }
 
-    let output = "\r" + CLEAR_LINE;
-    for (let i = 1; i < lineCount; i++) {
-      output += MOVE_UP_ONE + CLEAR_LINE;
+    yield* terminal.writeStderr(HIDE_CURSOR);
+    sessionActive = true;
+  });
+
+  const stopTTYSession = Effect.gen(function* () {
+    if (!isTTY || !sessionActive) {
+      return;
     }
-    process.stderr.write(output + "\r");
-  };
+
+    yield* terminal.writeStderr("\n" + SHOW_CURSOR);
+    previousLineCount = 0;
+    sessionActive = false;
+  });
 
   const renderNonTTYTaskUpdates = (
     ordered: ReadonlyArray<{ snapshot: TaskSnapshot; depth: number }>,
@@ -103,7 +158,7 @@ export const runProgressServiceRenderer = (
   ) => {
     const nextTaskSignatureById = new Map<number, string>();
     const changedTaskLines: Array<string> = [];
-    const nonTtyUpdateStep = Math.max(1, Math.floor(config.nonTtyUpdateStep));
+    const nonTtyUpdateStep = Math.max(1, Math.floor(rendererConfig.nonTtyUpdateStep));
 
     for (let i = 0; i < ordered.length; i++) {
       const taskId = ordered[i]!.snapshot.id as number;
@@ -120,11 +175,13 @@ export const runProgressServiceRenderer = (
       }
     }
 
-    if (changedTaskLines.length > 0) {
-      process.stderr.write(changedTaskLines.join("\n") + "\n");
-    }
+    return Effect.gen(function* () {
+      if (changedTaskLines.length > 0) {
+        yield* terminal.writeStderr(changedTaskLines.join("\n") + "\n");
+      }
 
-    nonTTYTaskSignatureById = nextTaskSignatureById;
+      nonTTYTaskSignatureById = nextTaskSignatureById;
+    });
   };
 
   const renderFrame = (mode: "tick" | "final") =>
@@ -137,95 +194,102 @@ export const runProgressServiceRenderer = (
       const frameTick = mode === "final" ? tick + 1 : tick;
       const taskLines = ordered.map(({ snapshot, depth }) => {
         const lineTick = isTTY ? frameTick : 0;
-        return buildTaskLine(snapshot, depth, lineTick, config);
+        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.progressbar));
       });
 
       if (isTTY) {
+        let frame = "";
+
+        // 1. Cursor reset — move up and clear previous frame lines
+        if (previousLineCount > 0) {
+          frame += "\r" + CLEAR_LINE;
+          for (let i = 1; i < previousLineCount; i++) {
+            frame += MOVE_UP_ONE + CLEAR_LINE;
+          }
+        }
+
         if (retainLogHistory) {
           const historyLogs = yield* Ref.get(logsRef);
-          const lines = [...historyLogs, ...taskLines];
-          clearTTYLines(previousLineCount);
+          const lines = yield* clipTTYFrameLines([...historyLogs, ...taskLines]);
           if (lines.length > 0) {
-            process.stderr.write(lines.join("\n"));
+            frame += lines.join("\n");
           }
           previousLineCount = lines.length;
-          return;
+        } else {
+          // 2. Logs (scroll above the task block)
+          if (drainedLogs.length > 0) {
+            frame += drainedLogs.join("\n") + "\n";
+          }
+          // 3. Task lines
+          if (taskLines.length > 0) {
+            frame += taskLines.join("\n");
+          }
+          previousLineCount = taskLines.length;
         }
 
-        clearTTYLines(previousTaskLineCount);
-        if (drainedLogs.length > 0) {
-          process.stderr.write(drainedLogs.join("\n") + "\n");
-        }
-        if (taskLines.length > 0) {
-          process.stderr.write(taskLines.join("\n"));
+        // 4. Single atomic write
+        if (frame) {
+          yield* terminal.writeStderr(frame);
         }
-        previousTaskLineCount = taskLines.length;
         return;
       }
 
       if (drainedLogs.length > 0) {
-        process.stderr.write(drainedLogs.join("\n") + "\n");
+        yield* terminal.writeStderr(drainedLogs.join("\n") + "\n");
       }
-      renderNonTTYTaskUpdates(ordered, taskLines);
+      yield* renderNonTTYTaskUpdates(ordered, taskLines);
     });
 
-  return Effect.gen(function* () {
+  const renderLoop = Effect.gen(function* () {
+    rendererActive = true;
     if (isTTY) {
-      process.stderr.write(HIDE_CURSOR);
-
-      if (config.disableUserInput && process.stdin.isTTY) {
-        const stdin = process.stdin;
-        const wasRaw = Boolean(stdin.isRaw);
-        stdin.resume();
-        stdin.setRawMode?.(true);
-
-        const onData = (chunk: Buffer) => {
-          if (chunk.length === 1 && chunk[0] === 3) {
-            process.kill(process.pid, "SIGINT");
-          }
-        };
-
-        stdin.on("data", onData);
-
-        teardownInput = () => {
-          try {
-            stdin.off("data", onData);
-            stdin.setRawMode?.(wasRaw);
-            stdin.pause();
-          } catch {
-            // Best effort terminal restoration.
-          }
-        };
-      }
+      yield* startTTYSession;
     }
 
     while (true) {
       const dirty = yield* Ref.getAndSet(dirtyRef, false);
-      const hasActiveSpinners = yield* Ref.get(tasksRef).pipe(
-        Effect.map((tasks) =>
-          Array.from(tasks.values()).some(
-            (task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits",
-          ),
-        ),
+      const tasks = Array.from((yield* Ref.get(tasksRef)).values()).filter(
+        (task) => !(task.transient && task.status !== "running"),
+      );
+      const hasActiveSpinners = tasks.some(
+        (task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits",
       );
+      const hasPendingLogs = (yield* Ref.get(pendingLogsRef)).length > 0;
 
-      if (dirty || hasActiveSpinners) {
+      if (isTTY) {
+        if (dirty || hasActiveSpinners || hasPendingLogs) {
+          yield* renderFrame("tick");
+        }
+      } else if (dirty || hasActiveSpinners) {
         yield* renderFrame("tick");
       }
 
       tick += 1;
-      yield* Effect.sleep(RENDER_INTERVAL);
+      yield* Effect.sleep(Math.max(1, Math.floor(rendererConfig.renderIntervalMillis)));
     }
   }).pipe(
     Effect.ensuring(
       Effect.gen(function* () {
-        yield* renderFrame("final");
+        if (!rendererActive) {
+          return;
+        }
 
         if (isTTY) {
-          teardownInput?.();
-          process.stderr.write("\n" + SHOW_CURSOR);
+          if (sessionActive) {
+            yield* renderFrame("final");
+            yield* stopTTYSession;
+          }
+          return;
         }
+
+        yield* renderFrame("final");
       }),
     ),
   );
+
+  if (isTTY && rendererConfig.disableUserInput) {
+    return terminal.withRawInputCapture(renderLoop);
+  }
+
+  return renderLoop;
 };

package/src/runtime.ts

@@ -1,19 +1,40 @@
-import { Effect, Exit, FiberRef, Option, Ref } from "effect";
+import { Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
+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 {
+  decodeProgressBarConfigSync,
+  decodeRendererConfigSync,
   defaultProgressBarConfig,
+  defaultRendererConfig,
   DeterminateTaskUnits,
   IndeterminateTaskUnits,
-  Progress,
   ProgressBarConfig,
+  RendererConfig,
+  Task,
   TaskId,
   TaskSnapshot,
 } from "./types";
 import { inferTotal } from "./utils";
 
-const DIRTY_DEBOUNCE_INTERVAL = "10 millis";
+const mergeConfig = <T extends Record<PropertyKey, any>>(
+  base: T,
+  override: PartialDeep<T> | undefined,
+): T =>
+  mergeWith(
+    structuredClone(base),
+    (override ?? {}) as Record<PropertyKey, any>,
+    (_targetValue, sourceValue) => {
+      if (Array.isArray(sourceValue)) {
+        return sourceValue;
+      }
+      return undefined;
+    },
+  ) as T;
 
 const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): TaskSnapshot => {
   const currentUnits = snapshot.units;
@@ -54,49 +75,53 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     status: snapshot.status,
     transient: options.transient ?? snapshot.transient,
     units,
+    progressbar: snapshot.progressbar,
   });
 };
 
-export const makeProgressService = Effect.gen(function* () {
-  const configOption = yield* Effect.serviceOption(ProgressBarConfig);
-  const config = Option.getOrElse(configOption, () => defaultProgressBarConfig);
-  const maxRetainedLogLines = Math.max(0, Math.floor(config.maxLogLines ?? 0));
+const makeProgressService = Effect.gen(function* () {
+  const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
+  const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
+
+  const rendererConfig = decodeRendererConfigSync(
+    mergeConfig(
+      defaultRendererConfig,
+      Option.isSome(rendererConfigOption) ? rendererConfigOption.value : undefined,
+    ),
+  );
+  const progressBarConfig = decodeProgressBarConfigSync(
+    mergeConfig(
+      defaultProgressBarConfig,
+      Option.isSome(progressBarConfigOption) ? progressBarConfigOption.value : undefined,
+    ),
+  );
+  const terminal = yield* ProgressTerminal;
+  const isTTY = yield* terminal.isTTY;
+  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 logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const dirtyRef = yield* Ref.make(true);
-  const dirtyScheduledRef = yield* Ref.make(false);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
+  const scope = yield* Effect.scope;
 
-  yield* Effect.forkScoped(
+  yield* Effect.forkIn(
     runProgressServiceRenderer(
       tasksRef,
       logsRef,
       pendingLogsRef,
       dirtyRef,
-      config,
+      terminal,
+      isTTY,
+      rendererConfig,
       maxRetainedLogLines,
     ),
+    scope,
   );
 
-  const markDirty = Effect.gen(function* () {
-    const shouldSchedule = yield* Ref.modify(dirtyScheduledRef, (scheduled) =>
-      scheduled ? [false, true] : [true, true],
-    );
-
-    if (!shouldSchedule) {
-      return;
-    }
-
-    yield* Effect.forkDaemon(
-      Effect.sleep(DIRTY_DEBOUNCE_INTERVAL).pipe(
-        Effect.zipRight(Ref.set(dirtyRef, true)),
-        Effect.ensuring(Ref.set(dirtyScheduledRef, false)),
-      ),
-    );
-  });
+  const markDirty = Ref.set(dirtyRef, true);
 
   const addTask = (options: AddTaskOptions) =>
     Effect.gen(function* () {
@@ -109,6 +134,12 @@ export 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 resolvedProgressBarConfig = decodeProgressBarConfigSync(
+        mergeConfig(inheritedProgressBarConfig, options.progressbar),
+      );
 
       const snapshot = new TaskSnapshot({
         id: taskId,
@@ -117,6 +148,7 @@ export const makeProgressService = Effect.gen(function* () {
         status: "running",
         transient: options.transient ?? false,
         units,
+        progressbar: resolvedProgressBarConfig,
       });
 
       yield* Ref.update(tasksRef, (tasks) => {
@@ -156,8 +188,7 @@ export const makeProgressService = Effect.gen(function* () {
               total: snapshot.units.total,
             })
           : new IndeterminateTaskUnits({
-              spinnerFrame:
-                (snapshot.units.spinnerFrame + amount) % Math.max(1, config.spinnerFrames.length),
+              spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount),
             });
 
       next.set(
@@ -169,6 +200,7 @@ export const makeProgressService = Effect.gen(function* () {
           status: snapshot.status,
           transient: snapshot.transient,
           units,
+          progressbar: snapshot.progressbar,
         }),
       );
 
@@ -203,6 +235,7 @@ export const makeProgressService = Effect.gen(function* () {
                   total: snapshot.units.total,
                 })
               : snapshot.units,
+          progressbar: snapshot.progressbar,
         }),
       );
       return next;
@@ -230,12 +263,13 @@ export const makeProgressService = Effect.gen(function* () {
           status: "failed",
           transient: snapshot.transient,
           units: snapshot.units,
+          progressbar: snapshot.progressbar,
         }),
       );
       return next;
     }).pipe(Effect.zipRight(markDirty));
 
-  const log = (...args: ReadonlyArray<unknown>) =>
+  const appendLog = (args: ReadonlyArray<unknown>) =>
     Effect.gen(function* () {
       if (args.length === 0) {
         return;
@@ -243,7 +277,7 @@ export const makeProgressService = Effect.gen(function* () {
 
       const message = formatWithOptions(
         {
-          colors: config.isTTY,
+          colors: isTTY,
           depth: 6,
         },
         ...args,
@@ -263,6 +297,11 @@ export const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
+  const log = (...args: ReadonlyArray<unknown>) =>
+    Effect.gen(function* () {
+      yield* appendLog(args);
+    });
+
   const getTask = (taskId: TaskId) =>
     Ref.get(tasksRef).pipe(Effect.map((tasks) => Option.fromNullable(tasks.get(taskId))));
 
@@ -270,6 +309,7 @@ export const makeProgressService = Effect.gen(function* () {
 
   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);
@@ -281,7 +321,14 @@ export const makeProgressService = Effect.gen(function* () {
       });
 
       const exit = yield* Effect.exit(
-        Effect.locally(effect(taskId), currentParentRef, Option.some(taskId)),
+        Effect.locally(
+          Effect.withConsole(
+            Effect.provideService(effect, Task, taskId),
+            makeProgressConsole(log, outerConsole),
+          ),
+          currentParentRef,
+          Option.some(taskId),
+        ),
       );
 
       if (Exit.isSuccess(exit)) {
@@ -302,15 +349,17 @@ export const makeProgressService = Effect.gen(function* () {
         description: options.description,
         total: options.total ?? inferTotal(iterable),
         transient: options.transient,
+        progressbar: options.progressbar,
       },
-      (taskId) => {
-        return Effect.forEach(iterable, (item, index) =>
+      Effect.gen(function* () {
+        const taskId = yield* Task;
+        return yield* Effect.forEach(iterable, (item, index) =>
           Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
         );
-      },
+      }),
     );
 
-  return Progress.of({
+  const service: ProgressService = {
     addTask,
     updateTask,
     advanceTask,
@@ -321,5 +370,27 @@ export const makeProgressService = Effect.gen(function* () {
     listTasks,
     withTask,
     trackIterable,
-  });
+  };
+
+  return Progress.of(service);
 });
+
+export class Progress extends Context.Tag("stromseng.dev/Progress")<Progress, ProgressService>() {
+  static readonly Default = Layer.scoped(Progress, makeProgressService);
+}
+
+export const provideProgressService = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+  Effect.gen(function* () {
+    const existing = yield* Effect.serviceOption(Progress);
+    if (Option.isSome(existing)) {
+      return yield* Effect.provideService(effect, Progress, existing.value);
+    }
+
+    const existingTerminal = yield* Effect.serviceOption(ProgressTerminal);
+    if (Option.isSome(existingTerminal)) {
+      return yield* Effect.scoped(effect.pipe(Effect.provide(Progress.Default)));
+    }
+
+    const defaultLayers = Layer.provide(Progress.Default, ProgressTerminal.Default);
+    return yield* Effect.scoped(effect.pipe(Effect.provide(defaultLayers)));
+  });

package/src/terminal.ts

@@ -0,0 +1,61 @@
+import { Context, Effect, Layer } from "effect";
+
+export 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>;
+}
+
+const withRawInputCapture: ProgressTerminalService["withRawInputCapture"] = (effect) =>
+  Effect.suspend(() => {
+    if (!process.stdin.isTTY) {
+      return effect;
+    }
+
+    const stdin = process.stdin;
+    const wasRaw = Boolean(stdin.isRaw);
+    const onData = (chunk: Buffer) => {
+      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 {
+            // Best effort terminal restoration.
+          }
+        }),
+    );
+  });
+
+export class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")<
+  ProgressTerminal,
+  ProgressTerminalService
+>() {
+  static readonly Default = Layer.succeed(ProgressTerminal, {
+    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,
+  } satisfies ProgressTerminalService);
+}

package/src/types.ts

@@ -1,39 +1,53 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
+import type { PartialDeep } from "type-fest";
+import { defaultProgressBarColors, ProgressBarColorsSchema } from "./colors";
 
-export const SPINNER_FRAMES = ["-", "\\", "|", "/"] as const;
-export const DEFAULT_PROGRESS_BAR_WIDTH = 30;
+export const RendererConfigSchema = Schema.Struct({
+  disableUserInput: Schema.Boolean,
+  renderIntervalMillis: Schema.Number,
+  maxLogLines: Schema.optional(Schema.Number),
+  nonTtyUpdateStep: Schema.Number,
+});
+export type RendererConfigShape = typeof RendererConfigSchema.Type;
+export const decodeRendererConfigSync = Schema.decodeUnknownSync(RendererConfigSchema);
 
 export const ProgressBarConfigSchema = Schema.Struct({
-  isTTY: Schema.Boolean,
-  disableUserInput: Schema.Boolean,
   spinnerFrames: Schema.NonEmptyArray(Schema.String),
   barWidth: Schema.Number,
   fillChar: Schema.String,
   emptyChar: Schema.String,
   leftBracket: Schema.String,
   rightBracket: Schema.String,
-  maxLogLines: Schema.optional(Schema.Number),
-  nonTtyUpdateStep: Schema.Number,
+  colors: ProgressBarColorsSchema,
 });
-
 export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
+export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
 
-export const defaultProgressBarConfig: ProgressBarConfigShape = {
-  isTTY: Boolean(process.stderr.isTTY),
+export const defaultRendererConfig: RendererConfigShape = {
   disableUserInput: true,
-  spinnerFrames: SPINNER_FRAMES,
-  barWidth: DEFAULT_PROGRESS_BAR_WIDTH,
+  renderIntervalMillis: 50, // 20 FPS
+  maxLogLines: 0,
+  nonTtyUpdateStep: 5,
+};
+
+export const defaultProgressBarConfig: ProgressBarConfigShape = {
+  spinnerFrames: ["-", "\\", "|", "/"],
+  barWidth: 30,
   fillChar: "━",
   emptyChar: "─",
   leftBracket: "",
   rightBracket: "",
-  maxLogLines: 0,
-  nonTtyUpdateStep: 5,
+  colors: defaultProgressBarColors,
 };
 
+export class RendererConfig extends Context.Tag("stromseng.dev/RendererConfig")<
+  RendererConfig,
+  PartialDeep<RendererConfigShape>
+>() {}
+
 export class ProgressBarConfig extends Context.Tag("stromseng.dev/ProgressBarConfig")<
   ProgressBarConfig,
-  ProgressBarConfigShape
+  PartialDeep<ProgressBarConfigShape>
 >() {}
 
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
@@ -50,6 +64,7 @@ export interface AddTaskOptions {
   readonly total?: number;
   readonly transient?: boolean;
   readonly parentId?: TaskId;
+  readonly progressbar?: PartialDeep<ProgressBarConfigShape>;
 }
 
 export interface UpdateTaskOptions {
@@ -87,6 +102,7 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   status: TaskStatusSchema,
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
+  progressbar: ProgressBarConfigSchema,
 }) {}
 
 export interface ProgressService {
@@ -100,16 +116,16 @@ export interface ProgressService {
   readonly listTasks: Effect.Effect<ReadonlyArray<TaskSnapshot>>;
   readonly withTask: <A, E, R>(
     options: AddTaskOptions,
-    effect: (taskId: TaskId) => Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E, R>;
+    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, R>;
+  ) => Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Task>>;
 }
 
-export class Progress extends Context.Tag("stromseng.dev/Progress")<Progress, ProgressService>() {}
+export class Task extends Context.Tag("stromseng.dev/Task")<Task, TaskId>() {}
 
 export class TaskAddedEvent extends Schema.TaggedClass<TaskAddedEvent>()("TaskAdded", {
   taskId: TaskIdSchema,