effective-progress 0.5.1 → 0.5.2

package/dist/index.mjs

@@ -0,0 +1,815 @@
+import { Brand, Clock, Context, Effect, Exit, FiberRef, Layer, Option, Ref, Schema } from "effect";
+import { dual } from "effect/Function";
+import { Writable } from "node:stream";
+import { Box, Text, render } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/ink-renderer/format.ts
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const formatDurationSeconds = (seconds) => {
+	const value = Math.max(0, Math.floor(seconds));
+	if (value < 60) return `${value}s`;
+	if (value < 3600) {
+		const mins = Math.floor(value / 60);
+		const secs = value % 60;
+		return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+	}
+	const hours = Math.floor(value / 3600);
+	const mins = Math.floor(value % 3600 / 60);
+	return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+};
+const formatElapsed = (task, now) => {
+	return formatDurationSeconds(Math.max(0, (task.completedAt ?? now) - task.startedAt) / 1e3);
+};
+const formatEta = (task, now) => {
+	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return "";
+	const { completed, total } = task.units;
+	const remaining = total - completed;
+	if (completed <= 0 || remaining <= 0) return "";
+	const elapsedMillis = Math.max(1, now - task.startedAt);
+	return formatDurationSeconds(Math.max(0, Math.floor(elapsedMillis / completed * remaining)) / 1e3);
+};
+const formatAmount = (task, tick) => {
+	if (task.units._tag === "DeterminateTaskUnits") {
+		const totalText = `${task.units.total}`;
+		return `${`${task.units.completed}`.padStart(totalText.length, " ")}/${totalText}`;
+	}
+	if (task.status === "running") return SPINNER_FRAMES[(task.units.spinnerFrame + tick) % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0];
+	return task.status === "done" ? "✓" : "✗";
+};
+
+//#endregion
+//#region src/ink-renderer/tree.ts
+const treeAncestorPrefix = (tree) => tree.ancestorHasNextSibling.slice(1).map((hasNext) => hasNext ? "│  " : "   ").join("");
+const renderTreePrefix = (tree) => {
+	if (tree.depth <= 0) return "";
+	return `${treeAncestorPrefix(tree)}${tree.hasNextSibling ? "├─ " : "└─ "}`;
+};
+const computeTreeInfo = (ordered) => {
+	const hasNextSiblingByIndex = Array.from({ length: ordered.length }, () => false);
+	for (let i = 0; i < ordered.length; i++) {
+		const depth = ordered[i].depth;
+		for (let j = i + 1; j < ordered.length; j++) {
+			const candidateDepth = ordered[j].depth;
+			if (candidateDepth < depth) break;
+			if (candidateDepth === depth) {
+				hasNextSiblingByIndex[i] = true;
+				break;
+			}
+		}
+	}
+	const ancestorStateByDepth = [];
+	return ordered.map((entry, index) => {
+		const depth = entry.depth;
+		ancestorStateByDepth.length = depth;
+		const hasChildren = index + 1 < ordered.length && ordered[index + 1] !== void 0 && ordered[index + 1].depth > depth;
+		const tree = {
+			depth,
+			hasNextSibling: hasNextSiblingByIndex[index] ?? false,
+			hasChildren,
+			ancestorHasNextSibling: [...ancestorStateByDepth]
+		};
+		ancestorStateByDepth[depth] = hasNextSiblingByIndex[index] ?? false;
+		return {
+			...entry,
+			tree
+		};
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/layout.ts
+const DEFAULT_BAR_WIDTH = 20;
+const MIN_DESCRIPTION_WIDTH = 8;
+const MIN_BAR_WIDTH = 8;
+const MIN_ELAPSED_WIDTH = 3;
+const MIN_AMOUNT_WIDTH = 1;
+const BASELINE_ROW_WIDTH = 100;
+const MIN_DESCRIPTION_COLUMNS_FOR_TREE = 24;
+const RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR = Array.from("59m 59s").length;
+const RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR = Array.from("ETA: 59m 59s").length;
+const textWidth = (text) => Array.from(text).length;
+const computeWidths = (rows, now, tick, terminalColumns, includeTree = true) => {
+	let hasDeterminate = false;
+	let description = MIN_DESCRIPTION_WIDTH;
+	let amount = 1;
+	let elapsed = RESERVED_ELAPSED_WIDTH_UP_TO_ONE_HOUR;
+	let eta = RESERVED_ETA_WIDTH_UP_TO_ONE_HOUR;
+	for (const row of rows) {
+		const { task, tree } = row;
+		const treePrefix = includeTree ? renderTreePrefix(tree) : "";
+		description = Math.max(description, textWidth(`${treePrefix}${task.description}`));
+		if (task.units._tag === "DeterminateTaskUnits") hasDeterminate = true;
+		amount = Math.max(amount, textWidth(formatAmount(task, tick)));
+		elapsed = Math.max(elapsed, textWidth(formatElapsed(task, now)));
+		if (task.status === "running" && task.units._tag === "DeterminateTaskUnits") {
+			const etaValue = formatEta(task, now);
+			const etaText = `ETA: ${etaValue.length > 0 ? etaValue : "--"}`;
+			eta = Math.max(eta, textWidth(etaText));
+		}
+	}
+	let widths = {
+		description,
+		bar: hasDeterminate ? DEFAULT_BAR_WIDTH : 0,
+		amount,
+		elapsed,
+		eta
+	};
+	const visible = (w) => [
+		w.description,
+		w.bar,
+		w.amount,
+		w.elapsed,
+		w.eta
+	].filter((width) => width > 0);
+	const total = (w) => {
+		const cols = visible(w);
+		return cols.reduce((sum, width) => sum + width, 0) + Math.max(0, cols.length - 1);
+	};
+	const baselineTarget = Math.max(BASELINE_ROW_WIDTH, total(widths));
+	const target = terminalColumns === void 0 ? baselineTarget : Math.max(1, Math.min(Math.max(1, Math.floor(terminalColumns)), baselineTarget));
+	if (total(widths) < target) widths.description += target - total(widths);
+	else if (total(widths) > target) {
+		let overflow = total(widths) - target;
+		const reduceBy = (key, min) => {
+			if (overflow <= 0) return;
+			const current = widths[key];
+			if (current <= min) return;
+			const reducible = current - min;
+			const delta = Math.min(reducible, overflow);
+			widths = {
+				...widths,
+				[key]: current - delta
+			};
+			overflow -= delta;
+		};
+		reduceBy("description", MIN_DESCRIPTION_WIDTH);
+		reduceBy("eta", 0);
+		reduceBy("bar", MIN_BAR_WIDTH);
+		reduceBy("bar", 0);
+		reduceBy("elapsed", MIN_ELAPSED_WIDTH);
+		reduceBy("amount", MIN_AMOUNT_WIDTH);
+		reduceBy("description", 0);
+		if (total(widths) < target) widths.description += target - total(widths);
+	}
+	return {
+		row: total(widths),
+		description: widths.description,
+		bar: widths.bar,
+		amount: widths.amount,
+		elapsed: widths.elapsed,
+		eta: widths.eta
+	};
+};
+const computeSharedColumnWidths = (rows, now, tick, terminalColumns) => {
+	const withTree = computeWidths(rows, now, tick, terminalColumns, true);
+	if (withTree.description >= MIN_DESCRIPTION_COLUMNS_FOR_TREE) return {
+		...withTree,
+		showTree: true
+	};
+	return {
+		...computeWidths(rows, now, tick, terminalColumns, false),
+		showTree: false
+	};
+};
+
+//#endregion
+//#region src/ink-renderer/columns/amount-column.tsx
+const AmountColumn = ({ task, tick }) => {
+	const text = formatAmount(task, tick);
+	return /* @__PURE__ */ jsx(Text, {
+		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : task.units._tag === "DeterminateTaskUnits" ? "whiteBright" : "yellow",
+		children: text
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/columns/bar-column.tsx
+const clamp = (value, minimum, maximum) => Math.min(Math.max(value, minimum), maximum);
+const BarColumn = ({ task, width }) => {
+	if (task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
+	const barWidth = Math.max(1, Math.floor(width));
+	const safeTotal = Math.max(1, task.units.total);
+	const ratio = task.status === "done" ? 1 : clamp(task.units.completed / safeTotal, 0, 1);
+	const filled = Math.round(barWidth * ratio);
+	const empty = Math.max(0, barWidth - filled);
+	const bar = `${"━".repeat(filled)}${"─".repeat(empty)}`;
+	return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		color: task.status === "failed" ? "red" : task.status === "done" ? "green" : "blue",
+		children: bar
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/columns/description-column.tsx
+const DescriptionColumn = ({ task, tree, showTree }) => /* @__PURE__ */ jsx(Text, {
+	wrap: "truncate-end",
+	children: `${showTree ? renderTreePrefix(tree) : ""}${task.description}`
+});
+
+//#endregion
+//#region src/ink-renderer/columns/elapsed-column.tsx
+const ElapsedColumn = ({ task, now }) => /* @__PURE__ */ jsx(Text, {
+	color: "gray",
+	children: formatElapsed(task, now)
+});
+
+//#endregion
+//#region src/ink-renderer/columns/eta-column.tsx
+const EtaColumn = ({ task, now }) => {
+	if (task.status !== "running" || task.units._tag !== "DeterminateTaskUnits") return /* @__PURE__ */ jsx(Text, {});
+	const eta = formatEta(task, now);
+	return /* @__PURE__ */ jsx(Text, {
+		wrap: "truncate-end",
+		color: "gray",
+		children: eta.length > 0 ? `ETA: ${eta}` : "ETA: --"
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/task-row.tsx
+const TaskRow = ({ row, now, tick, isTTY, widths }) => {
+	const props = {
+		task: row.task,
+		tree: row.tree,
+		now,
+		tick,
+		isTTY,
+		showTree: widths.showTree
+	};
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "row",
+		minWidth: widths.row,
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				width: widths.description,
+				flexShrink: 1,
+				marginRight: 1,
+				children: /* @__PURE__ */ jsx(DescriptionColumn, { ...props })
+			}),
+			widths.bar > 0 ? /* @__PURE__ */ jsx(Box, {
+				width: widths.bar,
+				flexShrink: 0,
+				marginRight: 1,
+				children: /* @__PURE__ */ jsx(BarColumn, {
+					...props,
+					width: Math.max(1, Math.min(widths.bar, DEFAULT_BAR_WIDTH))
+				})
+			}) : null,
+			/* @__PURE__ */ jsx(Box, {
+				width: widths.amount,
+				flexShrink: 0,
+				marginRight: 1,
+				children: /* @__PURE__ */ jsx(AmountColumn, { ...props })
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				width: widths.elapsed,
+				flexShrink: 0,
+				marginRight: 1,
+				children: /* @__PURE__ */ jsx(ElapsedColumn, { ...props })
+			}),
+			widths.eta > 0 ? /* @__PURE__ */ jsx(Box, {
+				width: widths.eta,
+				flexShrink: 0,
+				children: /* @__PURE__ */ jsx(EtaColumn, { ...props })
+			}) : null
+		]
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/app.tsx
+const ProgressApp = ({ rows, now, tick, isTTY, terminalColumns }) => {
+	const widths = computeSharedColumnWidths(rows, now, tick, terminalColumns);
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		children: rows.map((row) => /* @__PURE__ */ jsx(TaskRow, {
+			row,
+			now,
+			tick,
+			isTTY,
+			widths
+		}, row.task.id))
+	});
+};
+
+//#endregion
+//#region src/ink-renderer/model.ts
+const orderedVisibleTasks = (store) => store.renderOrder.flatMap((row) => {
+	const snapshot = store.tasks.get(row.id);
+	if (!snapshot || snapshot.transient && snapshot.status !== "running") return [];
+	return [{
+		snapshot,
+		depth: row.depth
+	}];
+});
+const toTaskRows = (store) => computeTreeInfo(orderedVisibleTasks(store)).map((entry) => ({
+	task: entry.snapshot,
+	tree: entry.tree
+}));
+
+//#endregion
+//#region src/ink-renderer/service.tsx
+const RENDER_INTERVAL_MILLIS = 100;
+const hasRunningSpinners = (tasks) => tasks.some((task) => task.status === "running" && task.units._tag === "IndeterminateTaskUnits");
+const createInkWritable = (terminal) => new Writable({ write(chunk, _encoding, callback) {
+	try {
+		const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : `${chunk}`;
+		Effect.runSync(terminal.writeStderr(text));
+		callback();
+	} catch (error) {
+		callback(error);
+	}
+} });
+const makeDefaultInkRenderer = () => ({ run: (storeRef, dirtyRef, terminal, isTTY) => Effect.gen(function* () {
+	const output = createInkWritable(terminal);
+	let instance;
+	let tick = 0;
+	let rendererActive = false;
+	const renderStore = (store, now, terminalColumns) => Effect.sync(() => {
+		const app = /* @__PURE__ */ jsx(ProgressApp, {
+			rows: toTaskRows(store),
+			now,
+			tick,
+			isTTY,
+			terminalColumns
+		});
+		if (instance === void 0) {
+			instance = render(app, {
+				stdout: output,
+				stderr: output,
+				patchConsole: true,
+				exitOnCtrlC: false,
+				debug: false
+			});
+			return;
+		}
+		instance.rerender(app);
+	});
+	return yield* Effect.gen(function* () {
+		rendererActive = true;
+		while (true) {
+			const dirty = yield* Ref.getAndSet(dirtyRef, false);
+			const store = yield* Ref.get(storeRef);
+			const tasks = Array.from(store.tasks.values()).filter((task) => !(task.transient && task.status !== "running"));
+			if (dirty || hasRunningSpinners(tasks)) yield* renderStore(store, yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
+			tick += 1;
+			yield* Effect.sleep(RENDER_INTERVAL_MILLIS);
+		}
+	}).pipe(Effect.ensuring(Effect.gen(function* () {
+		if (rendererActive) yield* renderStore(yield* Ref.get(storeRef), yield* Clock.currentTimeMillis, isTTY ? yield* terminal.stderrColumns : void 0);
+		yield* Effect.sync(() => {
+			instance?.unmount();
+		});
+	})));
+}) });
+var InkRenderer = class InkRenderer extends Context.Tag("stromseng.dev/effective-progress/InkRenderer")() {
+	static Default = Layer.succeed(InkRenderer, InkRenderer.of(makeDefaultInkRenderer()));
+};
+
+//#endregion
+//#region src/terminal.ts
+const withRawInputCapture = (effect) => Effect.suspend(() => {
+	if (!process.stdin.isTTY) return effect;
+	const stdin = process.stdin;
+	const wasRaw = Boolean(stdin.isRaw);
+	const onData = (chunk) => {
+		if (chunk.length === 1 && chunk[0] === 3) process.kill(process.pid, "SIGINT");
+	};
+	return Effect.acquireUseRelease(Effect.sync(() => {
+		stdin.resume();
+		stdin.setRawMode?.(true);
+		stdin.on("data", onData);
+	}), () => effect, () => Effect.sync(() => {
+		try {
+			stdin.off("data", onData);
+			stdin.setRawMode?.(wasRaw);
+			stdin.pause();
+		} catch {}
+	}));
+});
+const defaultTerminalService = {
+	isTTY: Effect.sync(() => Boolean(process.stderr.isTTY)),
+	stderrRows: Effect.sync(() => process.stderr.rows),
+	stderrColumns: Effect.sync(() => process.stderr.columns),
+	writeStderr: (text) => Effect.sync(() => {
+		process.stderr.write(text);
+	}),
+	withRawInputCapture
+};
+var ProgressTerminal = class ProgressTerminal extends Context.Tag("stromseng.dev/ProgressTerminal")() {
+	static Default = Layer.succeed(ProgressTerminal, defaultTerminalService);
+};
+
+//#endregion
+//#region src/types.ts
+const TaskIdSchema = Schema.Number.pipe(Schema.brand("TaskId"));
+const TaskId = Brand.nominal();
+const TaskStatusSchema = Schema.Literal("running", "done", "failed");
+var DeterminateTaskUnits = class extends Schema.TaggedClass()("DeterminateTaskUnits", {
+	completed: Schema.Number,
+	total: Schema.Number
+}) {};
+var IndeterminateTaskUnits = class extends Schema.TaggedClass()("IndeterminateTaskUnits", { spinnerFrame: Schema.Number }) {};
+const TaskUnitsSchema = Schema.Union(DeterminateTaskUnits, IndeterminateTaskUnits);
+var TaskSnapshot = class extends Schema.TaggedClass()("TaskSnapshot", {
+	id: TaskIdSchema,
+	parentId: Schema.NullOr(TaskIdSchema),
+	description: Schema.String,
+	status: TaskStatusSchema,
+	transient: Schema.Boolean,
+	units: TaskUnitsSchema,
+	startedAt: Schema.Number,
+	completedAt: Schema.NullOr(Schema.Number)
+}) {};
+var Task = class extends Context.Tag("stromseng.dev/effective-progress/Task")() {};
+var TaskAddedEvent = class extends Schema.TaggedClass()("TaskAdded", {
+	taskId: TaskIdSchema,
+	parentId: Schema.NullOr(TaskIdSchema),
+	description: Schema.String,
+	total: Schema.optional(Schema.Number),
+	transient: Schema.Boolean
+}) {};
+var TaskUpdatedEvent = class extends Schema.TaggedClass()("TaskUpdated", {
+	taskId: TaskIdSchema,
+	description: Schema.optional(Schema.String),
+	completed: Schema.optional(Schema.Number),
+	total: Schema.optional(Schema.Number),
+	transient: Schema.optional(Schema.Boolean)
+}) {};
+var TaskAdvancedEvent = class extends Schema.TaggedClass()("TaskAdvanced", {
+	taskId: TaskIdSchema,
+	amount: Schema.Number
+}) {};
+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 decodeProgressTaskEvent = Schema.decodeUnknownSync(ProgressTaskEventSchema);
+
+//#endregion
+//#region src/runtime.ts
+const updatedSnapshot = (snapshot, options) => {
+	const currentUnits = snapshot.units;
+	const units = (() => {
+		if (options.total !== void 0) {
+			if (options.total <= 0) return new IndeterminateTaskUnits({ spinnerFrame: 0 });
+			const completed = options.completed ?? (currentUnits._tag === "DeterminateTaskUnits" ? currentUnits.completed : 0);
+			return new DeterminateTaskUnits({
+				completed: Math.max(0, completed),
+				total: Math.max(0, options.total)
+			});
+		}
+		if (currentUnits._tag === "DeterminateTaskUnits") {
+			if (options.completed === void 0) return currentUnits;
+			return new DeterminateTaskUnits({
+				completed: Math.max(0, options.completed),
+				total: currentUnits.total
+			});
+		}
+		return currentUnits;
+	})();
+	return new TaskSnapshot({
+		id: snapshot.id,
+		parentId: snapshot.parentId,
+		description: options.description ?? snapshot.description,
+		status: snapshot.status,
+		transient: options.transient ?? snapshot.transient,
+		units,
+		startedAt: snapshot.startedAt,
+		completedAt: snapshot.completedAt
+	});
+};
+const withTransient = (snapshot, transient) => new TaskSnapshot({
+	id: snapshot.id,
+	parentId: snapshot.parentId,
+	description: snapshot.description,
+	status: snapshot.status,
+	transient,
+	units: snapshot.units,
+	startedAt: snapshot.startedAt,
+	completedAt: snapshot.completedAt
+});
+const findInsertionIndex = (renderOrder, parentId) => {
+	if (parentId === null) return {
+		index: renderOrder.length,
+		depth: 0
+	};
+	const parentIdx = renderOrder.findIndex((row) => row.id === parentId);
+	if (parentIdx === -1) return {
+		index: renderOrder.length,
+		depth: 0
+	};
+	const parentDepth = renderOrder[parentIdx].depth;
+	let i = parentIdx + 1;
+	while (i < renderOrder.length && renderOrder[i].depth > parentDepth) i++;
+	return {
+		index: i,
+		depth: parentDepth + 1
+	};
+};
+const removeFromRenderOrder = (renderOrder, taskId) => {
+	const idx = renderOrder.findIndex((row) => row.id === taskId);
+	if (idx === -1) return renderOrder;
+	const taskDepth = renderOrder[idx].depth;
+	let end = idx + 1;
+	while (end < renderOrder.length && renderOrder[end].depth > taskDepth) end++;
+	const next = [...renderOrder];
+	next.splice(idx, end - idx);
+	return next;
+};
+const makeProgressService = Effect.gen(function* () {
+	const terminal = yield* ProgressTerminal;
+	const inkRenderer = yield* InkRenderer;
+	const outerConsole = yield* Effect.console;
+	const isTTY = yield* terminal.isTTY;
+	const nextTaskIdRef = yield* Ref.make(0);
+	const storeRef = yield* Ref.make({
+		tasks: /* @__PURE__ */ new Map(),
+		renderOrder: []
+	});
+	const dirtyRef = yield* Ref.make(true);
+	const currentParentRef = yield* FiberRef.make(Option.none());
+	const scope = yield* Effect.scope;
+	const markDirty = Ref.set(dirtyRef, true);
+	const log = (...args) => args.length === 0 ? Effect.void : outerConsole.log(...args);
+	yield* Effect.forkIn(inkRenderer.run(storeRef, dirtyRef, terminal, isTTY), scope);
+	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 taskId = TaskId(yield* Ref.updateAndGet(nextTaskIdRef, (id) => id + 1));
+		const units = options.total === void 0 || options.total <= 0 ? new IndeterminateTaskUnits({ spinnerFrame: 0 }) : new DeterminateTaskUnits({
+			completed: 0,
+			total: Math.max(0, options.total)
+		});
+		const store = yield* Ref.get(storeRef);
+		const parentSnapshot = Option.isSome(resolvedParentId) ? store.tasks.get(resolvedParentId.value) : void 0;
+		const now = yield* Clock.currentTimeMillis;
+		const parentIdValue = Option.getOrNull(resolvedParentId);
+		const snapshot = new TaskSnapshot({
+			id: taskId,
+			parentId: parentIdValue,
+			description: options.description,
+			status: "running",
+			transient: parentSnapshot?.transient ?? options.transient ?? false,
+			units,
+			startedAt: now,
+			completedAt: null
+		});
+		yield* Ref.update(storeRef, (s) => {
+			const nextTasks = new Map(s.tasks);
+			nextTasks.set(taskId, snapshot);
+			const { index, depth } = findInsertionIndex(s.renderOrder, parentIdValue);
+			const nextOrder = [...s.renderOrder];
+			nextOrder.splice(index, 0, {
+				id: taskId,
+				depth
+			});
+			return {
+				tasks: nextTasks,
+				renderOrder: nextOrder
+			};
+		});
+		yield* markDirty;
+		return taskId;
+	});
+	const updateTask = (taskId, options) => Ref.update(storeRef, (store) => {
+		const snapshot = store.tasks.get(taskId);
+		if (!snapshot) return store;
+		const nextTasks = new Map(store.tasks);
+		const nextSnapshot = updatedSnapshot(snapshot, options);
+		nextTasks.set(taskId, nextSnapshot);
+		if (options.transient !== void 0) for (const [candidateId, candidate] of store.tasks.entries()) {
+			if (candidateId === taskId) continue;
+			let parentId = candidate.parentId;
+			let isDescendant = false;
+			while (parentId !== null) {
+				if (parentId === taskId) {
+					isDescendant = true;
+					break;
+				}
+				parentId = store.tasks.get(parentId)?.parentId ?? null;
+			}
+			if (isDescendant) nextTasks.set(candidateId, withTransient(candidate, nextSnapshot.transient));
+		}
+		return {
+			tasks: nextTasks,
+			renderOrder: store.renderOrder
+		};
+	}).pipe(Effect.zipRight(markDirty));
+	const advanceTask = (taskId, amount = 1) => Ref.update(storeRef, (store) => {
+		const snapshot = store.tasks.get(taskId);
+		if (!snapshot) return store;
+		const units = snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
+			completed: Math.min(snapshot.units.total, snapshot.units.completed + amount),
+			total: snapshot.units.total
+		}) : new IndeterminateTaskUnits({ spinnerFrame: Math.max(0, snapshot.units.spinnerFrame + amount) });
+		const nextTasks = new Map(store.tasks);
+		nextTasks.set(taskId, new TaskSnapshot({
+			id: snapshot.id,
+			parentId: snapshot.parentId,
+			description: snapshot.description,
+			status: snapshot.status,
+			transient: snapshot.transient,
+			units,
+			startedAt: snapshot.startedAt,
+			completedAt: snapshot.completedAt
+		}));
+		return {
+			tasks: nextTasks,
+			renderOrder: store.renderOrder
+		};
+	}).pipe(Effect.zipRight(markDirty));
+	const completeTask = (taskId) => Effect.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		yield* Ref.update(storeRef, (store) => {
+			const snapshot = store.tasks.get(taskId);
+			if (!snapshot) return store;
+			const nextTasks = new Map(store.tasks);
+			if (snapshot.transient) {
+				nextTasks.delete(taskId);
+				return {
+					tasks: nextTasks,
+					renderOrder: removeFromRenderOrder(store.renderOrder, taskId)
+				};
+			}
+			nextTasks.set(taskId, new TaskSnapshot({
+				id: snapshot.id,
+				parentId: snapshot.parentId,
+				description: snapshot.description,
+				status: "done",
+				transient: snapshot.transient,
+				units: snapshot.units._tag === "DeterminateTaskUnits" ? new DeterminateTaskUnits({
+					completed: snapshot.units.total,
+					total: snapshot.units.total
+				}) : snapshot.units,
+				startedAt: snapshot.startedAt,
+				completedAt: now
+			}));
+			return {
+				tasks: nextTasks,
+				renderOrder: store.renderOrder
+			};
+		});
+		yield* markDirty;
+	});
+	const failTask = (taskId) => Effect.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		yield* Ref.update(storeRef, (store) => {
+			const snapshot = store.tasks.get(taskId);
+			if (!snapshot) return store;
+			const nextTasks = new Map(store.tasks);
+			if (snapshot.transient) {
+				nextTasks.delete(taskId);
+				return {
+					tasks: nextTasks,
+					renderOrder: removeFromRenderOrder(store.renderOrder, taskId)
+				};
+			}
+			nextTasks.set(taskId, new TaskSnapshot({
+				id: snapshot.id,
+				parentId: snapshot.parentId,
+				description: snapshot.description,
+				status: "failed",
+				transient: snapshot.transient,
+				units: snapshot.units,
+				startedAt: snapshot.startedAt,
+				completedAt: now
+			}));
+			return {
+				tasks: nextTasks,
+				renderOrder: store.renderOrder
+			};
+		});
+		yield* markDirty;
+	});
+	const getTask = (taskId) => Ref.get(storeRef).pipe(Effect.map((store) => Option.fromNullable(store.tasks.get(taskId))));
+	const listTasks = Ref.get(storeRef).pipe(Effect.map((store) => Array.from(store.tasks.values())));
+	const runTask = dual(2, (effect, options) => Effect.gen(function* () {
+		const inheritedParentId = yield* FiberRef.get(currentParentRef);
+		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));
+	}));
+	const service = {
+		addTask,
+		updateTask,
+		advanceTask,
+		completeTask,
+		failTask,
+		log,
+		getTask,
+		listTasks,
+		runTask,
+		withTask: dual(2, (effect, options) => runTask(Effect.gen(function* () {
+			const taskId = yield* Task;
+			const exit = yield* Effect.exit(effect);
+			if (Exit.isSuccess(exit)) yield* completeTask(taskId);
+			else yield* failTask(taskId);
+			return yield* Exit.match(exit, {
+				onFailure: Effect.failCause,
+				onSuccess: Effect.succeed
+			});
+		}), options))
+	};
+	return Progress.of(service);
+});
+var Progress = class Progress extends Context.Tag("stromseng.dev/effective-progress/Progress")() {
+	static Default = Layer.unwrapEffect(Effect.gen(function* () {
+		const terminalOption = yield* Effect.serviceOption(ProgressTerminal);
+		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(terminalOption)) layer = layer.pipe(Layer.provide(ProgressTerminal.Default));
+		return layer;
+	}));
+};
+
+//#endregion
+//#region src/utils.ts
+const inferTotal = (iterable) => {
+	if (Array.isArray(iterable)) return iterable.length;
+	if (typeof iterable === "string") return iterable.length;
+	const candidate = iterable;
+	if (typeof candidate.length === "number") return candidate.length;
+	if (typeof candidate.size === "number") return candidate.size;
+};
+
+//#endregion
+//#region src/api.ts
+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)));
+});
+const task = dual(2, (effect, options) => {
+	return provideProgress(Effect.gen(function* () {
+		return yield* (yield* Progress).withTask(effect, 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 all = dual(2, (effects, options) => provideProgress(Effect.gen(function* () {
+	const progress = yield* Progress;
+	return yield* progress.runTask(Effect.gen(function* () {
+		const taskId = yield* Task;
+		const exit = yield* Effect.exit(Effect.all(wrapEffects(effects, (effect) => Effect.tap(effect, () => progress.advanceTask(taskId, 1))), {
+			concurrency: options.concurrency,
+			batching: options.batching,
+			discard: options.discard,
+			mode: options.mode,
+			concurrentFinalizers: options.concurrentFinalizers
+		}));
+		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
+		else yield* progress.failTask(taskId);
+		return yield* Exit.match(exit, {
+			onFailure: Effect.failCause,
+			onSuccess: Effect.succeed
+		});
+	}), {
+		description: options.description,
+		total: countEffects(effects),
+		transient: options.transient
+	});
+})));
+const forEach = dual(3, (iterable, f, options) => provideProgress(Effect.gen(function* () {
+	const progress = yield* Progress;
+	return yield* progress.runTask(Effect.gen(function* () {
+		const taskId = yield* Task;
+		const exit = yield* Effect.exit(Effect.forEach(iterable, (item, index) => Effect.tap(f(item, index), () => progress.advanceTask(taskId, 1)), {
+			concurrency: options.concurrency,
+			batching: options.batching,
+			discard: options.discard,
+			concurrentFinalizers: options.concurrentFinalizers
+		}));
+		if (Exit.isSuccess(exit)) yield* progress.completeTask(taskId);
+		else yield* progress.failTask(taskId);
+		return yield* Exit.match(exit, {
+			onFailure: Effect.failCause,
+			onSuccess: Effect.succeed
+		});
+	}), {
+		description: options.description,
+		total: options.total ?? inferTotal(iterable),
+		transient: options.transient
+	});
+})));
+
+//#endregion
+export { DeterminateTaskUnits, IndeterminateTaskUnits, Progress, ProgressTaskEventSchema, ProgressTerminal, Task, TaskAddedEvent, TaskAdvancedEvent, TaskCompletedEvent, TaskFailedEvent, TaskId, TaskRemovedEvent, TaskSnapshot, TaskStatusSchema, TaskUnitsSchema, TaskUpdatedEvent, all, decodeProgressTaskEvent, forEach, task };