silvery 0.17.0 → 0.17.2

package/dist/ui/progress.mjs

@@ -0,0 +1,858 @@
+import { i as createSpinner, r as Spinner } from "../spinner-DSByknyx.mjs";
+import { t as ProgressBar } from "../progress-bar-COPSBlT9.mjs";
+import { t as MultiProgress } from "../multi-progress-CQVB9lES.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region packages/ag-react/src/ui/progress/als-context.ts
+/**
+* AsyncLocalStorage context for step progress reporting
+*
+* Provides a `step()` function that work functions can call to report progress.
+* Returns a no-op context when called outside of a steps() execution context,
+* so functions work in tests without the progress UI.
+*/
+const stepContext = new AsyncLocalStorage();
+/**
+* Get the current step context
+*
+* Safe to call anywhere - returns a no-op context when called outside
+* of a steps() execution context.
+*
+* @example
+* ```typescript
+* async function processFiles(files: string[]) {
+*   for (let i = 0; i < files.length; i++) {
+*     step().progress(i + 1, files.length);
+*     await process(files[i]);
+*   }
+* }
+*
+* // In tests (no steps context)
+* await processFiles(["a.md", "b.md"]);  // step() returns no-op, no errors
+*
+* // In production (with steps context)
+* await steps({ process: processFiles }).run();  // Shows progress
+* ```
+*/
+function step() {
+	return stepContext.getStore() ?? NO_OP_CONTEXT;
+}
+/**
+* Run a function with step context (internal use by runner)
+*/
+function runWithStepContext(ctx, fn) {
+	return stepContext.run(ctx, fn);
+}
+/**
+* Create an internal step context for the runner
+*/
+function createStepContext(label, handle, onSubStep) {
+	let currentSubLabel;
+	let currentSubHandle = null;
+	let subStepStartTime = 0;
+	const declaredHandles = /* @__PURE__ */ new Map();
+	return {
+		get label() {
+			return label;
+		},
+		get handle() {
+			return handle;
+		},
+		progress(current, total) {
+			if (currentSubHandle) currentSubHandle.setTitle(`${currentSubLabel} (${current}/${total})`);
+			else handle.setTitle(`${label} (${current}/${total})`);
+		},
+		sub(subLabel) {
+			this._completeSubStep();
+			currentSubLabel = subLabel;
+			subStepStartTime = Date.now();
+			if (onSubStep) {
+				currentSubHandle = onSubStep(subLabel);
+				currentSubHandle.start();
+			}
+		},
+		_addSubHandle(subLabel, subHandle) {
+			declaredHandles.set(subLabel, subHandle);
+		},
+		_getSubHandle(subLabel) {
+			return declaredHandles.get(subLabel);
+		},
+		_setCurrentSubHandle(subLabel, subHandle) {
+			currentSubLabel = subLabel;
+			currentSubHandle = subHandle;
+			subStepStartTime = Date.now();
+		},
+		_completeSubStep() {
+			if (currentSubHandle && currentSubLabel) {
+				const elapsed = Date.now() - subStepStartTime;
+				currentSubHandle.complete(elapsed);
+				currentSubHandle = null;
+				currentSubLabel = void 0;
+			}
+		}
+	};
+}
+/**
+* No-op context for when step() is called outside execution context
+*/
+const NO_OP_CONTEXT = {
+	progress: () => {},
+	sub: () => {},
+	get label() {
+		return "";
+	}
+};
+//#endregion
+//#region packages/ag-react/src/ui/progress/step-node.ts
+/**
+* Parse a declarative steps definition into a tree of StepNodes
+*
+* @param def - The declarative structure
+* @param indent - Current indentation level (internal)
+* @returns Array of StepNodes
+*/
+function parseStepsDef(def, indent = 0) {
+	const nodes = [];
+	for (const [key, value] of Object.entries(def)) if (typeof value === "function") nodes.push({
+		key,
+		label: generateLabel(key),
+		work: value,
+		indent
+	});
+	else if (Array.isArray(value) && value.length === 2) {
+		const [label, work] = value;
+		nodes.push({
+			key,
+			label,
+			work,
+			indent
+		});
+	} else if (typeof value === "object" && value !== null) {
+		const children = parseStepsDef(value, indent + 1);
+		nodes.push({
+			key,
+			label: generateLabel(key),
+			children,
+			indent
+		});
+	}
+	return nodes;
+}
+/**
+* Flatten the tree for sequential execution
+*
+* Returns nodes in depth-first order, with groups followed by their children.
+*/
+function flattenStepNodes(nodes) {
+	const result = [];
+	for (const node of nodes) {
+		result.push(node);
+		if (node.children) result.push(...flattenStepNodes(node.children));
+	}
+	return result;
+}
+/**
+* Get only leaf nodes (nodes with work functions)
+*/
+function getLeafNodes(nodes) {
+	const result = [];
+	for (const node of nodes) {
+		if (node.work) result.push(node);
+		if (node.children) result.push(...getLeafNodes(node.children));
+	}
+	return result;
+}
+/**
+* Generate a display label from a camelCase function name
+*
+* @example
+* generateLabel("loadModules") // "Load modules"
+* generateLabel("parseMarkdown") // "Parse markdown"
+* generateLabel("initBoardStateGenerator") // "Init board state generator"
+*/
+function generateLabel(fnName) {
+	return fnName.replace(/([A-Z])/g, " $1").replace(/(\d+)/g, " $1").toLowerCase().trim().replace(/\s+/g, " ").replace(/^./, (s) => s.toUpperCase());
+}
+//#endregion
+//#region packages/ag-react/src/ui/progress/declarative.ts
+/**
+* Declarative steps implementation
+*
+* Provides the declarative overload for steps() that accepts an object
+* structure and shows all steps upfront before execution.
+*/
+/**
+* Create a declarative steps runner
+*
+* @param def - Object structure defining steps
+* @returns StepsRunner with run(), pipe(), and done() methods
+*
+* @example
+* ```typescript
+* const loader = stepsDeclarative({
+*   loadModules,           // "Load modules"
+*   loadRepo: {           // "Load repo" (group)
+*     discover,            //   "Discover"
+*     parse,               //   "Parse"
+*   },
+* });
+*
+* const results = await loader.run({ clear: true });
+* ```
+*/
+function stepsDeclarative(def) {
+	const rootNodes = parseStepsDef(def);
+	const allNodes = flattenStepNodes(rootNodes);
+	let multi = null;
+	const handles = /* @__PURE__ */ new Map();
+	const groupLeaves = /* @__PURE__ */ new Map();
+	const leafToGroups = /* @__PURE__ */ new Map();
+	for (const node of allNodes) if (node.children) {
+		const leaves = getLeafNodes([node]);
+		groupLeaves.set(node, leaves);
+		for (const leaf of leaves) {
+			const groups = leafToGroups.get(leaf) ?? [];
+			groups.push(node);
+			leafToGroups.set(leaf, groups);
+		}
+	}
+	return {
+		get _steps() {
+			return rootNodes;
+		},
+		async run(options) {
+			multi = new MultiProgress();
+			registerAllSteps(allNodes, multi, handles);
+			const groupStartTimes = /* @__PURE__ */ new Map();
+			const completedLeaves = /* @__PURE__ */ new Set();
+			multi.start();
+			await new Promise((resolve) => setImmediate(resolve));
+			const results = {};
+			try {
+				for (const node of allNodes) if (node.work) {
+					const groups = leafToGroups.get(node) ?? [];
+					for (const group of groups) if (!groupStartTimes.has(group)) {
+						groupStartTimes.set(group, Date.now());
+						handles.get(group)?.start();
+					}
+					const result = await executeStep(node, handles, multi);
+					setNestedResult(results, node.key, result);
+					completedLeaves.add(node);
+					for (const group of groups) if ((groupLeaves.get(group) ?? []).every((l) => completedLeaves.has(l))) {
+						const elapsed = Date.now() - groupStartTimes.get(group);
+						handles.get(group)?.complete(elapsed);
+					}
+				}
+			} finally {
+				multi.stop(options?.clear ?? false);
+			}
+			return results;
+		},
+		async pipe(options) {
+			multi = new MultiProgress();
+			registerAllSteps(allNodes, multi, handles);
+			const groupStartTimes = /* @__PURE__ */ new Map();
+			const completedLeaves = /* @__PURE__ */ new Set();
+			multi.start();
+			await new Promise((resolve) => setImmediate(resolve));
+			let previousResult = void 0;
+			try {
+				for (const node of allNodes) if (node.work) {
+					const groups = leafToGroups.get(node) ?? [];
+					for (const group of groups) if (!groupStartTimes.has(group)) {
+						groupStartTimes.set(group, Date.now());
+						handles.get(group)?.start();
+					}
+					previousResult = await executeStep(node, handles, multi, previousResult);
+					completedLeaves.add(node);
+					for (const group of groups) if ((groupLeaves.get(group) ?? []).every((l) => completedLeaves.has(l))) {
+						const elapsed = Date.now() - groupStartTimes.get(group);
+						handles.get(group)?.complete(elapsed);
+					}
+				}
+			} finally {
+				multi.stop(options?.clear ?? false);
+			}
+			return previousResult;
+		},
+		done(options) {
+			if (multi) {
+				multi.stop(options?.clear ?? false);
+				multi = null;
+			}
+		}
+	};
+}
+/**
+* Register all steps with MultiProgress upfront
+*/
+function registerAllSteps(nodes, multi, handles) {
+	for (const node of nodes) {
+		const isGroup = node.children && !node.work;
+		const handle = multi.add(node.label, {
+			type: isGroup ? "group" : "spinner",
+			indent: node.indent
+		});
+		handles.set(node, handle);
+	}
+}
+/**
+* Execute a single step
+*/
+async function executeStep(node, handles, multi, input) {
+	const handle = handles.get(node);
+	const startTime = Date.now();
+	await new Promise((resolve) => setImmediate(resolve));
+	const ctx = createStepContext(node.label, handle, (subLabel) => {
+		return multi.add(subLabel, {
+			type: "spinner",
+			indent: node.indent + 1,
+			insertAfter: handle.id
+		});
+	});
+	handle.start();
+	try {
+		const result = await runWithStepContext(ctx, () => {
+			if (input !== void 0) return node.work(input);
+			return node.work();
+		});
+		if (isGenerator$2(result)) return await runGenerator$2(result, ctx, node, multi);
+		if (isAsyncGenerator$1(result)) return await runAsyncGenerator$1(result, ctx, node, multi);
+		ctx._completeSubStep();
+		const elapsed = Date.now() - startTime;
+		handle.complete(elapsed);
+		return result;
+	} catch (error) {
+		handle.fail();
+		throw error;
+	}
+}
+/**
+* Run a sync generator step
+*/
+async function runGenerator$2(gen, ctx, node, multi) {
+	const startTime = Date.now();
+	let result = gen.next();
+	let hasSubSteps = false;
+	let lastInsertedId = ctx.handle.id;
+	while (!result.done) {
+		const value = result.value;
+		if (isDeclareSteps$1(value)) {
+			if (!hasSubSteps) {
+				hasSubSteps = true;
+				ctx.handle.setType("group");
+			}
+			for (const label of value.declare) {
+				const subHandle = multi.add(label, {
+					type: "spinner",
+					indent: node.indent + 1,
+					insertAfter: lastInsertedId
+				});
+				lastInsertedId = subHandle.id;
+				ctx._addSubHandle(label, subHandle);
+			}
+		} else if (typeof value === "string") {
+			ctx._completeSubStep();
+			if (!hasSubSteps) {
+				hasSubSteps = true;
+				ctx.handle.setType("group");
+			}
+			const existingHandle = ctx._getSubHandle?.(value);
+			if (existingHandle) {
+				ctx._setCurrentSubHandle(value, existingHandle);
+				existingHandle.start();
+			} else {
+				const subHandle = multi.add(value, {
+					type: "spinner",
+					indent: node.indent + 1,
+					insertAfter: lastInsertedId
+				});
+				lastInsertedId = subHandle.id;
+				ctx._addSubHandle(value, subHandle);
+				subHandle.start();
+			}
+		} else if (isProgressUpdate(value)) ctx.progress(value.current ?? 0, value.total ?? 0);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		result = gen.next();
+	}
+	ctx._completeSubStep();
+	const elapsed = Date.now() - startTime;
+	ctx.handle.complete(elapsed);
+	return result.value;
+}
+/**
+* Run an async generator step
+*/
+async function runAsyncGenerator$1(gen, ctx, node, multi) {
+	const startTime = Date.now();
+	let result = await gen.next();
+	let hasSubSteps = false;
+	let lastInsertedId = ctx.handle.id;
+	while (!result.done) {
+		const value = result.value;
+		if (isDeclareSteps$1(value)) {
+			if (!hasSubSteps) {
+				hasSubSteps = true;
+				ctx.handle.setType("group");
+			}
+			for (const label of value.declare) {
+				const subHandle = multi.add(label, {
+					type: "spinner",
+					indent: node.indent + 1,
+					insertAfter: lastInsertedId
+				});
+				lastInsertedId = subHandle.id;
+				ctx._addSubHandle(label, subHandle);
+			}
+		} else if (typeof value === "string") {
+			ctx._completeSubStep();
+			if (!hasSubSteps) {
+				hasSubSteps = true;
+				ctx.handle.setType("group");
+			}
+			const existingHandle = ctx._getSubHandle(value);
+			if (existingHandle) {
+				ctx._setCurrentSubHandle(value, existingHandle);
+				existingHandle.start();
+			} else {
+				const subHandle = multi.add(value, {
+					type: "spinner",
+					indent: node.indent + 1,
+					insertAfter: lastInsertedId
+				});
+				lastInsertedId = subHandle.id;
+				ctx._addSubHandle(value, subHandle);
+				subHandle.start();
+			}
+		} else if (isProgressUpdate(value)) ctx.progress(value.current ?? 0, value.total ?? 0);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		result = await gen.next();
+	}
+	ctx._completeSubStep();
+	const elapsed = Date.now() - startTime;
+	ctx.handle.complete(elapsed);
+	return result.value;
+}
+/**
+* Set a nested result value by key path
+*/
+function setNestedResult(results, key, value) {
+	results[key] = value;
+}
+/**
+* Type guards
+*/
+function isGenerator$2(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
+}
+function isAsyncGenerator$1(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function isProgressUpdate(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && ("current" in value || "total" in value);
+}
+function isDeclareSteps$1(value) {
+	return value !== null && typeof value === "object" && "declare" in value && Array.isArray(value.declare);
+}
+//#endregion
+//#region packages/ag-react/src/ui/progress/steps.ts
+/**
+* Sequential step runner with progress display
+*
+* Supports two modes:
+*
+* ## Declarative Mode (recommended)
+*
+* Pass an object to declare all steps upfront:
+*
+* ```typescript
+* import { steps, step } from "@silvery/ag-react/ui/progress";
+*
+* const loader = steps({
+*   loadModules,           // Auto-named: "Load modules"
+*   loadRepo: {           // Group: "Load repo"
+*     discover,            //   "Discover"
+*     parse,               //   "Parse"
+*   },
+* });
+*
+* const results = await loader.run({ clear: true });
+*
+* // Inside work functions, use step() to report progress:
+* async function discover() {
+*   const files = await glob("**\/*.md");
+*   for (let i = 0; i < files.length; i++) {
+*     step().progress(i + 1, files.length);
+*     await process(files[i]);
+*   }
+*   return files;
+* }
+* ```
+*
+* ## Fluent Mode (legacy)
+*
+* Chain steps with `.run()` and execute with `.execute()`:
+*
+* ```typescript
+* await steps()
+*   .run("Loading modules", () => import("./app"))
+*   .run("Building view", async () => buildView())
+*   .execute();
+* ```
+*
+* Generators can yield sub-step progress:
+* - Yield a **string** to create a new sub-step
+* - Yield an **object** `{ current, total }` to update progress on current sub-step
+*/
+function steps(def) {
+	if (def !== void 0) return stepsDeclarative(def);
+	return createFluentBuilder();
+}
+/**
+* Create a no-op StepController for work functions that don't use sub-steps.
+* This satisfies the type union while being harmless if not used.
+*/
+function createNoopStepController() {
+	const controller = (_label) => {};
+	controller.progress = (_current, _total) => {};
+	controller.done = () => {};
+	return controller;
+}
+/**
+* Create the fluent step builder (legacy mode)
+*/
+function createFluentBuilder() {
+	const stepList = [];
+	const builder = {
+		run(title, work) {
+			stepList.push({
+				title,
+				work
+			});
+			return builder;
+		},
+		async execute(options) {
+			const multi = new MultiProgress();
+			const handles = /* @__PURE__ */ new Map();
+			const results = {};
+			for (const step of stepList) handles.set(step.title, multi.add(step.title, { type: "spinner" }));
+			multi.start();
+			try {
+				for (const step of stepList) {
+					const handle = handles.get(step.title);
+					await new Promise((resolve) => setImmediate(resolve));
+					const result = step.work(createNoopStepController());
+					if (isAsyncGenerator(result)) results[step.title] = await runAsyncGenerator(result, handle, step.title, multi);
+					else if (isSyncGenerator(result)) results[step.title] = await runSyncGenerator(result, handle, step.title, multi);
+					else if (isPromiseLike$2(result)) {
+						handle.start();
+						results[step.title] = await result;
+						handle.complete();
+					} else {
+						handle.start();
+						results[step.title] = result;
+						handle.complete();
+					}
+				}
+			} finally {
+				multi.stop(options?.clear ?? false);
+			}
+			return results;
+		}
+	};
+	return builder;
+}
+/**
+* Process a yielded value:
+* - { declare: [...] } = declare all sub-steps upfront (show as pending)
+* - string = start/create a sub-step with that label
+* - { current, total } = update progress on current sub-step
+*/
+function processYield(value, state, multi) {
+	if (isDeclareSteps(value)) {
+		for (const label of value.declare) {
+			const handle = multi.add(label, {
+				type: "spinner",
+				indent: 1,
+				insertAfter: state.lastInsertId
+			});
+			state.lastInsertId = handle.id;
+			state.declaredSteps.set(label, handle);
+		}
+		return;
+	}
+	if (typeof value === "string") {
+		if (state.currentHandle && state.currentLabel) {
+			const elapsed = Date.now() - state.subStepStartTime;
+			state.currentHandle.complete(elapsed);
+		}
+		state.currentLabel = value;
+		state.subStepStartTime = Date.now();
+		const declared = state.declaredSteps.get(value);
+		if (declared) {
+			state.currentHandle = declared;
+			state.currentHandle.start();
+		} else {
+			state.currentHandle = multi.add(value, {
+				type: "spinner",
+				indent: 1,
+				insertAfter: state.lastInsertId
+			});
+			state.lastInsertId = state.currentHandle.id;
+			state.currentHandle.start();
+		}
+	} else if (value && typeof value === "object") {
+		const { current, total } = value;
+		if (state.currentHandle && total && total > 0) state.currentHandle.setTitle(`${state.currentLabel} (${current ?? 0}/${total})`);
+	}
+}
+function isDeclareSteps(value) {
+	return value !== null && typeof value === "object" && "declare" in value && Array.isArray(value.declare);
+}
+/**
+* Run an async generator step
+*/
+async function runAsyncGenerator(gen, parentHandle, parentTitle, multi) {
+	const state = {
+		currentLabel: void 0,
+		currentHandle: null,
+		lastInsertId: parentHandle.id,
+		subStepStartTime: Date.now(),
+		startTime: Date.now(),
+		declaredSteps: /* @__PURE__ */ new Map()
+	};
+	let result = await gen.next();
+	while (!result.done) {
+		processYield(result.value, state, multi);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		result = await gen.next();
+	}
+	if (state.currentHandle && state.currentLabel) {
+		const elapsed = Date.now() - state.subStepStartTime;
+		state.currentHandle.complete(elapsed);
+	}
+	const totalElapsed = Date.now() - state.startTime;
+	parentHandle.complete(totalElapsed);
+	return result.value;
+}
+/**
+* Run a sync generator step
+*/
+async function runSyncGenerator(gen, parentHandle, parentTitle, multi) {
+	const state = {
+		currentLabel: void 0,
+		currentHandle: null,
+		lastInsertId: parentHandle.id,
+		subStepStartTime: Date.now(),
+		startTime: Date.now(),
+		declaredSteps: /* @__PURE__ */ new Map()
+	};
+	let result = gen.next();
+	while (!result.done) {
+		processYield(result.value, state, multi);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		result = gen.next();
+	}
+	if (state.currentHandle && state.currentLabel) {
+		const elapsed = Date.now() - state.subStepStartTime;
+		state.currentHandle.complete(elapsed);
+	}
+	const totalElapsed = Date.now() - state.startTime;
+	parentHandle.complete(totalElapsed);
+	return result.value;
+}
+function isAsyncGenerator(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function isSyncGenerator(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value[Symbol.iterator] === "function";
+}
+function isPromiseLike$2(value) {
+	return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+//#endregion
+//#region packages/ag-react/src/ui/progress/task.ts
+/** Phase labels for common operations */
+const PHASE_LABELS$1 = {
+	reading: "Reading events",
+	applying: "Applying events",
+	rules: "Evaluating rules",
+	scanning: "Scanning files",
+	reconciling: "Reconciling changes",
+	board: "Building view"
+};
+/**
+* Create a task wrapper with spinner
+*
+* @param title - Display title for the task
+* @returns TaskWrapper with wrap() method
+*/
+function task(title) {
+	return { async wrap(work) {
+		const spinner = createSpinner();
+		spinner(title);
+		try {
+			if (typeof work === "function") {
+				const result = work();
+				if (isGenerator$1(result)) return await runGenerator$1(result, spinner, title);
+				if (isPromiseLike$1(result)) {
+					const value = await result;
+					spinner.succeed(title);
+					return value;
+				}
+				spinner.succeed(title);
+				return result;
+			}
+			if (isPromiseLike$1(work)) {
+				const value = await work;
+				spinner.succeed(title);
+				return value;
+			}
+			spinner.succeed(title);
+			return work;
+		} catch (error) {
+			spinner.fail(title);
+			throw error;
+		}
+	} };
+}
+/**
+* Run a generator with progress updates
+*/
+async function runGenerator$1(gen, spinner, baseTitle) {
+	let result = gen.next();
+	while (!result.done) {
+		const info = result.value;
+		const phase = info.phase ?? "";
+		const phaseLabel = PHASE_LABELS$1[phase] ?? (phase || baseTitle);
+		if (info.total && info.total > 0) spinner(`${phaseLabel} (${info.current}/${info.total})`);
+		else spinner(phaseLabel);
+		await new Promise((resolve) => setImmediate(resolve));
+		result = gen.next();
+	}
+	spinner.succeed(baseTitle);
+	return result.value;
+}
+function isGenerator$1(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value.throw === "function";
+}
+function isPromiseLike$1(value) {
+	return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+//#endregion
+//#region packages/ag-react/src/ui/progress/tasks.ts
+/** Phase labels for common operations */
+const PHASE_LABELS = {
+	discover: "Discovering files",
+	parse: "Parsing markdown",
+	apply: "Applying changes",
+	resolve: "Resolving links",
+	materialize: "Evaluating rules",
+	board: "Building view",
+	reading: "Reading events",
+	applying: "Applying events",
+	rules: "Evaluating rules",
+	scanning: "Scanning files",
+	reconciling: "Reconciling changes"
+};
+/**
+* Create a sequential task builder
+*
+* @returns TaskBuilder with add() and run() methods
+*/
+function tasks() {
+	const taskList = [];
+	const builder = {
+		add(title, work) {
+			taskList.push({
+				title,
+				work
+			});
+			return builder;
+		},
+		async run(options) {
+			const multi = new MultiProgress();
+			const handles = /* @__PURE__ */ new Map();
+			const results = {};
+			for (const task of taskList) handles.set(task.title, multi.add(task.title, { type: "spinner" }));
+			multi.start();
+			try {
+				for (const task of taskList) {
+					const handle = handles.get(task.title);
+					await new Promise((resolve) => setImmediate(resolve));
+					const result = task.work();
+					if (isGenerator(result)) results[task.title] = await runGenerator(result, handle, task.title, multi);
+					else if (isPromiseLike(result)) {
+						handle.start();
+						results[task.title] = await result;
+						handle.complete();
+					} else {
+						handle.start();
+						results[task.title] = result;
+						handle.complete();
+					}
+				}
+			} finally {
+				multi.stop(options?.clear ?? false);
+			}
+			return results;
+		}
+	};
+	return builder;
+}
+/**
+* Run a generator task with progress updates
+* Parent task stays visible while sub-phases are indented below
+*/
+async function runGenerator(gen, parentHandle, baseTitle, multi) {
+	let result = gen.next();
+	let currentPhase;
+	let currentPhaseHandle = null;
+	let lastInsertId = parentHandle.id;
+	let phaseStartTime = Date.now();
+	const taskStartTime = Date.now();
+	while (!result.done) {
+		const info = result.value;
+		const phase = info.phase ?? "";
+		if (phase && phase !== currentPhase) {
+			if (currentPhaseHandle && currentPhase) {
+				const elapsed = Date.now() - phaseStartTime;
+				const prevLabel = PHASE_LABELS[currentPhase] ?? currentPhase;
+				currentPhaseHandle.complete(`${prevLabel} (${elapsed}ms)`);
+			}
+			currentPhase = phase;
+			phaseStartTime = Date.now();
+			const phaseLabel = PHASE_LABELS[phase] ?? phase;
+			currentPhaseHandle = multi.add(phaseLabel, {
+				type: "spinner",
+				indent: 1,
+				insertAfter: lastInsertId
+			});
+			lastInsertId = currentPhaseHandle.id;
+			currentPhaseHandle.start();
+		}
+		if (currentPhaseHandle && info.total && info.total > 0) {
+			const phaseLabel = PHASE_LABELS[phase] ?? phase;
+			currentPhaseHandle.setTitle(`${phaseLabel} (${info.current}/${info.total})`);
+		}
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		result = gen.next();
+	}
+	if (currentPhaseHandle && currentPhase) {
+		const elapsed = Date.now() - phaseStartTime;
+		const finalLabel = PHASE_LABELS[currentPhase] ?? currentPhase;
+		currentPhaseHandle.complete(`${finalLabel} (${elapsed}ms)`);
+	}
+	const totalElapsed = Date.now() - taskStartTime;
+	parentHandle.complete(`${baseTitle} (${totalElapsed}ms)`);
+	return result.value;
+}
+function isGenerator(value) {
+	return value !== null && typeof value === "object" && typeof value.next === "function" && typeof value.throw === "function";
+}
+function isPromiseLike(value) {
+	return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+//#endregion
+export { MultiProgress, ProgressBar, Spinner, createSpinner, step, steps, task, tasks };
+
+//# sourceMappingURL=progress.mjs.map