effective-progress 0.1.0 → 0.1.2

package/README.md

@@ -1,11 +1,11 @@
 # effective-progress
 
-`effective-progress` is an Effect-first terminal progress library with:
+`effective-progress` is an [Effect](https://effect.website/)-first terminal progress library with:
 
 - multiple progress bars
 - nested child progress bars
 - spinner support for indeterminate work
-- clean log rendering alongside progress output
+- clean log rendering alongside progress output, allowing you to simply use Effects `Console.log` or `Effect.logInfo`.
 
 ## Install
 
@@ -26,7 +26,7 @@ const program = Progress.all(
       yield* Console.log(`Completed task ${i + 1}`);
     }),
   ),
-  { description: "Running tasks in parallel", all: { concurrency: 2 } },
+  { description: "Running tasks in parallel", concurrency: 2 },
 );
 
 Effect.runPromise(program);
@@ -62,7 +62,7 @@ const program = Progress.all(
       ),
     ),
   ),
-  { description: "Running tasks in parallel", all: { concurrency: 2 } },
+  { description: "Running tasks in parallel", concurrency: 2 },
 );
 
 Effect.runPromise(program);
@@ -80,6 +80,12 @@ Effect.runPromise(program);
 - `examples/simpleExample.ts` - low-boilerplate real-world flow
 - `examples/advancedExample.ts` - full API usage with custom config and manual task control
 
+## Log retention
+
+- `maxLogLines` controls in-memory log retention.
+- `maxLogLines` omitted or set to `0` means no log history is kept in memory.
+- `maxLogLines > 0` keeps only the latest `N` log lines in memory.
+
 ## Notes
 
 - This is a WIP library, so expect breaking changes. Feedback and contributions are very welcome!

package/package.json

@@ -1,37 +1,42 @@
 {
   "name": "effective-progress",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Effect-first terminal progress bars with nested multibar support",
+  "homepage": "https://github.com/stromseng/effective-progress#readme",
+  "bugs": {
+    "url": "https://github.com/stromseng/effective-progress/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/stromseng/effective-progress.git"
   },
-  "bugs": {
-    "url": "https://github.com/stromseng/effective-progress/issues"
-  },
-  "homepage": "https://github.com/stromseng/effective-progress#readme",
-  "type": "module",
-  "module": "index.ts",
   "files": [
     "index.ts",
     "src",
     "README.md",
     "LICENSE"
   ],
+  "type": "module",
+  "module": "index.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "prepare": "effect-language-service patch"
+    "prepare": "effect-language-service patch",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@effect/language-service": "^0.73.1",
     "chalk": "^5.6.2",
     "effect": "^3.19.16"
   },
   "devDependencies": {
+    "@effect/language-service": "^0.73.1",
     "@types/bun": "latest",
+    "oxfmt": "^0.32.0",
     "oxlint": "^1.47.0"
   },
   "peerDependencies": {

package/src/api.ts

@@ -1,48 +1,36 @@
 import { Console, Effect, Option } from "effect";
+import type { Concurrency } from "effect/Types";
 import { makeProgressConsole } from "./console";
 import { makeProgressService } from "./runtime";
 import { Progress } from "./types";
 import type { TrackOptions } from "./types";
+import { inferTotal } from "./utils";
 
-export interface TrackEffectsOptions {
-  readonly description: string;
-  readonly total?: number;
-  readonly transient?: boolean;
-  readonly all?: {
-    readonly concurrency?: number | "unbounded";
-    readonly batching?: boolean | "inherit";
-    readonly concurrentFinalizers?: boolean;
-  };
+export interface EffectExecutionOptions {
+  readonly concurrency?: Concurrency;
+  readonly batching?: boolean | "inherit";
+  readonly concurrentFinalizers?: boolean;
 }
 
-export interface ForEachOptions extends TrackOptions {
-  readonly forEach?: {
-    readonly concurrency?: number | "unbounded";
-    readonly batching?: boolean | "inherit";
-    readonly concurrentFinalizers?: boolean;
-  };
+export interface EffectAllExecutionOptions extends EffectExecutionOptions {
+  readonly discard?: boolean;
+  readonly mode?: "default" | "validate" | "either";
 }
 
-const inferTotal = (iterable: Iterable<unknown>): number | undefined => {
-  if (Array.isArray(iterable)) {
-    return iterable.length;
-  }
+export type AllOptions = Omit<TrackOptions, "total"> & EffectAllExecutionOptions;
+export type AllReturn<
+  Arg extends ReadonlyArray<Effect.Effect<any, any, any>>,
+  O extends EffectAllExecutionOptions,
+> =
+  [Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>>] extends
+    [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress>>
+  : never;
 
-  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;
-  }
+export interface ForEachExecutionOptions extends EffectExecutionOptions {
+  readonly discard?: false | undefined;
+}
 
-  return undefined;
-};
+export type ForEachOptions = TrackOptions & ForEachExecutionOptions;
 
 export const withProgressService = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   Effect.gen(function* () {
@@ -65,32 +53,36 @@ export const withProgressService = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     );
   });
 
-export const all = <A, E, R>(
-  effects: ReadonlyArray<Effect.Effect<A, E, R>>,
-  options: TrackEffectsOptions,
-): Effect.Effect<ReadonlyArray<A>, E, Exclude<R, 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> =>
   withProgressService(
     Effect.gen(function* () {
       const progress = yield* Progress;
       return yield* progress.withTask(
         {
           description: options.description,
-          total: options.total ?? effects.length,
+          total: effects.length,
           transient: options.transient,
         },
         (taskId) =>
-          Effect.forEach(
+          Effect.all(
             effects.map((effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))),
-            (effect) => effect,
             {
-              concurrency: options.all?.concurrency,
-              batching: options.all?.batching,
-              concurrentFinalizers: options.all?.concurrentFinalizers,
+              concurrency: options.concurrency,
+              batching: options.batching,
+              discard: options.discard,
+              mode: options.mode,
+              concurrentFinalizers: options.concurrentFinalizers,
             },
           ),
       );
     }),
-  );
+  ) as AllReturn<Arg, O>;
 
 export const forEach = <A, B, E, R>(
   iterable: Iterable<A>,
@@ -101,34 +93,23 @@ export const forEach = <A, B, E, R>(
     Effect.gen(function* () {
       const progress = yield* Progress;
 
-      const items = Array.from(iterable);
-      const total = options.total ?? inferTotal(iterable);
-
       return yield* progress.withTask(
         {
           description: options.description,
-          total,
+          total: options.total ?? inferTotal(iterable),
           transient: options.transient,
         },
         (taskId) =>
           Effect.forEach(
-            items,
+            iterable,
             (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)),
             {
-              concurrency: options.forEach?.concurrency,
-              batching: options.forEach?.batching,
-              concurrentFinalizers: options.forEach?.concurrentFinalizers,
+              concurrency: options.concurrency,
+              batching: options.batching,
+              discard: options.discard,
+              concurrentFinalizers: options.concurrentFinalizers,
             },
           ),
       );
     }),
   );
-
-export const trackProgress = all;
-
-export const track = <A, B, E, R>(
-  iterable: Iterable<A>,
-  options: TrackOptions,
-  f: (item: A, index: number) => Effect.Effect<B, E, R>,
-): Effect.Effect<ReadonlyArray<B>, E, Exclude<R, Progress>> =>
-  forEach(iterable, f, options);

package/src/renderer.ts

@@ -1,11 +1,7 @@
 import { Effect, Ref } from "effect";
 import chalk from "chalk";
 import type { ProgressBarConfigShape } from "./types";
-import {
-  DeterminateTaskUnits,
-  TaskId,
-  TaskSnapshot,
-} from "./types";
+import { DeterminateTaskUnits, TaskId, TaskSnapshot } from "./types";
 
 const HIDE_CURSOR = "\x1b[?25l";
 const SHOW_CURSOR = "\x1b[?25h";
@@ -13,11 +9,6 @@ const CLEAR_LINE = "\x1b[2K";
 const MOVE_UP_ONE = "\x1b[1A";
 const RENDER_INTERVAL = "80 millis";
 
-export interface LogEntry {
-  readonly id: number;
-  readonly message: string;
-}
-
 const renderDeterminate = (units: DeterminateTaskUnits, config: ProgressBarConfigShape): string => {
   const safeTotal = units.total <= 0 ? 1 : units.total;
   const ratio = Math.min(1, Math.max(0, units.completed / safeTotal));
@@ -80,82 +71,105 @@ 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,
+  maxRetainedLogLines: number,
 ) => {
   const isTTY = config.isTTY;
+  const retainLogHistory = maxRetainedLogLines > 0;
   let previousLineCount = 0;
-  let nonTTYLastLogId = 0;
+  let previousTaskLineCount = 0;
   let nonTTYTaskSignatureById = new Map<number, string>();
   let tick = 0;
   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;
-      }
-      process.stderr.write(output + "\r");
-      previousLineCount = 0;
-    };
+  const clearTTYLines = (lineCount: number) => {
+    if (lineCount <= 0) {
+      return;
+    }
 
-    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];
+    let output = "\r" + CLEAR_LINE;
+    for (let i = 1; i < lineCount; i++) {
+      output += MOVE_UP_ONE + CLEAR_LINE;
+    }
+    process.stderr.write(output + "\r");
+  };
 
-        if (isTTY) {
-          clearTTY();
-          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;
-          }
+  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(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);
+      }
+    }
 
-          const nextTaskSignatureById = new Map<number, string>();
-          const changedTaskLines: Array<string> = [];
-          const nonTtyUpdateStep = Math.max(1, Math.floor(config.nonTtyUpdateStep));
+    if (changedTaskLines.length > 0) {
+      process.stderr.write(changedTaskLines.join("\n") + "\n");
+    }
 
-          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}`;
+    nonTTYTaskSignatureById = nextTaskSignatureById;
+  };
 
-            nextTaskSignatureById.set(taskId, signature);
-            if (nonTTYTaskSignatureById.get(taskId) !== signature) {
-              changedTaskLines.push(line);
-            }
-          }
+  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, config);
+      });
 
-          if (changedTaskLines.length > 0) {
-            process.stderr.write(changedTaskLines.join("\n") + "\n");
+      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;
+          return;
+        }
 
-          nonTTYTaskSignatureById = nextTaskSignatureById;
+        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 (drainedLogs.length > 0) {
+        process.stderr.write(drainedLogs.join("\n") + "\n");
+      }
+      renderNonTTYTaskUpdates(ordered, taskLines);
+    });
+
+  return Effect.gen(function* () {
     if (isTTY) {
       process.stderr.write(HIDE_CURSOR);
 
@@ -205,60 +219,7 @@ export const runProgressServiceRenderer = (
   }).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;
-        }
+        yield* renderFrame("final");
 
         if (isTTY) {
           teardownInput?.();

package/src/runtime.ts

@@ -1,44 +1,20 @@
 import { Effect, Exit, FiberRef, Option, Ref } from "effect";
 import { formatWithOptions } from "node:util";
 import { runProgressServiceRenderer } from "./renderer";
-import type {
-  AddTaskOptions,
-  ProgressService,
-  TrackOptions,
-  UpdateTaskOptions,
-} from "./types";
+import type { AddTaskOptions, ProgressService, UpdateTaskOptions } from "./types";
 import {
   defaultProgressBarConfig,
   DeterminateTaskUnits,
   IndeterminateTaskUnits,
+  Progress,
   ProgressBarConfig,
   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 updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): TaskSnapshot => {
   const currentUnits = snapshot.units;
   const units = (() => {
@@ -84,16 +60,26 @@ const updatedSnapshot = (snapshot: TaskSnapshot, options: UpdateTaskOptions): Ta
 export const makeProgressService = Effect.gen(function* () {
   const configOption = yield* Effect.serviceOption(ProgressBarConfig);
   const config = Option.getOrElse(configOption, () => defaultProgressBarConfig);
+  const maxRetainedLogLines = Math.max(0, Math.floor(config.maxLogLines ?? 0));
 
   const 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 currentParentRef = yield* FiberRef.make(Option.none<TaskId>());
 
-  yield* Effect.forkScoped(runProgressServiceRenderer(tasksRef, logsRef, dirtyRef, config));
+  yield* Effect.forkScoped(
+    runProgressServiceRenderer(
+      tasksRef,
+      logsRef,
+      pendingLogsRef,
+      dirtyRef,
+      config,
+      maxRetainedLogLines,
+    ),
+  );
 
   const markDirty = Effect.gen(function* () {
     const shouldSchedule = yield* Ref.modify(dirtyScheduledRef, (scheduled) =>
@@ -251,7 +237,10 @@ 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 message = formatWithOptions(
         {
           colors: config.isTTY,
@@ -260,17 +249,17 @@ export const makeProgressService = Effect.gen(function* () {
         ...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;
     });
 
@@ -315,14 +304,13 @@ export const makeProgressService = Effect.gen(function* () {
         transient: options.transient,
       },
       (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)),
         );
       },
     );
 
-  const service: ProgressService = {
+  return Progress.of({
     addTask,
     updateTask,
     advanceTask,
@@ -333,7 +321,5 @@ export const makeProgressService = Effect.gen(function* () {
     listTasks,
     withTask,
     trackIterable,
-  };
-
-  return service;
+  });
 });

package/src/types.ts

@@ -12,7 +12,7 @@ export const ProgressBarConfigSchema = Schema.Struct({
   emptyChar: Schema.String,
   leftBracket: Schema.String,
   rightBracket: Schema.String,
-  maxLogLines: Schema.Number,
+  maxLogLines: Schema.optional(Schema.Number),
   nonTtyUpdateStep: Schema.Number,
 });
 
@@ -59,11 +59,7 @@ export interface UpdateTaskOptions {
   readonly transient?: boolean;
 }
 
-export interface TrackOptions {
-  readonly description: string;
-  readonly total?: number;
-  readonly transient?: boolean;
-}
+export type TrackOptions = Exclude<AddTaskOptions, "parentId">;
 
 export class DeterminateTaskUnits extends Schema.TaggedClass<DeterminateTaskUnits>()(
   "DeterminateTaskUnits",
@@ -160,8 +156,3 @@ export const ProgressTaskEventSchema = Schema.Union(
 export type ProgressTaskEvent = typeof ProgressTaskEventSchema.Type;
 
 export const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);
-
-export const isIndeterminateTask = (snapshot: TaskSnapshot) =>
-  snapshot.units._tag === "IndeterminateTaskUnits";
-
-export const nextSpinnerFrame = (index: number) => (index + 1) % SPINNER_FRAMES.length;

package/src/utils.ts

@@ -0,0 +1,20 @@
+export 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;
+};