effective-progress 0.1.3 → 0.2.1

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!
@@ -82,6 +82,7 @@ Effect.runPromise(program);
 - `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
 
@@ -119,6 +120,7 @@ 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: {
@@ -129,26 +131,50 @@ yield *
         },
       },
     },
-    () => Effect.sleep("1 second"),
   );
 ```
 
-For manual service usage, capture logs explicitly:
+## Terminal service and mocking
+
+`effective-progress` now exposes a `ProgressTerminal` service that controls terminal detection and I/O:
+
+- `isTTY`
+- `stderrRows`
+- `stderrColumns`
+- `writeStderr(text)`
+- `withRawInputCapture(effect)`
+
+You can provide a mock if you want to alter the behavior of terminal detection or if you want to capture the output for testing:
+
+```ts
+import { Effect } from "effect";
+import * as Progress from "effective-progress";
+
+const mockTerminal: Progress.ProgressTerminalService = {
+  isTTY: Effect.succeed(true),
+  stderrRows: Effect.succeed(40),
+  stderrColumns: Effect.succeed(120),
+  writeStderr: (_text) => Effect.void,
+  withRawInputCapture: (effect) => effect,
+};
+
+const program = Progress.withTask(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:
 
 ```ts
-const program = Progress.provide(
+const program = Progress.withTask(
   Effect.gen(function* () {
-    const progress = yield* Progress.Progress;
-
-    yield* progress.withTask({ description: "Manual task" }, () =>
-      progress.withCapturedLogs(
-        Effect.gen(function* () {
-          yield* Console.log("This log is rendered through progress output");
-          yield* Effect.sleep("1 second");
-        }),
-      ),
-    );
+    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.1.3",
+  "version": "0.2.1",
   "description": "Effect-first terminal progress bars with nested multibar support",
   "homepage": "https://github.com/stromseng/effective-progress#readme",
   "bugs": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "chalk": "^5.6.2",
-    "effect": "^3.19.16",
+    "effect": "^3.19.17",
     "es-toolkit": "^1.44.0",
     "type-fest": "^5.4.4"
   },

package/src/api.ts

@@ -1,8 +1,9 @@
-import { Effect, Option } from "effect";
+import { Effect } from "effect";
+import { dual } from "effect/Function";
 import type { Concurrency } from "effect/Types";
-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 {
@@ -22,7 +23,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 {
@@ -31,85 +32,113 @@ export interface ForEachExecutionOptions extends EffectExecutionOptions {
 
 export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
-export const provide = <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);
-    }
-
-    return yield* Effect.scoped(
-      Effect.gen(function* () {
-        const service = yield* makeProgressService;
-        return yield* Effect.provideService(effect, Progress, service);
-      }),
-    );
-  });
-
-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> =>
-  provide(
+export const withTask: {
+  <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(
-        {
-          description: options.description,
-          total: effects.length,
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        (taskId) =>
-          Effect.all(
-            effects.map((effect) =>
-              Effect.tap(progress.withCapturedLogs(effect), () => progress.advanceTask(taskId, 1)),
-            ),
-            {
-              concurrency: options.concurrency,
-              batching: options.batching,
-              discard: options.discard,
-              mode: options.mode,
-              concurrentFinalizers: options.concurrentFinalizers,
-            },
-          ),
-      );
+      return yield* progress.withTask(effect, options);
     }),
-  ) as AllReturn<Arg, O>;
+  ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>,
+);
 
-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>> =>
-  provide(
-    Effect.gen(function* () {
-      const progress = yield* Progress;
+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.withTask(
+          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,
+              },
+            );
+          }),
+          {
+            description: options.description,
+            total: effects.length,
+            transient: options.transient,
+            progressbar: options.progressbar,
+          },
+        );
+      }),
+    ) as AllReturn<Arg, O>,
+);
 
-      return yield* progress.withTask(
-        {
-          description: options.description,
-          total: options.total ?? inferTotal(iterable),
-          transient: options.transient,
-          progressbar: options.progressbar,
-        },
-        (taskId) =>
-          Effect.forEach(
-            iterable,
-            (item, index) =>
-              Effect.tap(progress.withCapturedLogs(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>>;
+  <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.withTask(
+          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,
+              },
+            );
+          }),
+          {
+            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/colors.ts

@@ -103,61 +103,11 @@ export const defaultProgressBarColors: ProgressBarColors = {
   failed: { kind: "named", value: "red" },
 };
 
-const applyModifier = (instance: ChalkInstance, modifier: StyleModifier): ChalkInstance => {
-  switch (modifier) {
-    case "bold":
-      return instance.bold;
-    case "dim":
-      return instance.dim;
-    case "italic":
-      return instance.italic;
-    case "underline":
-      return instance.underline;
-    case "inverse":
-      return instance.inverse;
-    case "hidden":
-      return instance.hidden;
-    case "strikethrough":
-      return instance.strikethrough;
-  }
-};
+const applyModifier = (instance: ChalkInstance, modifier: StyleModifier): ChalkInstance =>
+  instance[modifier] as ChalkInstance;
 
-const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance => {
-  switch (color) {
-    case "black":
-      return instance.black;
-    case "red":
-      return instance.red;
-    case "green":
-      return instance.green;
-    case "yellow":
-      return instance.yellow;
-    case "blue":
-      return instance.blue;
-    case "magenta":
-      return instance.magenta;
-    case "cyan":
-      return instance.cyan;
-    case "white":
-      return instance.white;
-    case "blackBright":
-      return instance.blackBright;
-    case "redBright":
-      return instance.redBright;
-    case "greenBright":
-      return instance.greenBright;
-    case "yellowBright":
-      return instance.yellowBright;
-    case "blueBright":
-      return instance.blueBright;
-    case "magentaBright":
-      return instance.magentaBright;
-    case "cyanBright":
-      return instance.cyanBright;
-    case "whiteBright":
-      return instance.whiteBright;
-  }
-};
+const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance =>
+  instance[color] as ChalkInstance;
 
 const resolveBaseStyle = (style: ColorStyle): ChalkInstance => {
   switch (style.kind) {

package/src/index.ts

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

package/src/renderer.ts

@@ -4,6 +4,7 @@ import {
   compileProgressBarColors,
   ProgressBarColorsSchema,
 } from "./colors";
+import type { ProgressTerminalService } from "./terminal";
 import type { ProgressBarConfigShape, RendererConfigShape } from "./types";
 import { DeterminateTaskUnits, TaskId, TaskSnapshot } from "./types";
 
@@ -84,19 +85,18 @@ export const runProgressServiceRenderer = (
   logsRef: Ref.Ref<ReadonlyArray<string>>,
   pendingLogsRef: Ref.Ref<ReadonlyArray<string>>,
   dirtyRef: Ref.Ref<boolean>,
+  terminal: ProgressTerminalService,
+  isTTY: boolean,
   rendererConfig: RendererConfigShape,
   maxRetainedLogLines: number,
-  rendererLatch: Effect.Latch,
 ) => {
-  const isTTY = rendererConfig.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 rendererActive = false;
-  let teardownInput: (() => void) | undefined;
+  let sessionActive = false;
 
   const getCompiledColors = (progressbar: ProgressBarConfigShape): CompiledProgressBarColors => {
     const key = encodeProgressBarColorsKey(progressbar.colors);
@@ -110,17 +110,47 @@ export const runProgressServiceRenderer = (
     return compiled;
   };
 
-  const clearTTYLines = (lineCount: number) => {
-    if (lineCount <= 0) {
+  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 }>,
@@ -145,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") =>
@@ -166,78 +198,69 @@ export const runProgressServiceRenderer = (
       });
 
       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");
+        // 4. Single atomic write
+        if (frame) {
+          yield* terminal.writeStderr(frame);
         }
-        if (taskLines.length > 0) {
-          process.stderr.write(taskLines.join("\n"));
-        }
-        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* () {
-    yield* rendererLatch.await;
+  const renderLoop = Effect.gen(function* () {
     rendererActive = true;
-
     if (isTTY) {
-      process.stderr.write(HIDE_CURSOR);
-
-      if (rendererConfig.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");
       }
 
@@ -251,13 +274,22 @@ export const runProgressServiceRenderer = (
           return;
         }
 
-        yield* renderFrame("final");
-
         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,9 +1,11 @@
-import { Console, Effect, Exit, FiberRef, Option, Ref } from "effect";
+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 {
   decodeProgressBarConfigSync,
@@ -12,16 +14,14 @@ import {
   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,
@@ -80,7 +80,7 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
   });
 };
 
-export const makeProgressService = Effect.gen(function* () {
+const makeProgressService = Effect.gen(function* () {
   const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
   const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
 
@@ -96,6 +96,8 @@ export const makeProgressService = Effect.gen(function* () {
       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);
@@ -103,9 +105,6 @@ export const makeProgressService = Effect.gen(function* () {
   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 rendererStartedRef = yield* Ref.make(false);
-  const rendererLatch = yield* Effect.makeLatch(false);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
   const scope = yield* Effect.scope;
 
@@ -115,29 +114,15 @@ export const makeProgressService = Effect.gen(function* () {
       logsRef,
       pendingLogsRef,
       dirtyRef,
+      terminal,
+      isTTY,
       rendererConfig,
       maxRetainedLogLines,
-      rendererLatch,
     ),
     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* () {
@@ -151,18 +136,11 @@ export const makeProgressService = Effect.gen(function* () {
           ? 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 parentSnapshot = Option.isSome(parentId) ? tasks.get(parentId.value) : undefined;
       const inheritedProgressBarConfig = parentSnapshot?.progressbar ?? progressBarConfig;
       const resolvedProgressBarConfig = decodeProgressBarConfigSync(
         mergeConfig(inheritedProgressBarConfig, options.progressbar),
       );
-      const shouldOpenRenderer = yield* Ref.modify(rendererStartedRef, (started) =>
-        started ? [false, true] : [true, true],
-      );
-      if (shouldOpenRenderer) {
-        yield* rendererLatch.open;
-      }
 
       const snapshot = new TaskSnapshot({
         id: taskId,
@@ -292,22 +270,16 @@ export const makeProgressService = Effect.gen(function* () {
       return next;
     }).pipe(Effect.zipRight(markDirty));
 
-  const log = (...args: ReadonlyArray<unknown>) =>
+  const appendLog = (args: ReadonlyArray<unknown>) =>
     Effect.gen(function* () {
       if (args.length === 0) {
         return;
       }
 
-      const shouldOpenRenderer = yield* Ref.modify(rendererStartedRef, (started) =>
-        started ? [false, true] : [true, true],
-      );
-      if (shouldOpenRenderer) {
-        yield* rendererLatch.open;
-      }
-
+      // TODO: Might wanna replace this or make it configurable. Look for other options.
       const message = formatWithOptions(
         {
-          colors: rendererConfig.isTTY,
+          colors: isTTY,
           depth: 6,
         },
         ...args,
@@ -327,58 +299,66 @@ export const makeProgressService = Effect.gen(function* () {
       yield* markDirty;
     });
 
-  const withCapturedLogs: ProgressService["withCapturedLogs"] = (effect) =>
-    Effect.gen(function* () {
-      const outerConsole = yield* Console.consoleWith((console) => Effect.succeed(console));
-      return yield* Effect.withConsole(effect, makeProgressConsole(log, outerConsole));
-    });
+  const log = (...args: ReadonlyArray<unknown>) => appendLog(args);
 
   const getTask = (taskId: TaskId) =>
     Ref.get(tasksRef).pipe(Effect.map((tasks) => Option.fromNullable(tasks.get(taskId))));
 
   const listTasks = Ref.get(tasksRef).pipe(Effect.map((tasks) => Array.from(tasks.values())));
 
-  const withTask: ProgressService["withTask"] = (options, effect) =>
-    Effect.gen(function* () {
-      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 withTask: ProgressService["withTask"] = 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(effect(taskId), currentParentRef, Option.some(taskId)),
-      );
+        const exit = yield* Effect.exit(
+          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);
-      }
+        if (Exit.isSuccess(exit)) {
+          yield* completeTask(taskId);
+        } else {
+          yield* failTask(taskId);
+        }
 
-      return yield* Exit.match(exit, {
-        onFailure: Effect.failCause,
-        onSuccess: Effect.succeed,
-      });
-    });
+        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,
       },
-      (taskId) => {
-        return Effect.forEach(iterable, (item, index) =>
-          Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
-        );
-      },
     );
 
   const service: ProgressService = {
@@ -388,7 +368,6 @@ export const makeProgressService = Effect.gen(function* () {
     completeTask,
     failTask,
     log,
-    withCapturedLogs,
     getTask,
     listTasks,
     withTask,
@@ -397,3 +376,23 @@ export const makeProgressService = Effect.gen(function* () {
 
   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

@@ -3,7 +3,6 @@ import type { PartialDeep } from "type-fest";
 import { defaultProgressBarColors, ProgressBarColorsSchema } from "./colors";
 
 export const RendererConfigSchema = Schema.Struct({
-  isTTY: Schema.Boolean,
   disableUserInput: Schema.Boolean,
   renderIntervalMillis: Schema.Number,
   maxLogLines: Schema.optional(Schema.Number),
@@ -25,7 +24,6 @@ export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
 export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
 
 export const defaultRendererConfig: RendererConfigShape = {
-  isTTY: Boolean(process.stderr.isTTY),
   disableUserInput: true,
   renderIntervalMillis: 50, // 20 FPS
   maxLogLines: 0,
@@ -114,21 +112,25 @@ export interface ProgressService {
   readonly completeTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly failTask: (taskId: TaskId) => Effect.Effect<void>;
   readonly log: (...args: ReadonlyArray<unknown>) => Effect.Effect<void>;
-  readonly withCapturedLogs: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
   readonly getTask: (taskId: TaskId) => Effect.Effect<Option.Option<TaskSnapshot>>;
   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>;
+  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>>;
+  };
   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,