effective-progress 0.2.3 → 0.3.0

package/README.md

@@ -105,10 +105,6 @@ const configured = program.pipe(
   }),
   Effect.provideService(Progress.ProgressBarConfig, {
     barWidth: 36,
-    colors: {
-      fill: { kind: "hex", value: "#00b894" },
-      spinner: { kind: "ansi256", value: 214 },
-    },
   }),
 );
 
@@ -124,9 +120,6 @@ yield *
     progressbar: {
       barWidth: 20,
       spinnerFrames: [".", "o", "O", "0"],
-      colors: {
-        spinner: { kind: "named", value: "magentaBright" },
-      },
     },
   });
 ```
@@ -177,38 +170,64 @@ const program = Progress.task(
 
 ## Progress bar colors
 
-`progressbar.colors` is configured with typed color tokens that are validated by Effect Schema.
+Colors are configured through the `Colorizer` service. You can set a global colorizer, or provide per-task overrides using `Effect.provideService`.
+
+### Global colorizer
+
+Provide a custom `Colorizer` at the top level to change colors for all tasks:
 
 ```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"] },
-  },
-}
+import chalk from "chalk";
+import { Effect } from "effect";
+import * as Progress from "effective-progress";
+
+const program = Progress.task(myEffect, { description: "Work" }).pipe(
+  Effect.provideService(
+    Progress.Colorizer,
+    Progress.Colorizer.of({
+      fill: chalk.hex("#00b894"),
+      empty: chalk.white.dim,
+      brackets: chalk.rgb(180, 190, 210),
+      percent: chalk.whiteBright.bold,
+      spinner: chalk.ansi256(214),
+      done: chalk.greenBright,
+      failed: chalk.redBright.bold,
+    }),
+  ),
+);
 ```
 
-Supported color styles:
+### Per-task colorizer
+
+Wrap any effect with `Effect.provideService(Colorizer, ...)` to override colors for that task (and its children). The colorizer is captured at task-creation time, so each task can have its own colors:
 
-- `named` (for example `cyan`, `greenBright`)
-- `hex` (for example `#00b894`)
-- `rgb` (for example `{ r: 0, g: 184, b: 148 }`)
-- `ansi256` (for example `214`)
+```ts
+Progress.forEach(
+  ["fetch", "transform", "persist"],
+  (stage) => Effect.gen(function* () {
+    yield* Effect.sleep("500 millis");
+    return stage;
+  }),
+  { description: "Worker pipeline" },
+).pipe(
+  Effect.provideService(
+    Progress.Colorizer,
+    Progress.Colorizer.of({
+      fill: chalk.red,
+      empty: chalk.white.dim,
+      brackets: chalk.white.dim,
+      percent: chalk.white.bold,
+      spinner: chalk.magentaBright,
+      done: chalk.greenBright,
+      failed: chalk.redBright,
+    }),
+  ),
+);
+```
 
-Supported modifiers:
+Tasks inherit the colorizer from their parent task.
 
-- `bold`, `dim`, `italic`, `underline`, `inverse`, `hidden`, `strikethrough`
+Each `ColorizerService` slot (`fill`, `empty`, `brackets`, `percent`, `spinner`, `done`, `failed`) is a `(text: string) => string` function. Use any chalk style — named colors, hex, rgb, ansi256, and modifiers like `.bold` or `.dim` all work.
 
 ## Dependencies & package size
 

package/package.json

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

package/src/api.ts

@@ -1,11 +1,20 @@
-import { Effect, Exit } from "effect";
+import { Effect, Exit, Option } from "effect";
 import { dual } from "effect/Function";
 import type { Concurrency } from "effect/Types";
-import { Progress, provideProgressService } from "./runtime";
+import { Progress } from "./runtime";
 import { Task } from "./types";
 import type { AddTaskOptions, TrackOptions } from "./types";
 import { inferTotal } from "./utils";
 
+const provideProgress = <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.pipe(Effect.provide(Progress.Default)));
+  });
+
 export interface EffectExecutionOptions {
   readonly concurrency?: Concurrency;
   readonly batching?: boolean | "inherit";
@@ -19,7 +28,9 @@ export interface EffectAllExecutionOptions extends EffectExecutionOptions {
 
 export type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
 export type AllReturn<
-  Arg extends ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>,
+  Arg extends
+    | ReadonlyArray<Effect.Effect<any, any, any>>
+    | Record<string, Effect.Effect<any, any, any>>,
   O extends EffectAllExecutionOptions,
 > = [
   [Arg] extends [ReadonlyArray<Effect.Effect<any, any, any>>]
@@ -48,7 +59,7 @@ export const task: {
 } = dual(
   2,
   <A, E, R>(effect: Effect.Effect<A, E, R>, options: AddTaskOptions) =>
-    provideProgressService(
+    provideProgress(
       Effect.gen(function* () {
         const progress = yield* Progress;
         return yield* progress.withTask(effect, options);
@@ -56,7 +67,9 @@ export const task: {
     ) as Effect.Effect<A, E, Exclude<R, Progress | Task>>,
 );
 
-type AllArg = ReadonlyArray<Effect.Effect<any, any, any>> | Record<string, Effect.Effect<any, any, any>>;
+type AllArg =
+  | ReadonlyArray<Effect.Effect<any, any, any>>
+  | Record<string, Effect.Effect<any, any, any>>;
 
 const wrapEffects = (
   effects: AllArg,
@@ -83,7 +96,7 @@ export const all: {
     effects: Arg,
     options: Omit<TrackOptions, "total"> & O,
   ) =>
-    provideProgressService(
+    provideProgress(
       Effect.gen(function* () {
         const progress = yield* Progress;
         return yield* progress.runTask(
@@ -143,7 +156,7 @@ export const forEach: {
     f: (item: A, index: number) => Effect.Effect<B, E, R>,
     options: ForEachOptions,
   ) =>
-    provideProgressService(
+    provideProgress(
       Effect.gen(function* () {
         const progress = yield* Progress;
 

package/src/colors.ts

@@ -1,141 +1,7 @@
 import chalk from "chalk";
-import type { ChalkInstance } from "chalk";
-import { Schema } from "effect";
+import { Context, Layer } 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];
-
-const applyNamedColor = (instance: ChalkInstance, color: NamedColor): ChalkInstance =>
-  instance[color];
-
-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 {
+export interface ColorizerService {
   readonly fill: (text: string) => string;
   readonly empty: (text: string) => string;
   readonly brackets: (text: string) => string;
@@ -145,12 +11,20 @@ export interface CompiledProgressBarColors {
   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),
-});
+export class Colorizer extends Context.Tag("stromseng.dev/effective-progress/Colorizer")<
+  Colorizer,
+  ColorizerService
+>() {
+  static readonly Default = Layer.succeed(
+    Colorizer,
+    Colorizer.of({
+      fill: chalk.blue,
+      empty: chalk.white.dim,
+      brackets: chalk.white.dim,
+      percent: chalk.white.bold,
+      spinner: chalk.yellow,
+      done: chalk.green,
+      failed: chalk.red,
+    }),
+  );
+}

package/src/renderer.ts

@@ -1,9 +1,5 @@
-import { Effect, Ref, Schema } from "effect";
-import {
-  type CompiledProgressBarColors,
-  compileProgressBarColors,
-  ProgressBarColorsSchema,
-} from "./colors";
+import { Clock, Duration, Effect, Ref } from "effect";
+import { Colorizer, type ColorizerService } from "./colors";
 import type { ProgressTerminalService } from "./terminal";
 import type { ProgressBarConfigShape, RendererConfigShape, TaskStore } from "./types";
 import { DeterminateTaskUnits, TaskSnapshot } from "./types";
@@ -12,12 +8,11 @@ const HIDE_CURSOR = "\x1b[?25l";
 const SHOW_CURSOR = "\x1b[?25h";
 const CLEAR_LINE = "\x1b[2K";
 const MOVE_UP_ONE = "\x1b[1A";
-const encodeProgressBarColorsKey = Schema.encodeSync(Schema.parseJson(ProgressBarColorsSchema));
 
 const renderDeterminate = (
   units: DeterminateTaskUnits,
   progressbar: ProgressBarConfigShape,
-  colors: CompiledProgressBarColors,
+  colors: ColorizerService,
 ): string => {
   const safeTotal = units.total <= 0 ? 1 : units.total;
   const ratio = Math.min(1, Math.max(0, units.completed / safeTotal));
@@ -27,34 +22,45 @@ const renderDeterminate = (
   return `${colors.brackets(progressbar.leftBracket)}${bar}${colors.brackets(progressbar.rightBracket)} ${units.completed}/${units.total} ${colors.percent(percent + "%")}`;
 };
 
+const formatElapsed = (snapshot: TaskSnapshot, now: number): string => {
+  const elapsedMillis = (snapshot.completedAt ?? now) - snapshot.startedAt;
+  const duration =
+    snapshot.status === "running"
+      ? Duration.seconds(Math.floor(elapsedMillis / 1000))
+      : Duration.millis(elapsedMillis);
+  return ` (${Duration.format(duration)})`;
+};
+
 const buildTaskLine = (
   snapshot: TaskSnapshot,
   depth: number,
   tick: number,
-  colors: CompiledProgressBarColors,
+  colors: ColorizerService,
+  now: number,
 ): string => {
   const progressbar = snapshot.config;
   const prefix = `${"  ".repeat(depth)}- ${snapshot.description}: `;
+  const elapsed = formatElapsed(snapshot, now);
 
   if (snapshot.status === "failed") {
-    return `${prefix}${colors.failed("[failed]")}`;
+    return `${prefix}${colors.failed("[failed]")}${elapsed}`;
   }
 
   if (snapshot.status === "done") {
     if (snapshot.units._tag === "DeterminateTaskUnits") {
-      return `${prefix}${colors.done("[done]")} ${snapshot.units.completed}/${snapshot.units.total}`;
+      return `${prefix}${colors.done("[done]")} ${snapshot.units.completed}/${snapshot.units.total}${elapsed}`;
     }
-    return `${prefix}${colors.done("[done]")}`;
+    return `${prefix}${colors.done("[done]")}${elapsed}`;
   }
 
   if (snapshot.units._tag === "DeterminateTaskUnits") {
-    return prefix + renderDeterminate(snapshot.units, progressbar, colors);
+    return prefix + renderDeterminate(snapshot.units, progressbar, colors) + elapsed;
   }
 
   const frames = progressbar.spinnerFrames;
   const frameIndex = (snapshot.units.spinnerFrame + tick) % frames.length;
   const frame = frames[frameIndex] ?? frames[0]!;
-  return `${prefix}${colors.spinner(frame)}`;
+  return `${prefix}${colors.spinner(frame)}${elapsed}`;
 };
 
 export const runProgressServiceRenderer = (
@@ -66,209 +72,200 @@ export const runProgressServiceRenderer = (
   isTTY: boolean,
   rendererConfig: RendererConfigShape,
   maxRetainedLogLines: number,
-) => {
-  const retainLogHistory = maxRetainedLogLines > 0;
-  const colorCache = new Map<string, CompiledProgressBarColors>();
-  let previousLineCount = 0;
-  let nonTTYTaskSignatureById = new Map<number, string>();
-  let tick = 0;
-  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;
-    }
+) =>
+  Effect.gen(function* () {
+    const colorizer = yield* Colorizer;
+    const retainLogHistory = maxRetainedLogLines > 0;
+    let previousLineCount = 0;
+    let nonTTYTaskSignatureById = new Map<number, string>();
+    let tick = 0;
+    let rendererActive = false;
+    let sessionActive = false;
+
+    const clipTTYFrameLines = (lines: ReadonlyArray<string>) =>
+      Effect.gen(function* () {
+        const terminalRows = yield* terminal.stderrRows;
+        if (terminalRows === undefined) {
+          return lines;
+        }
 
-    const compiled = compileProgressBarColors(progressbar.colors);
-    colorCache.set(key, compiled);
-    return compiled;
-  };
+        const visibleLineLimit = Math.max(1, terminalRows - 1);
+        if (lines.length <= visibleLineLimit) {
+          return lines;
+        }
 
-  const clipTTYFrameLines = (lines: ReadonlyArray<string>) =>
-    Effect.gen(function* () {
-      const terminalRows = yield* terminal.stderrRows;
-      if (terminalRows === undefined) {
-        return lines;
-      }
+        if (visibleLineLimit === 1) {
+          return [`... ${lines.length} lines hidden`];
+        }
 
-      const visibleLineLimit = Math.max(1, terminalRows - 1);
-      if (lines.length <= visibleLineLimit) {
-        return lines;
-      }
+        const hiddenLineCount = lines.length - visibleLineLimit + 1;
+        return [
+          `... ${hiddenLineCount} lines hidden (showing latest lines)`,
+          ...lines.slice(lines.length - (visibleLineLimit - 1)),
+        ];
+      });
 
-      if (visibleLineLimit === 1) {
-        return [`... ${lines.length} lines hidden`];
+    const startTTYSession = Effect.gen(function* () {
+      if (!isTTY || sessionActive) {
+        return;
       }
 
-      const hiddenLineCount = lines.length - visibleLineLimit + 1;
-      return [
-        `... ${hiddenLineCount} lines hidden (showing latest lines)`,
-        ...lines.slice(lines.length - (visibleLineLimit - 1)),
-      ];
+      yield* terminal.writeStderr(HIDE_CURSOR);
+      sessionActive = true;
     });
 
-  const startTTYSession = Effect.gen(function* () {
-    if (!isTTY || sessionActive) {
-      return;
-    }
-
-    yield* terminal.writeStderr(HIDE_CURSOR);
-    sessionActive = true;
-  });
-
-  const stopTTYSession = Effect.gen(function* () {
-    if (!isTTY || !sessionActive) {
-      return;
-    }
+    const stopTTYSession = Effect.gen(function* () {
+      if (!isTTY || !sessionActive) {
+        return;
+      }
 
-    yield* terminal.writeStderr("\n" + SHOW_CURSOR);
-    previousLineCount = 0;
-    sessionActive = false;
-  });
+      yield* terminal.writeStderr("\n" + SHOW_CURSOR);
+      previousLineCount = 0;
+      sessionActive = false;
+    });
 
-  const renderNonTTYTaskUpdates = (
-    ordered: ReadonlyArray<{ snapshot: TaskSnapshot; depth: number }>,
-    taskLines: ReadonlyArray<string>,
-  ) => {
-    const nextTaskSignatureById = new Map<number, string>();
-    const changedTaskLines: Array<string> = [];
-    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;
-      const snapshot = ordered[i]!.snapshot;
-      const line = taskLines[i]!;
-      const signature =
-        snapshot.units._tag === "DeterminateTaskUnits"
-          ? `${snapshot.status}:${snapshot.description}:${Math.floor(snapshot.units.completed / nonTtyUpdateStep)}:${snapshot.units.total}`
-          : `${snapshot.status}:${snapshot.description}`;
-
-      nextTaskSignatureById.set(taskId, signature);
-      if (nonTTYTaskSignatureById.get(taskId) !== signature) {
-        changedTaskLines.push(line);
+    const renderNonTTYTaskUpdates = (
+      ordered: ReadonlyArray<{ snapshot: TaskSnapshot; depth: number }>,
+      taskLines: ReadonlyArray<string>,
+    ) => {
+      const nextTaskSignatureById = new Map<number, string>();
+      const changedTaskLines: Array<string> = [];
+      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;
+        const snapshot = ordered[i]!.snapshot;
+        const line = taskLines[i]!;
+        const signature =
+          snapshot.units._tag === "DeterminateTaskUnits"
+            ? `${snapshot.status}:${snapshot.description}:${Math.floor(snapshot.units.completed / nonTtyUpdateStep)}:${snapshot.units.total}`
+            : `${snapshot.status}:${snapshot.description}`;
+
+        nextTaskSignatureById.set(taskId, signature);
+        if (nonTTYTaskSignatureById.get(taskId) !== signature) {
+          changedTaskLines.push(line);
+        }
       }
-    }
 
-    return Effect.gen(function* () {
-      if (changedTaskLines.length > 0) {
-        yield* terminal.writeStderr(changedTaskLines.join("\n") + "\n");
-      }
+      return Effect.gen(function* () {
+        if (changedTaskLines.length > 0) {
+          yield* terminal.writeStderr(changedTaskLines.join("\n") + "\n");
+        }
 
-      nonTTYTaskSignatureById = nextTaskSignatureById;
-    });
-  };
-
-  const renderFrame = (mode: "tick" | "final") =>
-    Effect.gen(function* () {
-      const drainedLogs = yield* Ref.getAndSet(pendingLogsRef, []);
-      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.config));
+        nonTTYTaskSignatureById = nextTaskSignatureById;
       });
+    };
 
-      if (isTTY) {
-        let frame = "";
+    const renderFrame = (mode: "tick" | "final") =>
+      Effect.gen(function* () {
+        const drainedLogs = yield* Ref.getAndSet(pendingLogsRef, []);
+        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 now = yield* Clock.currentTimeMillis;
+        const frameTick = mode === "final" ? tick + 1 : tick;
+        const taskLines = ordered.map(({ snapshot, depth }) => {
+          const lineTick = isTTY ? frameTick : 0;
+          const taskColorizer = store.colorizers.get(snapshot.id) ?? colorizer;
+          return buildTaskLine(snapshot, depth, lineTick, taskColorizer, now);
+        });
 
-        // 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 (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 = yield* clipTTYFrameLines([...historyLogs, ...taskLines]);
-          if (lines.length > 0) {
-            frame += lines.join("\n");
-          }
-          previousLineCount = lines.length;
-        } else {
-          // 2. Logs (scroll above the task block)
-          if (drainedLogs.length > 0) {
-            frame += drainedLogs.join("\n") + "\n";
+          if (retainLogHistory) {
+            const historyLogs = yield* Ref.get(logsRef);
+            const lines = yield* clipTTYFrameLines([...historyLogs, ...taskLines]);
+            if (lines.length > 0) {
+              frame += lines.join("\n");
+            }
+            previousLineCount = lines.length;
+          } 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;
           }
-          // 3. Task lines
-          if (taskLines.length > 0) {
-            frame += taskLines.join("\n");
+
+          // 4. Single atomic write
+          if (frame) {
+            yield* terminal.writeStderr(frame);
           }
-          previousLineCount = taskLines.length;
+          return;
         }
 
-        // 4. Single atomic write
-        if (frame) {
-          yield* terminal.writeStderr(frame);
+        if (drainedLogs.length > 0) {
+          yield* terminal.writeStderr(drainedLogs.join("\n") + "\n");
         }
-        return;
-      }
+        yield* renderNonTTYTaskUpdates(ordered, taskLines);
+      });
 
-      if (drainedLogs.length > 0) {
-        yield* terminal.writeStderr(drainedLogs.join("\n") + "\n");
+    const renderLoop = Effect.gen(function* () {
+      rendererActive = true;
+      if (isTTY) {
+        yield* startTTYSession;
       }
-      yield* renderNonTTYTaskUpdates(ordered, taskLines);
-    });
-
-  const renderLoop = Effect.gen(function* () {
-    rendererActive = true;
-    if (isTTY) {
-      yield* startTTYSession;
-    }
 
-    while (true) {
-      const dirty = yield* Ref.getAndSet(dirtyRef, false);
-      const tasks = Array.from((yield* Ref.get(storeRef)).tasks.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;
+      while (true) {
+        const dirty = yield* Ref.getAndSet(dirtyRef, false);
+        const tasks = Array.from((yield* Ref.get(storeRef)).tasks.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 (isTTY) {
-        if (dirty || hasActiveSpinners || hasPendingLogs) {
+        if (isTTY) {
+          if (dirty || hasActiveSpinners || hasPendingLogs) {
+            yield* renderFrame("tick");
+          }
+        } else if (dirty || hasActiveSpinners) {
           yield* renderFrame("tick");
         }
-      } else if (dirty || hasActiveSpinners) {
-        yield* renderFrame("tick");
-      }
 
-      tick += 1;
-      yield* Effect.sleep(Math.max(1, Math.floor(rendererConfig.renderIntervalMillis)));
-    }
-  }).pipe(
-    Effect.ensuring(
-      Effect.gen(function* () {
-        if (!rendererActive) {
-          return;
-        }
+        tick += 1;
+        yield* Effect.sleep(Math.max(1, Math.floor(rendererConfig.renderIntervalMillis)));
+      }
+    }).pipe(
+      Effect.ensuring(
+        Effect.gen(function* () {
+          if (!rendererActive) {
+            return;
+          }
 
-        if (isTTY) {
-          if (sessionActive) {
-            yield* renderFrame("final");
-            yield* stopTTYSession;
+          if (isTTY) {
+            if (sessionActive) {
+              yield* renderFrame("final");
+              yield* stopTTYSession;
+            }
+            return;
           }
-          return;
-        }
 
-        yield* renderFrame("final");
-      }),
-    ),
-  );
+          yield* renderFrame("final");
+        }),
+      ),
+    );
 
-  if (isTTY && rendererConfig.disableUserInput) {
-    return terminal.withRawInputCapture(renderLoop);
-  }
+    if (isTTY && rendererConfig.disableUserInput) {
+      return yield* terminal.withRawInputCapture(renderLoop);
+    }
 
-  return renderLoop;
-};
+    return yield* renderLoop;
+  });

package/src/runtime.ts

@@ -1,8 +1,9 @@
-import { Context, Effect, Exit, FiberRef, Layer, Option, Ref } from "effect";
+import { Clock, 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 { Colorizer, type ColorizerService } from "./colors";
 import { makeProgressConsole } from "./console";
 import { runProgressServiceRenderer } from "./renderer";
 import { ProgressTerminal } from "./terminal";
@@ -82,6 +83,8 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
     transient: options.transient ?? snapshot.transient,
     units,
     config: snapshot.config,
+    startedAt: snapshot.startedAt,
+    completedAt: snapshot.completedAt,
   });
 };
 
@@ -117,7 +120,6 @@ const removeFromRenderOrder = (
 const makeProgressService = Effect.gen(function* () {
   const rendererConfigOption = yield* Effect.serviceOption(RendererConfig);
   const progressBarConfigOption = yield* Effect.serviceOption(ProgressBarConfig);
-
   const rendererConfig = decodeRendererConfigSync(
     mergeConfig(
       defaultRendererConfig,
@@ -138,6 +140,7 @@ const makeProgressService = Effect.gen(function* () {
   const storeRef = yield* Ref.make<TaskStore>({
     tasks: new Map<TaskId, TaskSnapshot>(),
     renderOrder: [],
+    colorizers: new Map<TaskId, ColorizerService>(),
   });
   const logsRef = yield* Ref.make<ReadonlyArray<string>>([]);
   const pendingLogsRef = yield* Ref.make<ReadonlyArray<string>>([]);
@@ -167,6 +170,7 @@ const makeProgressService = Effect.gen(function* () {
         options.parentId === undefined
           ? yield* FiberRef.get(currentParentRef)
           : Option.some(options.parentId);
+      const colorizerOption = yield* Effect.serviceOption(Colorizer);
       const taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
       const units =
         options.total === undefined || options.total <= 0
@@ -181,6 +185,7 @@ const makeProgressService = Effect.gen(function* () {
         mergeConfig(inheritedProgressBarConfig, options.progressbar),
       );
 
+      const now = yield* Clock.currentTimeMillis;
       const parentIdValue = Option.getOrNull(resolvedParentId);
       const snapshot = new TaskSnapshot({
         id: taskId,
@@ -190,6 +195,8 @@ const makeProgressService = Effect.gen(function* () {
         transient: options.transient ?? false,
         units,
         config: resolvedProgressBarConfig,
+        startedAt: now,
+        completedAt: null,
       });
 
       yield* Ref.update(storeRef, (s) => {
@@ -198,7 +205,11 @@ const makeProgressService = Effect.gen(function* () {
         const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
         const nextOrder = [...s.renderOrder];
         nextOrder.splice(index, 0, { id: taskId, depth });
-        return { tasks: nextTasks, renderOrder: nextOrder };
+        const nextColorizers = new Map(s.colorizers);
+        if (Option.isSome(colorizerOption)) {
+          nextColorizers.set(taskId, colorizerOption.value);
+        }
+        return { tasks: nextTasks, renderOrder: nextOrder, colorizers: nextColorizers };
       });
       yield* markDirty;
 
@@ -211,7 +222,7 @@ const makeProgressService = Effect.gen(function* () {
       if (!snapshot) return store;
       const nextTasks = new Map(store.tasks);
       nextTasks.set(taskId, updatedSnapshot(snapshot, options));
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
+      return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
     }).pipe(Effect.zipRight(markDirty));
 
   const advanceTask = (taskId: TaskId, amount = 1) =>
@@ -240,69 +251,95 @@ const makeProgressService = Effect.gen(function* () {
           transient: snapshot.transient,
           units,
           config: snapshot.config,
+          startedAt: snapshot.startedAt,
+          completedAt: snapshot.completedAt,
         }),
       );
 
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
+      return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
     }).pipe(Effect.zipRight(markDirty));
 
   const completeTask = (taskId: TaskId) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-
-      const nextTasks = new Map(store.tasks);
-      if (snapshot.transient) {
-        nextTasks.delete(taskId);
-        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
-      }
-
-      nextTasks.set(
-        taskId,
-        new TaskSnapshot({
-          id: snapshot.id,
-          parentId: snapshot.parentId,
-          description: snapshot.description,
-          status: "done",
-          transient: snapshot.transient,
-          units:
-            snapshot.units._tag === "DeterminateTaskUnits"
-              ? new DeterminateTaskUnits({
-                  completed: snapshot.units.total,
-                  total: snapshot.units.total,
-                })
-              : snapshot.units,
-          config: snapshot.config,
-        }),
-      );
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
-    }).pipe(Effect.zipRight(markDirty));
+    Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      yield* Ref.update(storeRef, (store) => {
+        const snapshot = store.tasks.get(taskId);
+        if (!snapshot) return store;
+
+        const nextTasks = new Map(store.tasks);
+        if (snapshot.transient) {
+          nextTasks.delete(taskId);
+          const nextColorizers = new Map(store.colorizers);
+          nextColorizers.delete(taskId);
+          return {
+            tasks: nextTasks,
+            renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
+            colorizers: nextColorizers,
+          };
+        }
+
+        nextTasks.set(
+          taskId,
+          new TaskSnapshot({
+            id: snapshot.id,
+            parentId: snapshot.parentId,
+            description: snapshot.description,
+            status: "done",
+            transient: snapshot.transient,
+            units:
+              snapshot.units._tag === "DeterminateTaskUnits"
+                ? new DeterminateTaskUnits({
+                    completed: snapshot.units.total,
+                    total: snapshot.units.total,
+                  })
+                : snapshot.units,
+            config: snapshot.config,
+            startedAt: snapshot.startedAt,
+            completedAt: now,
+          }),
+        );
+        return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+      });
+      yield* markDirty;
+    });
 
   const failTask = (taskId: TaskId) =>
-    Ref.update(storeRef, (store) => {
-      const snapshot = store.tasks.get(taskId);
-      if (!snapshot) return store;
-
-      const nextTasks = new Map(store.tasks);
-      if (snapshot.transient) {
-        nextTasks.delete(taskId);
-        return { tasks: nextTasks, renderOrder: removeFromRenderOrder(store.renderOrder, taskId) };
-      }
-
-      nextTasks.set(
-        taskId,
-        new TaskSnapshot({
-          id: snapshot.id,
-          parentId: snapshot.parentId,
-          description: snapshot.description,
-          status: "failed",
-          transient: snapshot.transient,
-          units: snapshot.units,
-          config: snapshot.config,
-        }),
-      );
-      return { tasks: nextTasks, renderOrder: store.renderOrder };
-    }).pipe(Effect.zipRight(markDirty));
+    Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      yield* Ref.update(storeRef, (store) => {
+        const snapshot = store.tasks.get(taskId);
+        if (!snapshot) return store;
+
+        const nextTasks = new Map(store.tasks);
+        if (snapshot.transient) {
+          nextTasks.delete(taskId);
+          const nextColorizers = new Map(store.colorizers);
+          nextColorizers.delete(taskId);
+          return {
+            tasks: nextTasks,
+            renderOrder: removeFromRenderOrder(store.renderOrder, taskId),
+            colorizers: nextColorizers,
+          };
+        }
+
+        nextTasks.set(
+          taskId,
+          new TaskSnapshot({
+            id: snapshot.id,
+            parentId: snapshot.parentId,
+            description: snapshot.description,
+            status: "failed",
+            transient: snapshot.transient,
+            units: snapshot.units,
+            config: snapshot.config,
+            startedAt: snapshot.startedAt,
+            completedAt: now,
+          }),
+        );
+        return { tasks: nextTasks, renderOrder: store.renderOrder, colorizers: store.colorizers };
+      });
+      yield* markDirty;
+    });
 
   const appendLog = (args: ReadonlyArray<unknown>) =>
     Effect.gen(function* () {
@@ -405,22 +442,19 @@ 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 class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")<
+  Progress,
+  ProgressService
+>() {
+  static readonly Default = Layer.unwrapEffect(
+    Effect.gen(function* () {
+      const colorizerOption = yield* Effect.serviceOption(Colorizer);
+      const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
+      const base = Layer.scoped(Progress, makeProgressService);
+      return base.pipe(
+        Option.isNone(colorizerOption) ? Layer.provide(Colorizer.Default) : (l) => l,
+        Option.isNone(terminalOption) ? Layer.provide(ProgressTerminal.Default) : (l) => l,
+      );
+    }),
+  );
 }
-
-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

@@ -42,18 +42,20 @@ const withRawInputCapture: ProgressTerminalService["withRawInputCapture"] = (eff
     );
   });
 
+const defaultTerminalService: ProgressTerminalService = {
+  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,
+};
+
 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);
+  static readonly Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
 }

package/src/types.ts

@@ -1,6 +1,6 @@
 import { Brand, Context, Effect, Option, Schema } from "effect";
 import type { PartialDeep } from "type-fest";
-import { defaultProgressBarColors, ProgressBarColorsSchema } from "./colors";
+import type { ColorizerService } from "./colors";
 
 export const RendererConfigSchema = Schema.Struct({
   disableUserInput: Schema.Boolean,
@@ -18,14 +18,13 @@ export const ProgressBarConfigSchema = Schema.Struct({
   emptyChar: Schema.String,
   leftBracket: Schema.String,
   rightBracket: Schema.String,
-  colors: ProgressBarColorsSchema,
 });
 export type ProgressBarConfigShape = typeof ProgressBarConfigSchema.Type;
 export const decodeProgressBarConfigSync = Schema.decodeUnknownSync(ProgressBarConfigSchema);
 
 export const defaultRendererConfig: RendererConfigShape = {
   disableUserInput: true,
-  renderIntervalMillis: 50, // 20 FPS
+  renderIntervalMillis: 100, // 10 FPS
   maxLogLines: 0,
   nonTtyUpdateStep: 5,
 };
@@ -37,18 +36,16 @@ export const defaultProgressBarConfig: ProgressBarConfigShape = {
   emptyChar: "─",
   leftBracket: "",
   rightBracket: "",
-  colors: defaultProgressBarColors,
 };
 
-export class RendererConfig extends Context.Tag("stromseng.dev/RendererConfig")<
+export class RendererConfig extends Context.Tag("stromseng.dev/effective-progress/RendererConfig")<
   RendererConfig,
   PartialDeep<RendererConfigShape>
 >() {}
 
-export class ProgressBarConfig extends Context.Tag("stromseng.dev/ProgressBarConfig")<
-  ProgressBarConfig,
-  PartialDeep<ProgressBarConfigShape>
->() {}
+export class ProgressBarConfig extends Context.Tag(
+  "stromseng.dev/effective-progress/ProgressBarConfig",
+)<ProgressBarConfig, PartialDeep<ProgressBarConfigShape>>() {}
 
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 
@@ -103,6 +100,8 @@ export class TaskSnapshot extends Schema.TaggedClass<TaskSnapshot>()("TaskSnapsh
   transient: Schema.Boolean,
   units: TaskUnitsSchema,
   config: ProgressBarConfigSchema,
+  startedAt: Schema.Number,
+  completedAt: Schema.NullOr(Schema.Number),
 }) {}
 
 export interface RenderRow {
@@ -113,6 +112,7 @@ export interface RenderRow {
 export interface TaskStore {
   readonly tasks: Map<TaskId, TaskSnapshot>;
   readonly renderOrder: ReadonlyArray<RenderRow>;
+  readonly colorizers: Map<TaskId, ColorizerService>;
 }
 
 export interface ProgressService {
@@ -144,7 +144,7 @@ export interface ProgressService {
   };
 }
 
-export class Task extends Context.Tag("stromseng.dev/Task")<Task, TaskId>() {}
+export class Task extends Context.Tag("stromseng.dev/effective-progress/Task")<Task, TaskId>() {}
 
 export class TaskAddedEvent extends Schema.TaggedClass<TaskAddedEvent>()("TaskAdded", {
   taskId: TaskIdSchema,