effective-progress 0.1.0 → 0.1.3

package/src/renderer.ts

@@ -1,58 +1,59 @@
-import { Effect, Ref } from "effect";
-import chalk from "chalk";
-import type { ProgressBarConfigShape } from "./types";
+import { Effect, Ref, Schema } from "effect";
 import {
-  DeterminateTaskUnits,
-  TaskId,
-  TaskSnapshot,
-} from "./types";
+  type CompiledProgressBarColors,
+  compileProgressBarColors,
+  ProgressBarColorsSchema,
+} from "./colors";
+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));
 
-export interface LogEntry {
-  readonly id: number;
-  readonly message: string;
-}
-
-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 = (
@@ -80,86 +81,127 @@ const orderTasksForRender = (
 
 export const runProgressServiceRenderer = (
   tasksRef: Ref.Ref<Map<TaskId, TaskSnapshot>>,
-  logsRef: Ref.Ref<ReadonlyArray<LogEntry>>,
+  logsRef: Ref.Ref<ReadonlyArray<string>>,
+  pendingLogsRef: Ref.Ref<ReadonlyArray<string>>,
   dirtyRef: Ref.Ref<boolean>,
-  config: ProgressBarConfigShape,
+  rendererConfig: RendererConfigShape,
+  maxRetainedLogLines: number,
+  rendererLatch: Effect.Latch,
 ) => {
-  const isTTY = config.isTTY;
+  const isTTY = rendererConfig.isTTY;
+  const retainLogHistory = maxRetainedLogLines > 0;
+  const colorCache = new Map<string, CompiledProgressBarColors>();
   let previousLineCount = 0;
-  let nonTTYLastLogId = 0;
+  let previousTaskLineCount = 0;
   let nonTTYTaskSignatureById = new Map<number, string>();
   let tick = 0;
+  let rendererActive = false;
   let teardownInput: (() => void) | undefined;
 
-  return Effect.gen(function* () {
-    const clearTTY = () => {
-      let output = "\r" + CLEAR_LINE;
-      for (let i = 1; i < previousLineCount; i++) {
-        output += MOVE_UP_ONE + CLEAR_LINE;
+  const getCompiledColors = (progressbar: ProgressBarConfigShape): CompiledProgressBarColors => {
+    const key = encodeProgressBarColorsKey(progressbar.colors);
+    const cached = colorCache.get(key);
+    if (cached) {
+      return cached;
+    }
+
+    const compiled = compileProgressBarColors(progressbar.colors);
+    colorCache.set(key, compiled);
+    return compiled;
+  };
+
+  const clearTTYLines = (lineCount: number) => {
+    if (lineCount <= 0) {
+      return;
+    }
+
+    let output = "\r" + CLEAR_LINE;
+    for (let i = 1; i < lineCount; i++) {
+      output += MOVE_UP_ONE + CLEAR_LINE;
+    }
+    process.stderr.write(output + "\r");
+  };
+
+  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);
       }
-      process.stderr.write(output + "\r");
-      previousLineCount = 0;
-    };
+    }
 
-    const renderFrame = (mode: "tick" | "final") =>
-      Effect.gen(function* () {
-        const logs = yield* Ref.get(logsRef);
-        const snapshots = Array.from((yield* Ref.get(tasksRef)).values()).filter(
-          (task) => !(task.transient && task.status !== "running"),
-        );
-        const ordered = orderTasksForRender(snapshots);
-        const frameTick = mode === "final" ? tick + 1 : tick;
-        const taskLines = ordered.map(({ snapshot, depth }) => {
-          const lineTick = isTTY ? frameTick : 0;
-          return buildTaskLine(snapshot, depth, lineTick, config);
-        });
-        const logLines = logs.map((log) => log.message);
-        const lines = [...logLines, ...taskLines];
+    if (changedTaskLines.length > 0) {
+      process.stderr.write(changedTaskLines.join("\n") + "\n");
+    }
 
-        if (isTTY) {
-          clearTTY();
+    nonTTYTaskSignatureById = nextTaskSignatureById;
+  };
+
+  const renderFrame = (mode: "tick" | "final") =>
+    Effect.gen(function* () {
+      const drainedLogs = yield* Ref.getAndSet(pendingLogsRef, []);
+      const snapshots = Array.from((yield* Ref.get(tasksRef)).values()).filter(
+        (task) => !(task.transient && task.status !== "running"),
+      );
+      const ordered = orderTasksForRender(snapshots);
+      const frameTick = mode === "final" ? tick + 1 : tick;
+      const taskLines = ordered.map(({ snapshot, depth }) => {
+        const lineTick = isTTY ? frameTick : 0;
+        return buildTaskLine(snapshot, depth, lineTick, getCompiledColors(snapshot.progressbar));
+      });
+
+      if (isTTY) {
+        if (retainLogHistory) {
+          const historyLogs = yield* Ref.get(logsRef);
+          const lines = [...historyLogs, ...taskLines];
+          clearTTYLines(previousLineCount);
           if (lines.length > 0) {
             process.stderr.write(lines.join("\n"));
-            previousLineCount = lines.length;
-          }
-        } else {
-          const appendedLogs = logs.filter((log) => log.id > nonTTYLastLogId);
-          if (appendedLogs.length > 0) {
-            process.stderr.write(appendedLogs.map((log) => log.message).join("\n") + "\n");
-            nonTTYLastLogId = appendedLogs[appendedLogs.length - 1]?.id ?? nonTTYLastLogId;
           }
+          previousLineCount = lines.length;
+          return;
+        }
 
-          const nextTaskSignatureById = new Map<number, string>();
-          const changedTaskLines: Array<string> = [];
-          const nonTtyUpdateStep = Math.max(1, Math.floor(config.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);
-            }
-          }
+        clearTTYLines(previousTaskLineCount);
+        if (drainedLogs.length > 0) {
+          process.stderr.write(drainedLogs.join("\n") + "\n");
+        }
+        if (taskLines.length > 0) {
+          process.stderr.write(taskLines.join("\n"));
+        }
+        previousTaskLineCount = taskLines.length;
+        return;
+      }
 
-          if (changedTaskLines.length > 0) {
-            process.stderr.write(changedTaskLines.join("\n") + "\n");
-          }
+      if (drainedLogs.length > 0) {
+        process.stderr.write(drainedLogs.join("\n") + "\n");
+      }
+      renderNonTTYTaskUpdates(ordered, taskLines);
+    });
 
-          nonTTYTaskSignatureById = nextTaskSignatureById;
-        }
-      });
+  return Effect.gen(function* () {
+    yield* rendererLatch.await;
+    rendererActive = true;
 
     if (isTTY) {
       process.stderr.write(HIDE_CURSOR);
 
-      if (config.disableUserInput && process.stdin.isTTY) {
+      if (rendererConfig.disableUserInput && process.stdin.isTTY) {
         const stdin = process.stdin;
         const wasRaw = Boolean(stdin.isRaw);
         stdin.resume();
@@ -200,66 +242,17 @@ export const runProgressServiceRenderer = (
       }
 
       tick += 1;
-      yield* Effect.sleep(RENDER_INTERVAL);
+      yield* Effect.sleep(Math.max(1, Math.floor(rendererConfig.renderIntervalMillis)));
     }
   }).pipe(
     Effect.ensuring(
       Effect.gen(function* () {
-        const logs = yield* Ref.get(logsRef);
-        const snapshots = Array.from((yield* Ref.get(tasksRef)).values()).filter(
-          (task) => !(task.transient && task.status !== "running"),
-        );
-        const ordered = orderTasksForRender(snapshots);
-        const taskLines = ordered.map(({ snapshot, depth }) =>
-          buildTaskLine(snapshot, depth, tick + 1, config),
-        );
-        const logLines = logs.map((log) => log.message);
-        const lines = [...logLines, ...taskLines];
-
-        if (isTTY) {
-          let output = "\r" + CLEAR_LINE;
-          for (let i = 1; i < previousLineCount; i++) {
-            output += MOVE_UP_ONE + CLEAR_LINE;
-          }
-
-          if (lines.length > 0) {
-            process.stderr.write(output + "\r" + lines.join("\n"));
-          } else {
-            process.stderr.write(output + "\r");
-          }
-        } else {
-          const appendedLogs = logs.filter((log) => log.id > nonTTYLastLogId);
-          if (appendedLogs.length > 0) {
-            process.stderr.write(appendedLogs.map((log) => log.message).join("\n") + "\n");
-            nonTTYLastLogId = appendedLogs[appendedLogs.length - 1]?.id ?? nonTTYLastLogId;
-          }
-
-          const nextTaskSignatureById = new Map<number, string>();
-          const changedTaskLines: Array<string> = [];
-          const nonTtyUpdateStep = Math.max(1, Math.floor(config.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);
-            }
-          }
-
-          if (changedTaskLines.length > 0) {
-            process.stderr.write(changedTaskLines.join("\n") + "\n");
-          }
-
-          nonTTYTaskSignatureById = nextTaskSignatureById;
+        if (!rendererActive) {
+          return;
         }
 
+        yield* renderFrame("final");
+
         if (isTTY) {
           teardownInput?.();
           process.stderr.write("\n" + SHOW_CURSOR);

package/src/runtime.ts

@@ -1,43 +1,41 @@
-import { Effect, Exit, FiberRef, Option, Ref } from "effect";
+import { Console, Effect, Exit, FiberRef, 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 type {
-  AddTaskOptions,
-  ProgressService,
-  TrackOptions,
-  UpdateTaskOptions,
-} from "./types";
+import type { AddTaskOptions, ProgressService, UpdateTaskOptions } from "./types";
 import {
+  decodeProgressBarConfigSync,
+  decodeRendererConfigSync,
   defaultProgressBarConfig,
+  defaultRendererConfig,
   DeterminateTaskUnits,
   IndeterminateTaskUnits,
+  Progress,
   ProgressBarConfig,
+  RendererConfig,
   TaskId,
   TaskSnapshot,
 } from "./types";
+import { inferTotal } from "./utils";
 
 const DIRTY_DEBOUNCE_INTERVAL = "10 millis";
 
-const inferTotal = (iterable: Iterable<unknown>): number | undefined => {
-  if (Array.isArray(iterable)) {
-    return iterable.length;
-  }
-
-  if (typeof iterable === "string") {
-    return iterable.length;
-  }
-
-  const candidate = iterable as { length?: unknown; size?: unknown };
-  if (typeof candidate.length === "number") {
-    return candidate.length;
-  }
-
-  if (typeof candidate.size === "number") {
-    return candidate.size;
-  }
-
-  return undefined;
-};
+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;
@@ -78,22 +76,51 @@ 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 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 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<{ id: number; message: string }>>([]);
+  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 nextLogIdRef = yield* Ref.make(0);
+  const rendererStartedRef = yield* Ref.make(false);
+  const rendererLatch = yield* Effect.makeLatch(false);
   const currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
-
-  yield* Effect.forkScoped(runProgressServiceRenderer(tasksRef, logsRef, dirtyRef, config));
+  const scope = yield* Effect.scope;
+
+  yield* Effect.forkIn(
+    runProgressServiceRenderer(
+      tasksRef,
+      logsRef,
+      pendingLogsRef,
+      dirtyRef,
+      rendererConfig,
+      maxRetainedLogLines,
+      rendererLatch,
+    ),
+    scope,
+  );
 
   const markDirty = Effect.gen(function* () {
     const shouldSchedule = yield* Ref.modify(dirtyScheduledRef, (scheduled) =>
@@ -123,6 +150,19 @@ 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 shouldOpenRenderer = yield* Ref.modify(rendererStartedRef, (started) =>
+        started ? [false, true] : [true, true],
+      );
+      if (shouldOpenRenderer) {
+        yield* rendererLatch.open;
+      }
 
       const snapshot = new TaskSnapshot({
         id: taskId,
@@ -131,6 +171,7 @@ export const makeProgressService = Effect.gen(function* () {
         status: "running",
         transient: options.transient ?? false,
         units,
+        progressbar: resolvedProgressBarConfig,
       });
 
       yield* Ref.update(tasksRef, (tasks) => {
@@ -170,8 +211,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(
@@ -183,6 +223,7 @@ export const makeProgressService = Effect.gen(function* () {
           status: snapshot.status,
           transient: snapshot.transient,
           units,
+          progressbar: snapshot.progressbar,
         }),
       );
 
@@ -217,6 +258,7 @@ export const makeProgressService = Effect.gen(function* () {
                   total: snapshot.units.total,
                 })
               : snapshot.units,
+          progressbar: snapshot.progressbar,
         }),
       );
       return next;
@@ -244,6 +286,7 @@ export const makeProgressService = Effect.gen(function* () {
           status: "failed",
           transient: snapshot.transient,
           units: snapshot.units,
+          progressbar: snapshot.progressbar,
         }),
       );
       return next;
@@ -251,29 +294,45 @@ export const makeProgressService = Effect.gen(function* () {
 
   const log = (...args: ReadonlyArray<unknown>) =>
     Effect.gen(function* () {
-      const id = yield* Ref.updateAndGet(nextLogIdRef, (current) => current + 1);
+      if (args.length === 0) {
+        return;
+      }
+
+      const shouldOpenRenderer = yield* Ref.modify(rendererStartedRef, (started) =>
+        started ? [false, true] : [true, true],
+      );
+      if (shouldOpenRenderer) {
+        yield* rendererLatch.open;
+      }
+
       const message = formatWithOptions(
         {
-          colors: config.isTTY,
+          colors: rendererConfig.isTTY,
           depth: 6,
         },
         ...args,
       );
 
-      yield* Ref.update(logsRef, (logs) => {
-        const maxLogLines = Math.floor(config.maxLogLines);
-        const next = [...logs, { id, message }];
-        if (maxLogLines <= 0) {
-          return next;
-        }
-        if (next.length <= maxLogLines) {
-          return next;
-        }
-        return next.slice(next.length - maxLogLines);
-      });
+      yield* Ref.update(pendingLogsRef, (logs) => [...logs, message]);
+      if (maxRetainedLogLines > 0) {
+        yield* Ref.update(logsRef, (logs) => {
+          const next = [...logs, message];
+          if (next.length <= maxRetainedLogLines) {
+            return next;
+          }
+          return next.slice(next.length - maxRetainedLogLines);
+        });
+      }
+
       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 getTask = (taskId: TaskId) =>
     Ref.get(tasksRef).pipe(Effect.map((tasks) => Option.fromNullable(tasks.get(taskId))));
 
@@ -313,10 +372,10 @@ export const makeProgressService = Effect.gen(function* () {
         description: options.description,
         total: options.total ?? inferTotal(iterable),
         transient: options.transient,
+        progressbar: options.progressbar,
       },
       (taskId) => {
-        const items = Array.from(iterable);
-        return Effect.forEach(items, (item, index) =>
+        return Effect.forEach(iterable, (item, index) =>
           Effect.tap(f(item, index), () => advanceTask(taskId, 1)),
         );
       },
@@ -329,11 +388,12 @@ export const makeProgressService = Effect.gen(function* () {
     completeTask,
     failTask,
     log,
+    withCapturedLogs,
     getTask,
     listTasks,
     withTask,
     trackIterable,
   };
 
-  return service;
+  return Progress.of(service);
 });