effective-progress 0.11.1 → 0.12.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
-import { Brand, Cause, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Schema } from "effect";
+import { Brand, Cause, Clock, Context, Effect, Exit, Layer, Option, Queue, Schema } from "effect";
 import { dual } from "effect/Function";
 import { Box, Text, render, useBoxMetrics } from "ink";
-import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createContext, use, useEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import cliSpinners from "cli-spinners";
 import stringWidth from "fast-string-width";
@@ -10,8 +10,12 @@ import stringWidth from "fast-string-width";
 //#region src/types.ts
 const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
 const TaskId = Brand.nominal();
-const TaskStatusSchema = Schema.Literal("running", "done", "failed");
-const TaskCountDisplaySchema = Schema.Literal("processedOnly", "detailed");
+const TaskStatusSchema = Schema.Literals([
+	"running",
+	"done",
+	"failed"
+]);
+const TaskCountDisplaySchema = Schema.Literals(["processedOnly", "detailed"]);
 const TaskUnitsSchema = Schema.Struct({
 	succeeded: Schema.Number,
 	failed: Schema.Number,
@@ -36,7 +40,7 @@ const TaskSnapshotSchema = Schema.Struct({
 	metadata: Schema.Unknown
 });
 const TaskSnapshot = (snapshot) => snapshot;
-var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
+var Task = class extends Context.Service()("stromseng.dev/effective-progress/Task") {};
 var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
 	taskId: TaskIdSchema,
 	parentId: Schema.NullOr(TaskIdSchema),
@@ -58,27 +62,30 @@ var TaskUpdatedEvent = class extends Schema.TaggedClass()("TaskUpdated", {
 var TaskAdvancedEvent = class extends Schema.TaggedClass()("TaskAdvanced", {
 	taskId: TaskIdSchema,
 	amount: Schema.Number,
-	kind: Schema.Literal("succeeded", "failed")
+	kind: Schema.Literals(["succeeded", "failed"])
 }) {};
 var TaskCompletedEvent = class extends Schema.TaggedClass()("TaskCompleted", { taskId: TaskIdSchema }) {};
 var TaskFailedEvent = class extends Schema.TaggedClass()("TaskFailed", { taskId: TaskIdSchema }) {};
 var TaskRemovedEvent = class extends Schema.TaggedClass()("TaskRemoved", { taskId: TaskIdSchema }) {};
-const ProgressTaskEventSchema = Schema.Union(TaskAddedEvent, TaskUpdatedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskRemovedEvent);
+const ProgressTaskEventSchema = Schema.Union([
+	TaskAddedEvent,
+	TaskUpdatedEvent,
+	TaskAdvancedEvent,
+	TaskCompletedEvent,
+	TaskFailedEvent,
+	TaskRemovedEvent
+]);
 const decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);
 
 //#endregion
-//#region src/renderer/store.ts
+//#region src/services/store/store.ts
 const ETA_SAMPLE_WINDOW_MILLIS = 3e4;
 const ETA_SAMPLE_MAX_LENGTH = 1e3;
 const hasExplicitTotal = (options) => Object.prototype.hasOwnProperty.call(options, "total");
-const sanitizeTotalOnAdd = (total) => {
+const sanitizeTotal = (total) => {
 	if (total === void 0) return;
 	return total < 0 ? void 0 : total;
 };
-const sanitizeTotalOnUpdate = (nextTotal) => {
-	if (nextTotal === void 0) return;
-	return nextTotal < 0 ? void 0 : nextTotal;
-};
 const normalizeUnits = (counts) => {
 	const succeeded = Math.max(0, counts.succeeded);
 	const failed = Math.max(0, counts.failed);
@@ -103,12 +110,13 @@ const appendProgressSample = (samples, now, processed) => {
 	const previousSamples = samples ?? [];
 	if (previousSamples.at(-1)?.processed === processed) return previousSamples;
 	const windowStart = now - ETA_SAMPLE_WINDOW_MILLIS;
-	const nextSamples = [...previousSamples, {
+	const appendedLength = previousSamples.length + 1;
+	let firstRetainedIndex = Math.max(0, appendedLength - ETA_SAMPLE_MAX_LENGTH);
+	while (firstRetainedIndex + 1 < previousSamples.length && previousSamples[firstRetainedIndex + 1].timestamp < windowStart) firstRetainedIndex++;
+	return [...previousSamples.slice(firstRetainedIndex), {
 		timestamp: now,
 		processed
 	}];
-	while (nextSamples.length > 2 && (nextSamples.length > ETA_SAMPLE_MAX_LENGTH || nextSamples[1].timestamp < windowStart)) nextSamples.shift();
-	return nextSamples;
 };
 /** Applies mutable task fields and records a progress sample when the processed count changes. */
 const updatedSnapshot = (snapshot, options, now) => {
@@ -116,7 +124,7 @@ const updatedSnapshot = (snapshot, options, now) => {
 	const units = options.succeeded === void 0 && options.failed === void 0 && options.total === void 0 && !hasExplicitTotal(options) ? currentUnits : normalizeUnits({
 		succeeded: options.succeeded ?? currentUnits.succeeded,
 		failed: options.failed ?? currentUnits.failed,
-		total: hasExplicitTotal(options) ? sanitizeTotalOnUpdate(options.total) : currentUnits.total
+		total: hasExplicitTotal(options) ? sanitizeTotal(options.total) : currentUnits.total
 	});
 	return TaskSnapshot({
 		...snapshot,
@@ -163,8 +171,19 @@ const subtreeTaskIds = (renderOrder, taskId) => {
 	while (end < renderOrder.length && renderOrder[end].depth > taskDepth) end++;
 	return renderOrder.slice(idx, end).map((row) => row.id);
 };
+const removeTransientSubtree = (current, nextTasks, taskId) => {
+	const removedTaskIds = subtreeTaskIds(current.renderOrder, taskId);
+	for (const removedTaskId of removedTaskIds) nextTasks.delete(removedTaskId);
+	const nextColumns = new Map(current.columns);
+	for (const removedTaskId of removedTaskIds) nextColumns.delete(removedTaskId);
+	return {
+		removedTaskIds,
+		renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
+		columns: nextColumns
+	};
+};
 const SNAPSHOT_PUBLISH_INTERVAL_MILLIS = 100;
-const makeProgressRenderStore = () => {
+const makeProgressStoreRuntime = (publishQueue) => {
 	let nextTaskId = 0;
 	let state = {
 		tasks: /* @__PURE__ */ new Map(),
@@ -177,13 +196,13 @@ const makeProgressRenderStore = () => {
 		events: []
 	};
 	let hasPendingPublish = false;
-	let lastPublishAt = 0;
-	let publishTimeout;
+	let lastPublishAt = -SNAPSHOT_PUBLISH_INTERVAL_MILLIS;
+	let latestObservedAt = 0;
 	const listeners = /* @__PURE__ */ new Set();
 	const notifyListeners = () => {
 		for (const listener of listeners) listener();
 	};
-	const publishNow = () => {
+	const publishNow = (publishedAt) => {
 		const nextPublication = {
 			snapshot: state,
 			events: [...pendingEvents]
@@ -192,350 +211,351 @@ const makeProgressRenderStore = () => {
 		publishedPublication = nextPublication;
 		notifyListeners();
 		pendingEvents = [];
-		lastPublishAt = Date.now();
-	};
-	const clearScheduledPublish = () => {
-		if (publishTimeout === void 0) return;
-		clearTimeout(publishTimeout);
-		publishTimeout = void 0;
+		lastPublishAt = publishedAt;
 	};
-	const schedulePublish = () => {
-		if (!hasPendingPublish) return;
-		const now = Date.now();
+	const publisherLoop = Effect.forever(Effect.gen(function* () {
+		yield* Queue.take(publishQueue);
+		const now = yield* Clock.currentTimeMillis;
 		const waitMillis = Math.max(0, SNAPSHOT_PUBLISH_INTERVAL_MILLIS - (now - lastPublishAt));
-		if (waitMillis === 0) {
-			clearScheduledPublish();
-			publishNow();
+		if (waitMillis > 0) yield* Effect.sleep(waitMillis);
+		if (!hasPendingPublish) return;
+		publishNow(yield* Clock.currentTimeMillis);
+	}));
+	const schedulePublish = Effect.gen(function* () {
+		if (!hasPendingPublish) return;
+		const now = yield* Clock.currentTimeMillis;
+		if (Math.max(0, SNAPSHOT_PUBLISH_INTERVAL_MILLIS - (now - lastPublishAt)) === 0) {
+			publishNow(now);
 			return;
 		}
-		if (publishTimeout !== void 0) return;
-		publishTimeout = setTimeout(() => {
-			publishTimeout = void 0;
-			if (!hasPendingPublish) return;
-			publishNow();
-		}, waitMillis);
-	};
-	const publish = (update) => {
-		if (update.state === state) return;
+		yield* Queue.offer(publishQueue, void 0);
+	});
+	const publish = (update, now) => {
+		if (update.state === state) return Effect.void;
+		latestObservedAt = now;
 		state = update.state;
 		if (update.events.length > 0) pendingEvents.push(...update.events);
 		hasPendingPublish = true;
-		schedulePublish();
+		return schedulePublish;
 	};
-	const updateState = (transform) => {
-		publish(transform(state));
+	const updateState = (transform, now) => {
+		return publish(transform(state), now);
 	};
 	return {
-		getSnapshot: () => publishedPublication,
-		subscribe: (listener) => {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		flush: () => {
-			if (!hasPendingPublish) return;
-			clearScheduledPublish();
-			publishNow();
-		},
-		addTask: (options) => Effect.gen(function* () {
-			const taskId = TaskId(++nextTaskId);
-			const units = normalizeUnits({
-				succeeded: 0,
-				failed: 0,
-				total: sanitizeTotalOnAdd(options.total)
-			});
-			const parentSnapshot = options.parentId === void 0 ? void 0 : state.tasks.get(options.parentId);
-			const now = yield* Clock.currentTimeMillis;
-			const parentId = options.parentId ?? null;
-			const countDisplay = options.countDisplay ?? parentSnapshot?.countDisplay ?? "detailed";
-			const task = TaskSnapshot({
-				id: taskId,
-				parentId,
-				description: options.description,
-				status: "running",
-				countDisplay,
-				transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
-				units,
-				startedAt: now,
-				completedAt: null,
-				progressSamples: [{
-					timestamp: now,
-					processed: units.processed
-				}],
-				metadata: options.metadata
-			});
-			updateState((current) => {
-				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, task);
-				const { index, depth } = findInsertionIndex(current.renderOrder, parentId);
-				const nextRenderOrder = [...current.renderOrder];
-				nextRenderOrder.splice(index, 0, {
-					id: taskId,
-					depth
-				});
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: nextRenderOrder,
-						columns: options.columns ? new Map(current.columns).set(taskId, options.columns) : current.columns
-					},
-					events: [new TaskAddedEvent({
-						taskId,
-						parentId,
-						description: task.description,
-						total: task.units.total,
-						transient: task.transient,
-						countDisplay: task.countDisplay
-					})]
-				};
-			});
-			return taskId;
-		}),
-		updateTask: (taskId, options) => Effect.gen(function* () {
-			const now = yield* Clock.currentTimeMillis;
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
-				};
-				const nextTask = updatedSnapshot(currentTask, options, now);
-				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, nextTask);
-				const events = [new TaskUpdatedEvent({
-					taskId,
-					description: options.description ?? void 0,
-					succeeded: options.succeeded ?? void 0,
-					failed: options.failed ?? void 0,
-					processed: options.succeeded !== void 0 || options.failed !== void 0 ? nextTask.units.processed : void 0,
-					total: hasExplicitTotal(options) ? nextTask.units.total : void 0,
-					transient: options.transient ?? void 0,
-					countDisplay: options.countDisplay ?? void 0
-				})];
-				if (options.transient !== void 0) for (const candidateId of subtreeTaskIds(current.renderOrder, taskId).slice(1)) {
-					const candidate = current.tasks.get(candidateId);
-					if (!candidate) continue;
-					const nextCandidate = TaskSnapshot({
-						...candidate,
-						transient: nextTask.transient
-					});
-					nextTasks.set(candidateId, nextCandidate);
-					events.push(new TaskUpdatedEvent({
-						taskId: candidateId,
-						transient: nextCandidate.transient
-					}));
-				}
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events
-				};
-			});
-		}),
-		incrementSucceeded: (taskId, amount = 1) => Effect.gen(function* () {
-			const now = yield* Clock.currentTimeMillis;
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
+		store: {
+			getSnapshot: () => publishedPublication,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
 				};
+			},
+			flush: () => {
+				if (!hasPendingPublish) return;
+				publishNow(latestObservedAt);
+			},
+			addTask: (options) => Effect.gen(function* () {
+				const taskId = TaskId(++nextTaskId);
 				const units = normalizeUnits({
-					succeeded: currentTask.units.succeeded + amount,
-					failed: currentTask.units.failed,
-					total: currentTask.units.total
+					succeeded: 0,
+					failed: 0,
+					total: sanitizeTotal(options.total)
 				});
-				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, TaskSnapshot({
-					...currentTask,
+				const parentSnapshot = options.parentId === void 0 ? void 0 : state.tasks.get(options.parentId);
+				const now = yield* Clock.currentTimeMillis;
+				const parentId = options.parentId ?? null;
+				const countDisplay = options.countDisplay ?? parentSnapshot?.countDisplay ?? "detailed";
+				const task = TaskSnapshot({
+					id: taskId,
+					parentId,
+					description: options.description,
+					status: "running",
+					countDisplay,
+					transient: (parentSnapshot?.transient ?? false) || (options.transient ?? false),
 					units,
-					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
-				}));
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events: [new TaskAdvancedEvent({
-						taskId,
-						amount,
-						kind: "succeeded"
-					})]
-				};
-			});
-		}),
-		incrementFailed: (taskId, amount = 1) => Effect.gen(function* () {
-			const now = yield* Clock.currentTimeMillis;
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
-				};
-				const units = normalizeUnits({
-					succeeded: currentTask.units.succeeded,
-					failed: currentTask.units.failed + amount,
-					total: currentTask.units.total
+					startedAt: now,
+					completedAt: null,
+					progressSamples: [{
+						timestamp: now,
+						processed: units.processed
+					}],
+					metadata: options.metadata
 				});
-				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, TaskSnapshot({
-					...currentTask,
-					units,
-					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
-				}));
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events: [new TaskAdvancedEvent({
+				yield* updateState((current) => {
+					const nextTasks = new Map(current.tasks);
+					nextTasks.set(taskId, task);
+					const { index, depth } = findInsertionIndex(current.renderOrder, parentId);
+					const nextRenderOrder = [...current.renderOrder];
+					nextRenderOrder.splice(index, 0, {
+						id: taskId,
+						depth
+					});
+					return {
+						state: {
+							tasks: nextTasks,
+							renderOrder: nextRenderOrder,
+							columns: options.columns ? new Map(current.columns).set(taskId, options.columns) : current.columns
+						},
+						events: [new TaskAddedEvent({
+							taskId,
+							parentId,
+							description: task.description,
+							total: task.units.total,
+							transient: task.transient,
+							countDisplay: task.countDisplay
+						})]
+					};
+				}, now);
+				return taskId;
+			}),
+			updateTask: (taskId, options) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					const nextTask = updatedSnapshot(currentTask, options, now);
+					const nextTasks = new Map(current.tasks);
+					nextTasks.set(taskId, nextTask);
+					const events = [new TaskUpdatedEvent({
 						taskId,
-						amount,
-						kind: "failed"
-					})]
-				};
-			});
-		}),
-		completeTask: (taskId) => Effect.gen(function* () {
-			const now = yield* Clock.currentTimeMillis;
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
-				};
-				if (currentTask.status !== "running") return {
-					state: current,
-					events: []
-				};
-				const nextTasks = new Map(current.tasks);
-				if (currentTask.transient) {
-					const removedTaskIds = subtreeTaskIds(current.renderOrder, taskId);
-					for (const removedTaskId of removedTaskIds) nextTasks.delete(removedTaskId);
-					const nextColumns = new Map(current.columns);
-					for (const removedTaskId of removedTaskIds) nextColumns.delete(removedTaskId);
+						description: options.description ?? void 0,
+						succeeded: options.succeeded ?? void 0,
+						failed: options.failed ?? void 0,
+						processed: options.succeeded !== void 0 || options.failed !== void 0 ? nextTask.units.processed : void 0,
+						total: hasExplicitTotal(options) ? nextTask.units.total : void 0,
+						transient: options.transient ?? void 0,
+						countDisplay: options.countDisplay ?? void 0
+					})];
+					if (options.transient !== void 0) for (const candidateId of subtreeTaskIds(current.renderOrder, taskId).slice(1)) {
+						const candidate = current.tasks.get(candidateId);
+						if (!candidate) continue;
+						const nextCandidate = TaskSnapshot({
+							...candidate,
+							transient: nextTask.transient
+						});
+						nextTasks.set(candidateId, nextCandidate);
+						events.push(new TaskUpdatedEvent({
+							taskId: candidateId,
+							transient: nextCandidate.transient
+						}));
+					}
 					return {
 						state: {
 							tasks: nextTasks,
-							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
-							columns: nextColumns
+							renderOrder: current.renderOrder,
+							columns: current.columns
 						},
-						events: [new TaskCompletedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
+						events
 					};
-				}
-				const units = currentTask.units.total !== void 0 ? currentTask.units.processed < currentTask.units.total ? normalizeUnits({
-					succeeded: currentTask.units.succeeded + (currentTask.units.total - currentTask.units.processed),
-					failed: currentTask.units.failed,
-					total: currentTask.units.total
-				}) : currentTask.units : currentTask.units.processed > 0 ? normalizeUnits({
-					succeeded: currentTask.units.succeeded,
-					failed: currentTask.units.failed,
-					total: currentTask.units.processed
-				}) : currentTask.units;
-				nextTasks.set(taskId, TaskSnapshot({
-					...currentTask,
-					status: "done",
-					units,
-					completedAt: now,
-					progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
-				}));
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events: [new TaskCompletedEvent({ taskId })]
-				};
-			});
-		}),
-		failTask: (taskId) => Effect.gen(function* () {
-			const now = yield* Clock.currentTimeMillis;
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
-				};
-				if (currentTask.status !== "running") return {
-					state: current,
-					events: []
-				};
-				const nextTasks = new Map(current.tasks);
-				if (currentTask.transient) {
-					const removedTaskIds = subtreeTaskIds(current.renderOrder, taskId);
-					for (const removedTaskId of removedTaskIds) nextTasks.delete(removedTaskId);
-					const nextColumns = new Map(current.columns);
-					for (const removedTaskId of removedTaskIds) nextColumns.delete(removedTaskId);
+				}, now);
+			}),
+			incrementSucceeded: (taskId, amount = 1) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					const units = normalizeUnits({
+						succeeded: currentTask.units.succeeded + amount,
+						failed: currentTask.units.failed,
+						total: currentTask.units.total
+					});
+					const nextTasks = new Map(current.tasks);
+					nextTasks.set(taskId, TaskSnapshot({
+						...currentTask,
+						units,
+						progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
+					}));
 					return {
 						state: {
 							tasks: nextTasks,
-							renderOrder: removeFromRenderOrder(current.renderOrder, taskId),
-							columns: nextColumns
+							renderOrder: current.renderOrder,
+							columns: current.columns
 						},
-						events: [new TaskFailedEvent({ taskId }), ...removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
+						events: [new TaskAdvancedEvent({
+							taskId,
+							amount,
+							kind: "succeeded"
+						})]
 					};
-				}
-				nextTasks.set(taskId, TaskSnapshot({
-					...currentTask,
-					status: "failed",
-					completedAt: now
-				}));
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events: [new TaskFailedEvent({ taskId })]
-				};
-			});
-		}),
-		getTask: (taskId) => Effect.sync(() => Option.fromNullable(state.tasks.get(taskId))),
-		listTasks: Effect.sync(() => Array.from(state.tasks.values())),
-		setMetadata: (taskId, metadata) => Effect.sync(() => {
-			updateState((current) => {
-				const currentTask = current.tasks.get(taskId);
-				if (!currentTask) return {
-					state: current,
-					events: []
-				};
-				const nextTasks = new Map(current.tasks);
-				nextTasks.set(taskId, TaskSnapshot({
-					...currentTask,
-					metadata
-				}));
-				return {
-					state: {
-						tasks: nextTasks,
-						renderOrder: current.renderOrder,
-						columns: current.columns
-					},
-					events: []
-				};
-			});
-		}),
-		getMetadata: (taskId) => Effect.sync(() => {
-			return state.tasks.get(taskId)?.metadata;
-		})
+				}, now);
+			}),
+			incrementFailed: (taskId, amount = 1) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					const units = normalizeUnits({
+						succeeded: currentTask.units.succeeded,
+						failed: currentTask.units.failed + amount,
+						total: currentTask.units.total
+					});
+					const nextTasks = new Map(current.tasks);
+					nextTasks.set(taskId, TaskSnapshot({
+						...currentTask,
+						units,
+						progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
+					}));
+					return {
+						state: {
+							tasks: nextTasks,
+							renderOrder: current.renderOrder,
+							columns: current.columns
+						},
+						events: [new TaskAdvancedEvent({
+							taskId,
+							amount,
+							kind: "failed"
+						})]
+					};
+				}, now);
+			}),
+			completeTask: (taskId) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					if (currentTask.status !== "running") return {
+						state: current,
+						events: []
+					};
+					const nextTasks = new Map(current.tasks);
+					if (currentTask.transient) {
+						const removedSubtree = removeTransientSubtree(current, nextTasks, taskId);
+						return {
+							state: {
+								tasks: nextTasks,
+								renderOrder: removedSubtree.renderOrder,
+								columns: removedSubtree.columns
+							},
+							events: [new TaskCompletedEvent({ taskId }), ...removedSubtree.removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
+						};
+					}
+					const units = currentTask.units.total !== void 0 ? currentTask.units.processed < currentTask.units.total ? normalizeUnits({
+						succeeded: currentTask.units.succeeded + (currentTask.units.total - currentTask.units.processed),
+						failed: currentTask.units.failed,
+						total: currentTask.units.total
+					}) : currentTask.units : currentTask.units.processed > 0 ? normalizeUnits({
+						succeeded: currentTask.units.succeeded,
+						failed: currentTask.units.failed,
+						total: currentTask.units.processed
+					}) : currentTask.units;
+					nextTasks.set(taskId, TaskSnapshot({
+						...currentTask,
+						status: "done",
+						units,
+						completedAt: now,
+						progressSamples: appendProgressSample(currentTask.progressSamples, now, units.processed)
+					}));
+					return {
+						state: {
+							tasks: nextTasks,
+							renderOrder: current.renderOrder,
+							columns: current.columns
+						},
+						events: [new TaskCompletedEvent({ taskId })]
+					};
+				}, now);
+			}),
+			failTask: (taskId) => Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					if (currentTask.status !== "running") return {
+						state: current,
+						events: []
+					};
+					const nextTasks = new Map(current.tasks);
+					if (currentTask.transient) {
+						const removedSubtree = removeTransientSubtree(current, nextTasks, taskId);
+						return {
+							state: {
+								tasks: nextTasks,
+								renderOrder: removedSubtree.renderOrder,
+								columns: removedSubtree.columns
+							},
+							events: [new TaskFailedEvent({ taskId }), ...removedSubtree.removedTaskIds.map((removedTaskId) => new TaskRemovedEvent({ taskId: removedTaskId }))]
+						};
+					}
+					nextTasks.set(taskId, TaskSnapshot({
+						...currentTask,
+						status: "failed",
+						completedAt: now
+					}));
+					return {
+						state: {
+							tasks: nextTasks,
+							renderOrder: current.renderOrder,
+							columns: current.columns
+						},
+						events: [new TaskFailedEvent({ taskId })]
+					};
+				}, now);
+			}),
+			getTask: (taskId) => Effect.sync(() => Option.fromNullishOr(state.tasks.get(taskId))),
+			listTasks: Effect.sync(() => Array.from(state.tasks.values())),
+			setMetadata: (taskId, metadata) => Effect.gen(function* () {
+				yield* updateState((current) => {
+					const currentTask = current.tasks.get(taskId);
+					if (!currentTask) return {
+						state: current,
+						events: []
+					};
+					const nextTasks = new Map(current.tasks);
+					nextTasks.set(taskId, TaskSnapshot({
+						...currentTask,
+						metadata
+					}));
+					return {
+						state: {
+							tasks: nextTasks,
+							renderOrder: current.renderOrder,
+							columns: current.columns
+						},
+						events: []
+					};
+				}, yield* Clock.currentTimeMillis);
+			}),
+			getMetadata: (taskId) => Effect.sync(() => {
+				return state.tasks.get(taskId)?.metadata;
+			})
+		},
+		publisherLoop
 	};
 };
+const makeProgressStore = Effect.gen(function* () {
+	const runtime = makeProgressStoreRuntime(yield* Queue.sliding(1));
+	yield* Effect.forkDetach(runtime.publisherLoop);
+	return runtime.store;
+});
+var ProgressStore = class ProgressStore extends Context.Service()("stromseng.dev/effective-progress/ProgressStore") {
+	static layer = Layer.effect(ProgressStore, makeProgressStore);
+};
 
 //#endregion
-//#region src/renderer/hooks/use-now-clock.ts
+//#region src/services/renderer/hooks/use-now-clock.ts
 const useNowClock = (active, intervalMillis) => {
-	const [now, setNow] = useState(() => Date.now());
+	const [now, updateNow] = useReducer(() => Date.now(), void 0, Date.now);
 	useEffect(() => {
 		if (!active) return;
-		setNow(Date.now());
+		updateNow();
 		const interval = setInterval(() => {
-			setNow(Date.now());
+			updateNow();
 		}, intervalMillis);
 		return () => {
 			clearInterval(interval);
@@ -545,7 +565,7 @@ const useNowClock = (active, intervalMillis) => {
 };
 
 //#endregion
-//#region src/renderer/context/now-context.tsx
+//#region src/services/renderer/context/now-context.tsx
 const NOW_INTERVAL_MILLIS = 1e3;
 const NowContext = createContext(Date.now());
 const NowProvider = ({ active, children, nowOverride }) => {
@@ -556,10 +576,10 @@ const NowProvider = ({ active, children, nowOverride }) => {
 		children
 	});
 };
-const useNow = () => useContext(NowContext);
+const useNow = () => use(NowContext);
 
 //#endregion
-//#region src/renderer/hooks/use-spinner-clock.ts
+//#region src/services/renderer/hooks/use-spinner-clock.ts
 const normalizeIntervalMillis = (intervalMillis) => Math.max(1, intervalMillis);
 const getSpinnerTickAtTime = (baseTick, startedAt, now, intervalMillis) => {
 	const elapsedMillis = Math.max(0, now - startedAt);
@@ -590,7 +610,7 @@ const useSpinnerClock = (active, intervalMillis) => {
 };
 
 //#endregion
-//#region src/renderer/context/spinner-context.tsx
+//#region src/services/renderer/context/spinner-context.tsx
 const DEFAULT_SPINNER_INTERVAL_MILLIS = cliSpinners.dots.interval;
 const SpinnerContext = createContext(0);
 const SpinnerProvider = ({ active, children, intervalMillis = DEFAULT_SPINNER_INTERVAL_MILLIS, tickOverride }) => {
@@ -601,14 +621,14 @@ const SpinnerProvider = ({ active, children, intervalMillis = DEFAULT_SPINNER_IN
 		children
 	});
 };
-const useSpinnerTick = () => useContext(SpinnerContext);
+const useSpinnerTick = () => use(SpinnerContext);
 
 //#endregion
-//#region src/renderer/shared/determinate.ts
+//#region src/services/renderer/shared/determinate.ts
 const isDeterminate$2 = (task) => task.units.total !== void 0;
 
 //#endregion
-//#region src/renderer/shared/format.ts
+//#region src/services/renderer/shared/format.ts
 const isDeterminate$1 = (task) => task.units.total !== void 0;
 const showsUnknownTotalCounts = (task) => task.units.total === void 0 && task.units.processed > 0;
 const formatDurationSeconds = (seconds) => {
@@ -656,7 +676,7 @@ const formatElapsed = (task, now) => {
 const formatElapsedClock = (task, now) => {
 	return formatClockDurationSeconds(Math.max(0, (task.completedAt ?? now) - task.startedAt) / 1e3);
 };
-const formatEta = (task, now) => {
+const formatEta = (task) => {
 	if (task.status !== "running" || !isDeterminate$1(task)) return "";
 	const { processed, total } = task.units;
 	const remaining = total - processed;
@@ -665,7 +685,7 @@ const formatEta = (task, now) => {
 	if (etaMillis === void 0) return "";
 	return formatClockDurationSeconds(etaMillis / 1e3);
 };
-const formatEtaClock = (task, now) => {
+const formatEtaClock = (task) => {
 	if (task.status !== "running" || !isDeterminate$1(task)) return;
 	const { processed, total } = task.units;
 	const remaining = total - processed;
@@ -674,7 +694,7 @@ const formatEtaClock = (task, now) => {
 	if (etaMillis === void 0) return;
 	return formatClockDurationSeconds(etaMillis / 1e3);
 };
-const formatElapsedEta = (task, now) => `${formatElapsedClock(task, now)}<${formatEtaClock(task, now) ?? "00:00"}`;
+const formatElapsedEta = (task, now) => `${formatElapsedClock(task, now)}<${formatEtaClock(task) ?? "00:00"}`;
 const formatDeterminateAmountParts = (task) => {
 	if (!isDeterminate$1(task)) return;
 	const totalText = `${task.units.total}`;
@@ -703,7 +723,7 @@ const formatAmount = (task, _tick) => {
 };
 
 //#endregion
-//#region src/renderer/shared/text-width.ts
+//#region src/services/renderer/shared/text-width.ts
 const WIDTH_CACHE_LIMIT = 8192;
 const widthCache = /* @__PURE__ */ new Map();
 const textWidth = (text) => {
@@ -716,7 +736,7 @@ const textWidth = (text) => {
 };
 
 //#endregion
-//#region src/renderer/columns/amount-column.tsx
+//#region src/services/renderer/columns/amount-column.tsx
 const hasUnknownTotalCounts = (task) => task.units.total === void 0 && task.units.processed > 0;
 const hasCountedAmount = (task) => isDeterminate$2(task) || hasUnknownTotalCounts(task);
 const totalTextFor = (task) => task.units.total === void 0 ? "?" : `${task.units.total}`;
@@ -752,7 +772,7 @@ const measureAmountLayout = (rows) => {
 		}, countedWidth)
 	};
 };
-const renderAmount = (task, layout) => {
+const AmountValue = ({ task, layout }) => {
 	if (!hasCountedAmount(task)) return formatAmount(task, 0);
 	const processed = `${task.units.processed}`.padStart(layout.processedWidth, " ");
 	const total = totalTextFor(task).padStart(layout.totalWidth, " ");
@@ -775,16 +795,19 @@ const renderAmount = (task, layout) => {
 };
 const AmountCell = ({ task, layout }) => /* @__PURE__ */ jsx(Text, {
 	wrap: "truncate-end",
-	children: renderAmount(task, layout)
+	children: /* @__PURE__ */ jsx(AmountValue, {
+		task,
+		layout
+	})
 });
 
 //#endregion
-//#region src/renderer/columns/bar-column.tsx
+//#region src/services/renderer/columns/bar-column.tsx
 const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
 const prepareBar = (rows) => {
 	return { hasDeterminateRows: rows.some((row) => row.derived.isDeterminate) };
 };
-const renderProgressBar = (task, width) => {
+const ProgressBarSegments = ({ task, width }) => {
 	if (!isDeterminate$2(task)) return /* @__PURE__ */ jsx(Text, { children: ` `.repeat(Math.max(0, width)) });
 	const displayTotal = Math.max(task.units.total, task.units.succeeded + task.units.failed);
 	const succeededEnd = displayTotal === 0 ? width : Math.round(task.units.succeeded / displayTotal * width);
@@ -812,11 +835,14 @@ const renderProgressBar = (task, width) => {
 };
 const BarCell = ({ task, width }) => /* @__PURE__ */ jsx(Text, {
 	wrap: "truncate-end",
-	children: renderProgressBar(task, width ?? 0)
+	children: /* @__PURE__ */ jsx(ProgressBarSegments, {
+		task,
+		width: width ?? 0
+	})
 });
 
 //#endregion
-//#region src/renderer/columns/description-column.tsx
+//#region src/services/renderer/columns/description-column.tsx
 const MIN_TREE_DESCRIPTION_TEXT_WIDTH = 6;
 const DEFAULT_SPINNER_TYPE = "dots";
 const isDeterminate = (task) => task.units.total !== void 0;
@@ -894,7 +920,7 @@ const DescriptionCell = ({ cell, width, minTreeWidth, spinnerTick }) => {
 };
 
 //#endregion
-//#region src/renderer/columns/elapsed-eta-column.tsx
+//#region src/services/renderer/columns/elapsed-eta-column.tsx
 const ElapsedEtaCell = ({ task, now }) => {
 	return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
@@ -904,7 +930,7 @@ const ElapsedEtaCell = ({ task, now }) => {
 };
 
 //#endregion
-//#region src/renderer/columns/elapsed-column.tsx
+//#region src/services/renderer/columns/elapsed-column.tsx
 const ElapsedCell = ({ task, now }) => {
 	return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
@@ -914,9 +940,9 @@ const ElapsedCell = ({ task, now }) => {
 };
 
 //#endregion
-//#region src/renderer/columns/eta-column.tsx
-const EtaCell = ({ task, now }) => {
-	const eta = formatEta(task, now);
+//#region src/services/renderer/columns/eta-column.tsx
+const EtaCell = ({ task }) => {
+	const eta = formatEta(task);
 	if (eta === "") return null;
 	return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
@@ -1006,10 +1032,7 @@ const eta = () => ({
 	align: "right",
 	flexShrink: 0,
 	minWidth: 8,
-	render: ({ task }, ctx) => /* @__PURE__ */ jsx(EtaCell, {
-		task,
-		now: ctx.now
-	})
+	render: ({ task }) => /* @__PURE__ */ jsx(EtaCell, { task })
 });
 const defaults = () => [
 	description(),
@@ -1023,7 +1046,7 @@ const resolveColumnSizeValue = (value, prepared) => {
 };
 
 //#endregion
-//#region src/renderer/column-resolver.ts
+//#region src/services/renderer/column-resolver.ts
 const NO_PREPARE = Symbol("no-prepare");
 const getColumnsForRow = (row, columns) => columns.get(row.task.id) ?? defaults();
 const toCellInfo = (row) => row;
@@ -1077,13 +1100,13 @@ const resolveColumns = (rows, columns) => {
 };
 
 //#endregion
-//#region src/renderer/public-api.tsx
+//#region src/services/renderer/public-api.tsx
 const justifyContentForAlign = (align) => {
 	if (align === "right") return "flex-end";
 	if (align === "center") return "center";
 	return "flex-start";
 };
-const renderNode = (node) => {
+const RenderedNode = ({ node }) => {
 	if (typeof node === "string" || typeof node === "number") return /* @__PURE__ */ jsx(Text, {
 		wrap: "truncate-end",
 		children: node
@@ -1107,7 +1130,7 @@ const ColumnPosition = ({ position }) => {
 			const column = entry?.column;
 			const cell = row;
 			const output = column?.render(cell, {
-				width: hasMeasured ? width : void 0,
+				width: hasMeasured ? width : position.flexBasis,
 				now,
 				spinnerTick,
 				prepared: entry?.prepared
@@ -1115,7 +1138,7 @@ const ColumnPosition = ({ position }) => {
 			return /* @__PURE__ */ jsx(Box, {
 				height: 1,
 				justifyContent: justifyContentForAlign(column?.align),
-				children: renderNode(output)
+				children: /* @__PURE__ */ jsx(RenderedNode, { node: output })
 			}, row.task.id);
 		})
 	});
@@ -1131,7 +1154,7 @@ const ProgressRenderer = ({ rows, columns }) => {
 };
 
 //#endregion
-//#region src/renderer/store/render-snapshot.ts
+//#region src/services/store/render-snapshot.ts
 const orderedVisibleTasks = (store) => store.renderOrder.flatMap((row) => {
 	const snapshot = store.tasks.get(row.id);
 	if (!snapshot || snapshot.transient && snapshot.status !== "running") return [];
@@ -1210,7 +1233,7 @@ const toRenderSnapshot = (store, previousSnapshot) => {
 };
 
 //#endregion
-//#region src/renderer/store/use-progress-render-view.ts
+//#region src/services/renderer/hooks/use-progress-render-view.ts
 const useRenderSnapshot = (storeSnapshot) => {
 	const previousSnapshotRef = useRef(void 0);
 	const renderSnapshot = useMemo(() => toRenderSnapshot(storeSnapshot, previousSnapshotRef.current), [storeSnapshot]);
@@ -1230,7 +1253,17 @@ const useProgressRenderView = (store) => {
 };
 
 //#endregion
-//#region src/renderer/renderer-service.tsx
+//#region src/services/stdio.ts
+const defaultStdioService = {
+	stdout: process.stdout,
+	stderr: process.stderr
+};
+var ProgressStdio = class ProgressStdio extends Context.Service()("stromseng.dev/effective-progress/ProgressStdio") {
+	static layer = Layer.succeed(ProgressStdio, defaultStdioService);
+};
+
+//#endregion
+//#region src/services/renderer/renderer.tsx
 const MAX_FPS = 24;
 const ProgressRoot = ({ store }) => {
 	const { renderSnapshot, hasRunningTasks, publication } = useProgressRenderView(store);
@@ -1245,57 +1278,43 @@ const ProgressRoot = ({ store }) => {
 		})
 	});
 };
-const makeRendererv2InkRendererService = () => {
-	return { run: (store, stdio) => {
-		const proot = /* @__PURE__ */ jsx(ProgressRoot, { store });
-		return Effect.sync(() => render(proot, {
-			stdout: stdio.stdout,
-			stderr: stdio.stderr,
-			patchConsole: true,
-			exitOnCtrlC: false,
-			debug: false,
-			maxFps: MAX_FPS
-		})).pipe(Effect.flatMap((instance) => Effect.never.pipe(Effect.ensuring(Effect.gen(function* () {
-			store.flush();
-			instance.rerender(proot);
-			yield* Effect.sync(() => {
-				instance.unmount();
-			});
-		})))));
-	} };
-};
-
-//#endregion
-//#region src/services/ink-renderer.tsx
-var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")() {
-	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeRendererv2InkRendererService()));
-};
-
-//#endregion
-//#region src/services/stdio.ts
-const defaultStdioService = {
-	stdout: process.stdout,
-	stderr: process.stderr
-};
-var ProgressStdio = class ProgressStdio extends Context.Tag("stromseng.dev/effective-progress/ProgressStdio")() {
-	static Default = Layer.succeed(ProgressStdio, defaultStdioService);
+const makeRendererv2InkRendererService = Effect.gen(function* () {
+	const store = yield* ProgressStore;
+	const stdio = yield* ProgressStdio;
+	const proot = /* @__PURE__ */ jsx(ProgressRoot, { store });
+	return { run: Effect.sync(() => render(proot, {
+		stdout: stdio.stdout,
+		stderr: stdio.stderr,
+		patchConsole: true,
+		exitOnCtrlC: false,
+		debug: false,
+		maxFps: MAX_FPS
+	})).pipe(Effect.flatMap((instance) => Effect.never.pipe(Effect.ensuring(Effect.gen(function* () {
+		store.flush();
+		instance.rerender(proot);
+		yield* Effect.sync(() => {
+			instance.unmount();
+		});
+	}))))) };
+});
+var Renderer = class Renderer extends Context.Service()("stromseng.dev/effective-progress/Renderer") {
+	static layer = Layer.effect(Renderer, makeRendererv2InkRendererService);
 };
 
 //#endregion
 //#region src/services/progress.ts
 /** Builds the scoped implementation used by `ProgressService.task(...)` without auto-providing services. */
 const makeProgressService = Effect.gen(function* () {
-	const stdio = yield* ProgressStdio;
-	const inkRenderer = yield* InkRenderer;
-	const outerConsole = yield* Effect.console;
-	const store = makeProgressRenderStore();
-	const currentParentRef = yield* FiberRef.make(Option.none());
+	const inkRenderer = yield* Renderer;
+	const store = yield* ProgressStore;
 	const scope = yield* Effect.scope;
-	const log = (...args) => args.length === 0 ? Effect.void : outerConsole.log(...args);
-	yield* Effect.forkIn(inkRenderer.run(store, stdio), scope);
+	const parentOwner = Symbol();
+	const currentParentId = Effect.map(CurrentParent, (cp) => Option.isSome(cp) && cp.value.owner === parentOwner ? Option.some(cp.value.taskId) : Option.none());
+	const log = (...args) => Effect.log(...args);
+	yield* Effect.forkIn(inkRenderer.run, scope, { startImmediately: true });
 	yield* Effect.sleep("0 millis");
 	const addTask = (options) => Effect.gen(function* () {
-		const resolvedParentId = options.parentId === void 0 ? yield* FiberRef.get(currentParentRef) : Option.some(options.parentId);
+		const resolvedParentId = options.parentId === void 0 ? yield* currentParentId : Option.some(options.parentId);
 		return yield* store.addTask({
 			...options,
 			parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : void 0
@@ -1329,14 +1348,17 @@ const makeProgressService = Effect.gen(function* () {
 		else yield* failTask(taskId);
 	});
 	const scopedTask = dual(2, (effect, options) => Effect.gen(function* () {
-		const inheritedParentId = yield* FiberRef.get(currentParentRef);
+		const inheritedParentId = yield* currentParentId;
 		const resolvedParentId = options.parentId === void 0 ? inheritedParentId : Option.some(options.parentId);
 		const taskId = yield* addTask({
 			...options,
 			parentId: Option.isSome(resolvedParentId) ? resolvedParentId.value : void 0,
 			transient: options.transient
 		});
-		return yield* Effect.locally(Effect.provideService(effect, Task, taskId), currentParentRef, Option.some(taskId));
+		return yield* Effect.provideService(Effect.provideService(effect, Task, taskId), CurrentParent, Option.some({
+			owner: parentOwner,
+			taskId
+		}));
 	}));
 	const service = {
 		addTask,
@@ -1374,15 +1396,14 @@ const makeProgressService = Effect.gen(function* () {
 	};
 	return Progress.of(service);
 });
-var Progress = class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")() {
-	static Default = Layer.unwrapEffect(Effect.gen(function* () {
-		const stdioOption = yield* Effect.serviceOption(ProgressStdio);
-		const inkRendererOption = yield* Effect.serviceOption(InkRenderer);
-		let layer = Layer.scoped(Progress, makeProgressService);
-		if (Option.isNone(inkRendererOption)) layer = layer.pipe(Layer.provide(InkRenderer.Default));
-		if (Option.isNone(stdioOption)) layer = layer.pipe(Layer.provide(ProgressStdio.Default));
-		return layer;
-	}));
+/**
+* Returns a layer that uses an already-provided service for the given tag when available,
+* or falls back to the supplied default layer otherwise.
+*/
+const serviceOptionDefaultLayer = (tag, defaultLayer) => Layer.unwrap(Effect.map(Effect.serviceOption(tag), (option) => Option.getOrElse(Option.map(option, (service) => Layer.succeed(tag, service)), () => defaultLayer)));
+const CurrentParent = Context.Reference("stromseng.dev/effective-progress/CurrentParent", { defaultValue: Option.none });
+var Progress = class Progress extends Context.Service()("stromseng.dev/effective-progress/Progress") {
+	static layer = Layer.effect(Progress, makeProgressService).pipe(Layer.provide(serviceOptionDefaultLayer(Renderer, Renderer.layer).pipe(Layer.provideMerge(serviceOptionDefaultLayer(ProgressStdio, ProgressStdio.layer)), Layer.provideMerge(ProgressStore.layer))));
 };
 
 //#endregion
@@ -1400,7 +1421,7 @@ const inferTotal = (iterable) => {
 const provideProgress = (effect) => 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)));
+	return yield* Effect.scoped(Effect.provide(effect, Progress.layer, { local: true }));
 });
 /**
 * Runs an effect inside a task, creating and providing a `Progress` service automatically when one
@@ -1417,7 +1438,7 @@ const task = dual(2, (effectOrCallback, options) => {
 });
 const wrapEffects = (effects, tap) => Array.isArray(effects) ? effects.map(tap) : Object.fromEntries(Object.entries(effects).map(([k, effect]) => [k, tap(effect)]));
 const countEffects = (effects) => Array.isArray(effects) ? effects.length : Object.keys(effects).length;
-const isCollectAllMode = (mode) => mode === "either" || mode === "validate";
+const isCollectAllMode = (mode) => mode === "result";
 const allCountDisplay = (mode) => isCollectAllMode(mode) ? "detailed" : "processedOnly";
 const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* () {
 	const exit = yield* Effect.exit(effect);
@@ -1425,7 +1446,7 @@ const wrapTrackedEffect = (progress, taskId, effect) => Effect.gen(function* ()
 		yield* progress.incrementSucceeded(taskId, 1);
 		return exit.value;
 	}
-	if (Cause.isInterruptedOnly(exit.cause)) return yield* Effect.failCause(exit.cause);
+	if (Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.failCause(exit.cause);
 	yield* progress.incrementFailed(taskId, 1);
 	return yield* Effect.failCause(exit.cause);
 });
@@ -1445,10 +1466,8 @@ const all = dual(2, (effects, options) => provideProgress(Effect.gen(function* (
 		const taskId = handle.id;
 		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => wrapTrackedEffect(progress, taskId, effect)), {
 			concurrency: options.concurrency,
-			batching: options.batching,
 			discard: options.discard,
-			mode: options.mode,
-			concurrentFinalizers: options.concurrentFinalizers
+			mode: options.mode
 		}));
 		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
 		else if (!isCollectAllMode(options.mode)) yield* progress.failTask(taskId);
@@ -1474,9 +1493,7 @@ const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(fun
 		const taskId = handle.id;
 		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => wrapTrackedEffect(progress, taskId, f(item, index)), {
 			concurrency: options.concurrency,
-			batching: options.batching,
-			discard: options.discard,
-			concurrentFinalizers: options.concurrentFinalizers
+			discard: options.discard
 		}));
 		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
 		else yield* progress.failTask(taskId);