effective-progress 0.11.1 → 0.12.0

package/README.md

@@ -17,14 +17,14 @@
 
 - multiple nested tree-like progress bars
 - spinner support for “we have no idea how long this takes” work
-- keep using `Console.log` / `Effect.logInfo` while progress rendering is active
+- keep using Effect v4 `Effect.log*` / `Logger` and `Console.log` while progress rendering is active
 - familiar `.all` and `.forEach` APIs — swap `Effect` for `Progress`, get progress bars basically for free
 - flicker-free rendering with [Ink](https://github.com/vadimdemedes/ink)
 
 ## Install
 
 ```bash
-bun add effective-progress
+bun add effective-progress effect@^4.0.0-beta.100
 ```
 
 ## Usage
@@ -32,14 +32,14 @@ bun add effective-progress
 Iterate items with a single progress bar.
 
 ```ts
-import { Console, Effect } from "effect";
+import { Effect } from "effect";
 import * as Progress from "effective-progress";
 
 const program = Progress.all(
   Array.from({ length: 5 }).map((_, i) =>
     Effect.gen(function* () {
       yield* Effect.sleep("1 second");
-      yield* Console.log(`Completed task ${i + 1}`);
+      yield* Effect.logInfo(`Completed task ${i + 1}`);
     }),
   ),
   { description: "Running tasks in parallel", concurrency: 2 },
@@ -75,16 +75,16 @@ Effect.runPromise(program);
 
 <img alt="Nested example output" src="docs/images/nesting.gif" width="600" />
 
-### Effect.all modes
+### Effect.all result mode
 
-Support for `either`/`validate` modes of `Effect.all` and render the amount of successes/failures.
+`Progress.all` mirrors Effect v4's fail-fast default and `mode: "result"`, rendering the amount of successes and failures as work completes.
 
 <img alt="Mixed outcomes modes output" src="docs/images/mixedOutcomes.gif" width="600" />
 
 - `Progress.all` in default mode (`mode: "default"`) remains fail-fast.
 - In fail-fast runs, unresolved units remain unprocessed.
-- `mode: "either"` and `mode: "validate"` run all effects and keep mixed outcomes in the task counters.
-- Mixed outcomes can finalize as `done` when all units are accounted for.
+- `mode: "result"` runs every effect and returns a `Result` for each outcome while keeping mixed outcomes in the task counters.
+- Result-mode tasks finalize as `done` when all units are accounted for.
 - Empty collections are valid inputs for `Progress.all` / `Progress.forEach` and render as `0/0` instead of failing.
 
 ### Single task with a typed handle
@@ -92,13 +92,13 @@ Support for `either`/`validate` modes of `Effect.all` and render the amount of s
 Use `Progress.task(...)` when you want one progress bar around a custom effect. The callback form gives you a task-local handle, so you can update counts, descriptions, and metadata without fetching the current task ID first.
 
 ```ts
-import { Console, Effect } from "effect";
+import { Effect } from "effect";
 import * as Progress from "effective-progress";
 
 const program = Progress.task(
   (task) =>
     Effect.gen(function* () {
-      yield* Console.log("Starting deployment");
+      yield* Effect.logInfo("Starting deployment");
       yield* task.incrementSucceeded();
       yield* task.update({
         description: "Uploading release bundle",
@@ -125,7 +125,7 @@ Effect.runPromise(program);
 - `examples/advancedExample.ts` - mixed high-level and low-level Progress service usage
 - `examples/basic.ts` - minimal `Progress.all` usage
 - `examples/nesting.ts` - nested tree rendering with parent and child tasks
-- `examples/mixedOutcomes.ts` - fail-fast vs `either`/`validate` with mixed success/failure counters
+- `examples/mixedOutcomes.ts` - fail-fast vs `result` mode with mixed success/failure counters
 - `examples/cliProgressSemantics.ts` - zero totals, negative totals clearing to unknown totals, overflow counts, and empty `all` / `forEach`
 - `examples/unknownTotalCounting.ts` - count successes/failures without a known total and render `processed/?`
 - `examples/typedMetadata.ts` - typed task metadata rendered through custom columns
@@ -138,11 +138,21 @@ Effect.runPromise(program);
 
 ## Configuration
 
-### Console behavior
+### Logging behavior
 
 - The Ink renderer runs with `patchConsole: true`, so console output is patched by Ink while the app is mounted.
-- `Progress.task`, `Progress.all`, and `Progress.forEach` write through the currently provided Effect `Console` implementation.
-- Formatting is controlled by the API consumer's logger/console implementation.
+- `Effect.log*` uses the active Effect v4 `Logger` set, including custom loggers installed with `Logger.layer(...)`.
+- The low-level `progress.log(...)` method emits through `Effect.log`, so it honors the current log level, logger set, annotations, and spans.
+- Direct `Console` calls still use the currently provided Effect `Console` reference.
+- Formatting and routing remain controlled by the consumer's logger and console configuration.
+
+For example, install the v4 pretty console logger around a program with:
+
+```ts
+import { Effect, Logger } from "effect";
+
+Effect.runPromise(program.pipe(Effect.provide(Logger.layer([Logger.consolePretty()]))));
+```
 
 ### Ink renderer behavior
 
@@ -177,17 +187,19 @@ The handle exposes:
 
 When you need lower-level control, the `Progress` service is available inside the effect and exposes APIs like `addTask`, `updateTask`, `incrementSucceeded(taskId, amount)`, and `completeTask(taskId)`.
 
+The primary v4-style service layers are exposed as `Progress.layer` and `ProgressStdio.layer`.
+
 Example using the lower-level service API:
 
 ```ts
-import { Console, Effect } from "effect";
+import { Effect } from "effect";
 import * as Progress from "effective-progress";
 
 const program = Progress.task(
   Effect.gen(function* () {
     const progress = yield* Progress.Progress;
     const currentTask = yield* Progress.Task;
-    yield* Console.log("This log is handled by the outer Console", { taskId: currentTask });
+    yield* Effect.logInfo("Updating the current task", { taskId: currentTask });
 
     // Manual determinate updates:
     yield* progress.incrementSucceeded(currentTask, 3);
@@ -258,6 +270,6 @@ const program = Progress.task(
 
 If a task does not provide `columns`, the renderer falls back to `Progress.Columns.defaults()`.
 
-## Notes
+## Effect compatibility
 
-- As Effect 4.0 is around the corner with some changes to logging, there may be some adjustments needed to align with the new Effect APIs.
+This release targets Effect `4.0.0-beta.100` or newer compatible v4 prereleases. Effect v4 is still in beta, so its APIs may change between beta releases.

package/dist/index.d.mts

@@ -6,12 +6,12 @@ import { Concurrency } from "effect/Types";
 import * as effect_SchemaAST0 from "effect/SchemaAST";
 
 //#region src/types.d.ts
-declare const TaskIdSchema: Schema.brand<typeof Schema.Number, "TaskId">;
+declare const TaskIdSchema: Schema.brand<Schema.Number, "TaskId">;
 type TaskId = typeof TaskIdSchema.Type;
-declare const TaskId: Brand.Brand.Constructor<number & Brand.Brand<"TaskId">>;
-declare const TaskStatusSchema: Schema.Literal<["running", "done", "failed"]>;
+declare const TaskId: Brand.Constructor<number & Brand.Brand<"TaskId">>;
+declare const TaskStatusSchema: Schema.Literals<readonly ["running", "done", "failed"]>;
 type TaskStatus = typeof TaskStatusSchema.Type;
-declare const TaskCountDisplaySchema: Schema.Literal<["processedOnly", "detailed"]>;
+declare const TaskCountDisplaySchema: Schema.Literals<readonly ["processedOnly", "detailed"]>;
 type TaskCountDisplay = typeof TaskCountDisplaySchema.Type;
 type ColumnAlign = "left" | "center" | "right";
 interface TaskTreeInfo {
@@ -102,37 +102,37 @@ interface UpdateTaskOptions {
 }
 type TrackOptions = Omit<AddTaskOptions, "parentId">;
 declare const TaskUnitsSchema: Schema.Struct<{
-  succeeded: typeof Schema.Number;
-  failed: typeof Schema.Number;
-  processed: typeof Schema.Number;
-  total: Schema.optional<typeof Schema.Number>;
+  readonly succeeded: Schema.Number;
+  readonly failed: Schema.Number;
+  readonly processed: Schema.Number;
+  readonly total: Schema.optional<Schema.Number>;
 }>;
 type TaskUnits = typeof TaskUnitsSchema.Type;
 declare const TaskProgressSampleSchema: Schema.Struct<{
-  timestamp: typeof Schema.Number;
-  processed: typeof Schema.Number;
+  readonly timestamp: Schema.Number;
+  readonly processed: Schema.Number;
 }>;
 type TaskProgressSample = typeof TaskProgressSampleSchema.Type;
 declare const TaskSnapshotSchema: Schema.Struct<{
-  id: Schema.brand<typeof Schema.Number, "TaskId">;
-  parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
-  description: typeof Schema.String;
-  status: Schema.Literal<["running", "done", "failed"]>;
-  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
-  transient: typeof Schema.Boolean;
-  units: Schema.Struct<{
-    succeeded: typeof Schema.Number;
-    failed: typeof Schema.Number;
-    processed: typeof Schema.Number;
-    total: Schema.optional<typeof Schema.Number>;
+  readonly id: Schema.brand<Schema.Number, "TaskId">;
+  readonly parentId: Schema.NullOr<Schema.brand<Schema.Number, "TaskId">>;
+  readonly description: Schema.String;
+  readonly status: Schema.Literals<readonly ["running", "done", "failed"]>;
+  readonly countDisplay: Schema.Literals<readonly ["processedOnly", "detailed"]>;
+  readonly transient: Schema.Boolean;
+  readonly units: Schema.Struct<{
+    readonly succeeded: Schema.Number;
+    readonly failed: Schema.Number;
+    readonly processed: Schema.Number;
+    readonly total: Schema.optional<Schema.Number>;
   }>;
-  startedAt: typeof Schema.Number;
-  completedAt: Schema.NullOr<typeof Schema.Number>;
-  progressSamples: Schema.Array$<Schema.Struct<{
-    timestamp: typeof Schema.Number;
-    processed: typeof Schema.Number;
+  readonly startedAt: Schema.Number;
+  readonly completedAt: Schema.NullOr<Schema.Number>;
+  readonly progressSamples: Schema.$Array<Schema.Struct<{
+    readonly timestamp: Schema.Number;
+    readonly processed: Schema.Number;
   }>>;
-  metadata: typeof Schema.Unknown;
+  readonly metadata: Schema.Unknown;
 }>;
 type TaskSnapshot = typeof TaskSnapshotSchema.Type;
 declare const TaskSnapshot: (snapshot: TaskSnapshot) => TaskSnapshot;
@@ -145,7 +145,7 @@ interface TaskStore {
   readonly renderOrder: ReadonlyArray<RenderRow>;
   readonly columns: Map<TaskId, ReadonlyArray<ColumnDef<any, any>>>;
 }
-interface ProgressService {
+interface ProgressShape {
   readonly addTask: (options: AddTaskOptions<any>) => Effect.Effect<TaskId>;
   readonly updateTask: (taskId: TaskId, options: UpdateTaskOptions) => Effect.Effect<void>;
   readonly incrementSucceeded: (taskId: TaskId, amount?: number) => Effect.Effect<void>;
@@ -175,66 +175,54 @@ interface ProgressService {
     }): Effect.Effect<A, E, Exclude<R, Task>>;
   };
 }
-declare const Task_base: Context.TagClass<Task, "stromseng.dev/effective-progress/Task", number & Brand.Brand<"TaskId">>;
+declare const Task_base: Context.ServiceClass<Task, "stromseng.dev/effective-progress/Task", number & Brand.Brand<"TaskId">>;
 declare class Task extends Task_base {}
-declare const TaskAddedEvent_base: Schema.TaggedClass<TaskAddedEvent, "TaskAdded", {
-  readonly _tag: Schema.tag<"TaskAdded">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-  parentId: Schema.NullOr<Schema.brand<typeof Schema.Number, "TaskId">>;
-  description: typeof Schema.String;
-  total: Schema.optional<typeof Schema.Number>;
-  transient: typeof Schema.Boolean;
-  countDisplay: Schema.Literal<["processedOnly", "detailed"]>;
-}>;
+declare const TaskAddedEvent_base: Schema.Class<TaskAddedEvent, Schema.TaggedStruct<"TaskAdded", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+  readonly parentId: Schema.NullOr<Schema.brand<Schema.Number, "TaskId">>;
+  readonly description: Schema.String;
+  readonly total: Schema.optional<Schema.Number>;
+  readonly transient: Schema.Boolean;
+  readonly countDisplay: Schema.Literals<readonly ["processedOnly", "detailed"]>;
+}>, {}>;
 declare class TaskAddedEvent extends TaskAddedEvent_base {}
-declare const TaskUpdatedEvent_base: Schema.TaggedClass<TaskUpdatedEvent, "TaskUpdated", {
-  readonly _tag: Schema.tag<"TaskUpdated">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-  description: Schema.optional<typeof Schema.String>;
-  succeeded: Schema.optional<typeof Schema.Number>;
-  failed: Schema.optional<typeof Schema.Number>;
-  processed: Schema.optional<typeof Schema.Number>;
-  total: Schema.optional<typeof Schema.Number>;
-  transient: Schema.optional<typeof Schema.Boolean>;
-  countDisplay: Schema.optional<Schema.Literal<["processedOnly", "detailed"]>>;
-}>;
+declare const TaskUpdatedEvent_base: Schema.Class<TaskUpdatedEvent, Schema.TaggedStruct<"TaskUpdated", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+  readonly description: Schema.optional<Schema.String>;
+  readonly succeeded: Schema.optional<Schema.Number>;
+  readonly failed: Schema.optional<Schema.Number>;
+  readonly processed: Schema.optional<Schema.Number>;
+  readonly total: Schema.optional<Schema.Number>;
+  readonly transient: Schema.optional<Schema.Boolean>;
+  readonly countDisplay: Schema.optional<Schema.Literals<readonly ["processedOnly", "detailed"]>>;
+}>, {}>;
 declare class TaskUpdatedEvent extends TaskUpdatedEvent_base {}
-declare const TaskAdvancedEvent_base: Schema.TaggedClass<TaskAdvancedEvent, "TaskAdvanced", {
-  readonly _tag: Schema.tag<"TaskAdvanced">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-  amount: typeof Schema.Number;
-  kind: Schema.Literal<["succeeded", "failed"]>;
-}>;
+declare const TaskAdvancedEvent_base: Schema.Class<TaskAdvancedEvent, Schema.TaggedStruct<"TaskAdvanced", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+  readonly amount: Schema.Number;
+  readonly kind: Schema.Literals<readonly ["succeeded", "failed"]>;
+}>, {}>;
 declare class TaskAdvancedEvent extends TaskAdvancedEvent_base {}
-declare const TaskCompletedEvent_base: Schema.TaggedClass<TaskCompletedEvent, "TaskCompleted", {
-  readonly _tag: Schema.tag<"TaskCompleted">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-}>;
+declare const TaskCompletedEvent_base: Schema.Class<TaskCompletedEvent, Schema.TaggedStruct<"TaskCompleted", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+}>, {}>;
 declare class TaskCompletedEvent extends TaskCompletedEvent_base {}
-declare const TaskFailedEvent_base: Schema.TaggedClass<TaskFailedEvent, "TaskFailed", {
-  readonly _tag: Schema.tag<"TaskFailed">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-}>;
+declare const TaskFailedEvent_base: Schema.Class<TaskFailedEvent, Schema.TaggedStruct<"TaskFailed", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+}>, {}>;
 declare class TaskFailedEvent extends TaskFailedEvent_base {}
-declare const TaskRemovedEvent_base: Schema.TaggedClass<TaskRemovedEvent, "TaskRemoved", {
-  readonly _tag: Schema.tag<"TaskRemoved">;
-} & {
-  taskId: Schema.brand<typeof Schema.Number, "TaskId">;
-}>;
+declare const TaskRemovedEvent_base: Schema.Class<TaskRemovedEvent, Schema.TaggedStruct<"TaskRemoved", {
+  readonly taskId: Schema.brand<Schema.Number, "TaskId">;
+}>, {}>;
 declare class TaskRemovedEvent extends TaskRemovedEvent_base {}
-declare const ProgressTaskEventSchema: Schema.Union<[typeof TaskAddedEvent, typeof TaskUpdatedEvent, typeof TaskAdvancedEvent, typeof TaskCompletedEvent, typeof TaskFailedEvent, typeof TaskRemovedEvent]>;
+declare const ProgressTaskEventSchema: Schema.Union<readonly [typeof TaskAddedEvent, typeof TaskUpdatedEvent, typeof TaskAdvancedEvent, typeof TaskCompletedEvent, typeof TaskFailedEvent, typeof TaskRemovedEvent]>;
 type ProgressTaskEvent = typeof ProgressTaskEventSchema.Type;
-declare const decodeProgressTaskEvent: (u: unknown, overrideOptions?: effect_SchemaAST0.ParseOptions) => TaskAddedEvent | TaskUpdatedEvent | TaskAdvancedEvent | TaskCompletedEvent | TaskFailedEvent | TaskRemovedEvent;
+declare const decodeProgressTaskEvent: (input: unknown, options?: effect_SchemaAST0.ParseOptions) => TaskAddedEvent | TaskUpdatedEvent | TaskAdvancedEvent | TaskCompletedEvent | TaskFailedEvent | TaskRemovedEvent;
 //#endregion
 //#region src/services/progress.d.ts
-declare const Progress_base: Context.TagClass<Progress, "stromseng.dev/effective-progress/Progress", ProgressService>;
+declare const Progress_base: Context.ServiceClass<Progress, "stromseng.dev/effective-progress/Progress", ProgressShape>;
 declare class Progress extends Progress_base {
-  static readonly Default: Layer.Layer<Progress, never, never>;
+  static readonly layer: Layer.Layer<Progress, never, never>;
 }
 //#endregion
 //#region src/api.d.ts
@@ -248,15 +236,13 @@ interface PublicTaskApi {
 }
 interface EffectExecutionOptions {
   readonly concurrency?: Concurrency;
-  readonly batching?: boolean | "inherit";
-  readonly concurrentFinalizers?: boolean;
 }
 interface EffectAllExecutionOptions extends EffectExecutionOptions {
   readonly discard?: boolean;
-  readonly mode?: "default" | "validate" | "either";
+  readonly mode?: "default" | "result";
 }
 type AllOptions = Omit<TrackOptions, "total" | "countDisplay"> & EffectAllExecutionOptions;
-type AllReturn<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>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.ExtractMode<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>> : never;
+type AllReturn<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>>] ? Effect.All.ReturnTuple<Arg, Effect.All.IsDiscard<O>, Effect.All.IsResult<O>> : [Arg] extends [Record<string, Effect.Effect<any, any, any>>] ? Effect.All.ReturnObject<Arg, Effect.All.IsDiscard<O>, Effect.All.IsResult<O>> : never] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Exclude<R, Progress | Task>> : never;
 interface ForEachExecutionOptions extends EffectExecutionOptions {
   readonly discard?: false | undefined;
 }
@@ -288,7 +274,7 @@ declare const forEach: {
   <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>>;
 };
 //#endregion
-//#region src/renderer/columns/amount-column.d.ts
+//#region src/services/renderer/columns/amount-column.d.ts
 interface AmountLayout {
   readonly hasDetailedRows: boolean;
   readonly countWidth: number;
@@ -297,12 +283,12 @@ interface AmountLayout {
   readonly preferredWidth: number;
 }
 //#endregion
-//#region src/renderer/columns/bar-column.d.ts
+//#region src/services/renderer/columns/bar-column.d.ts
 interface BarPrepared {
   readonly hasDeterminateRows: boolean;
 }
 //#endregion
-//#region src/renderer/columns/description-column.d.ts
+//#region src/services/renderer/columns/description-column.d.ts
 interface DescriptionPrepared {
   readonly minTreeWidth: number;
   readonly preferredWidth: number;
@@ -337,13 +323,13 @@ declare const defaults: () => ReadonlyArray<ColumnDef<any, any>>;
 declare const resolveColumnSizeValue: <P>(value: ColumnSizeValue<P> | undefined, prepared: P) => number | undefined;
 //#endregion
 //#region src/services/stdio.d.ts
-interface ProgressStdioService {
+interface ProgressStdioShape {
   readonly stdout: NodeJS.WriteStream;
   readonly stderr: NodeJS.WriteStream;
 }
-declare const ProgressStdio_base: Context.TagClass<ProgressStdio, "stromseng.dev/effective-progress/ProgressStdio", ProgressStdioService>;
+declare const ProgressStdio_base: Context.ServiceClass<ProgressStdio, "stromseng.dev/effective-progress/ProgressStdio", ProgressStdioShape>;
 declare class ProgressStdio extends ProgressStdio_base {
-  static readonly Default: Layer.Layer<ProgressStdio, never, never>;
+  static readonly layer: Layer.Layer<ProgressStdio, never, never>;
 }
 //#endregion
-export { AddTaskOptions, AllOptions, AllReturn, CellInfo, ColumnAlign, ColumnDef, ColumnRenderContext, ColumnSizeValue, columns_d_exports as Columns, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, Progress, ProgressService, ProgressStdio, ProgressStdioService, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskHandle, TaskId, TaskOptions, TaskProgressSample, TaskProgressSampleSchema, TaskRemovedEvent, TaskRowDerived, TaskSnapshot, TaskSnapshotSchema, TaskStatus, TaskStatusSchema, TaskStore, TaskTreeInfo, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task$1 as task };
+export { AddTaskOptions, AllOptions, AllReturn, CellInfo, ColumnAlign, ColumnDef, ColumnRenderContext, ColumnSizeValue, columns_d_exports as Columns, EffectAllExecutionOptions, EffectExecutionOptions, ForEachExecutionOptions, ForEachOptions, Progress, ProgressShape, ProgressStdio, ProgressStdioShape, ProgressTaskEvent, ProgressTaskEventSchema, RenderRow, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskCountDisplay, TaskCountDisplaySchema, TaskFailedEvent, TaskHandle, TaskId, TaskOptions, TaskProgressSample, TaskProgressSampleSchema, TaskRemovedEvent, TaskRowDerived, TaskSnapshot, TaskSnapshotSchema, TaskStatus, TaskStatusSchema, TaskStore, TaskTreeInfo, TaskUnits, TaskUnitsSchema, TaskUpdatedEvent, TrackOptions, UpdateTaskOptions, all, decodeProgressTaskEvent, forEach, task$1 as task };