@datum-cloud/datum-ui 1.3.1 → 1.4.0

package/dist/{task-queue-dropdown-CGLFsgM1.mjs → task-queue-dropdown-DfdGiyfA.mjs}

@@ -1,12 +1,12 @@
-import { t as cn } from "./cn-dlASUkDY.mjs";
-import { t as Badge } from "./badge-DO2_XsXD.mjs";
-import { t as SpinnerIcon } from "./spinner.icon-DSvVwPjx.mjs";
-import { t as Button } from "./button-B_N7A8gv.mjs";
+import { t as cn } from "./utils-Bu32wN-x.mjs";
+import { t as Badge } from "./badge-BTNW_FEU.mjs";
+import { t as SpinnerIcon } from "./spinner.icon-BYUMQ8H-.mjs";
+import { t as Button } from "./button-A1qTjZ8U.mjs";
 import { t as Icon } from "./icon-wrapper-DKfJlJd0.mjs";
-import { t as Dialog } from "./dialog-ZmYSe4-x.mjs";
-import { t as ResponsiveDropdown } from "./responsive-dropdown-BhvBzT_1.mjs";
-import { a as TooltipTrigger, n as Tooltip, r as TooltipContent, t as Tooltip$1 } from "./tooltip-BqrOCH8l.mjs";
-import { c as TableRow, i as TableCell, n as TableBody, o as TableHead, s as TableHeader, t as Table } from "./table-BR3mwU8X.mjs";
+import { t as Dialog } from "./dialog-N2pkQIc4.mjs";
+import { t as ResponsiveDropdown } from "./responsive-dropdown-fCmduKaz.mjs";
+import { a as TooltipTrigger, n as Tooltip, r as TooltipContent, t as Tooltip$1 } from "./tooltip-BhatUaar.mjs";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "./table/index.mjs";
 import { Ban, CheckCircle2, CircleAlert, CircleCheck, CornerDownRightIcon, FileIcon, ListTodo, X, XCircle } from "lucide-react";
 import { createContext, use, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
@@ -84,6 +84,20 @@ function createUserMetadata(extra) {
 }
 //#endregion
 //#region src/components/features/task-queue/engine/executor.ts
+/**
+* Shallow-clone a task into an engine-local working copy.
+*
+* The executor mutates its working copy freely and emits fresh copies on every
+* update, so the object handed in (which may be the exact reference held in a
+* live React snapshot) is never mutated in place.
+*/
+function cloneTask(task) {
+	return {
+		...task,
+		succeededItems: [...task.succeededItems ?? []],
+		failedItems: [...task.failedItems ?? []]
+	};
+}
 function createTaskContext(task, callbacks) {
 	let cancelled = false;
 	let shouldStop = false;
@@ -145,14 +159,14 @@ function createTaskContext(task, callbacks) {
 		getShouldStop: () => shouldStop
 	};
 }
-async function executeTask(task, callbacks) {
-	const processor = task._processor;
+async function executeTask(inputTask, processor, callbacks) {
 	if (!processor) return {
 		status: "failed",
 		completed: 0,
 		failed: 0,
 		failedItems: [{ message: "No processor attached" }]
 	};
+	const task = cloneTask(inputTask);
 	task.status = "running";
 	task.startedAt = Date.now();
 	if (!task.succeededItems) task.succeededItems = [];
@@ -182,6 +196,22 @@ async function executeTask(task, callbacks) {
 	};
 }
 //#endregion
+//#region src/components/features/task-queue/engine/storage/serialize.ts
+/**
+* Strip a task down to its JSON-serializable fields before persisting.
+*
+* Drops the non-serializable members: the in-memory `_processor` reference and
+* the two fields that can hold React elements or functions — `icon`
+* (`ReactNode`) and `completionActions` (a `ButtonProps[]` or callback). Left in
+* place, a `ReactNode` icon sends `JSON.stringify` into circular-reference
+* territory and throws, aborting the whole persist. `_originalItems` is kept so
+* retry can resume against the full input set.
+*/
+function toSerializableTask(task) {
+	const { _processor, icon, completionActions, ...rest } = task;
+	return rest;
+}
+//#endregion
 //#region src/components/features/task-queue/engine/storage/local-storage.ts
 var LocalTaskStorage = class {
 	key;
@@ -220,12 +250,21 @@ var LocalTaskStorage = class {
 			localStorage.removeItem(this.key);
 		} catch {}
 	}
+	/**
+	* Notify when another tab writes to the same storage key, so this instance's
+	* consumers can re-read and converge instead of showing stale state.
+	*/
+	onExternalChange(callback) {
+		if (!isBrowser()) return () => {};
+		const handler = (event) => {
+			if (event.key === this.key) callback();
+		};
+		window.addEventListener("storage", handler);
+		return () => window.removeEventListener("storage", handler);
+	}
 	persist(tasks) {
 		try {
-			const serializable = tasks.map((task) => {
-				const { _processor, _icon, _completionActions, ...rest } = task;
-				return rest;
-			});
+			const serializable = tasks.map(toSerializableTask);
 			localStorage.setItem(this.key, JSON.stringify(serializable));
 		} catch (error) {
 			if (error instanceof Error && error.name === "QuotaExceededError") console.warn("[TaskQueue] Storage quota exceeded. Consider dismissing old tasks.");
@@ -263,6 +302,9 @@ var MemoryTaskStorage = class {
 //#endregion
 //#region src/components/features/task-queue/engine/storage/redis-storage.ts
 const DEFAULT_TTL = 3600 * 24 * 7;
+function hasSetex(client) {
+	return "setex" in client && typeof client.setex === "function";
+}
 var RedisTaskStorage = class {
 	client;
 	key;
@@ -270,11 +312,15 @@ var RedisTaskStorage = class {
 	initialized = false;
 	initPromise = null;
 	ttl;
+	readyCallbacks = /* @__PURE__ */ new Set();
+	pendingSync = false;
+	writeChain = Promise.resolve();
 	constructor(client, key = TASK_STORAGE_KEY, ttl = DEFAULT_TTL) {
 		this.client = client;
 		this.key = key;
 		this.ttl = ttl;
 		if (isBrowser()) this.initPromise = this.initialize();
+		else this.initialized = true;
 	}
 	/**
 	* Wait for initialization to complete.
@@ -283,6 +329,14 @@ var RedisTaskStorage = class {
 	async waitForInit() {
 		if (this.initPromise) await this.initPromise;
 	}
+	/** Invoke `callback` once persisted data has been loaded into the cache. */
+	onReady(callback) {
+		if (this.initialized) {
+			callback();
+			return;
+		}
+		this.readyCallbacks.add(callback);
+	}
 	async initialize() {
 		if (this.initialized) return;
 		if (!isBrowser()) {
@@ -291,10 +345,19 @@ var RedisTaskStorage = class {
 		}
 		try {
 			const raw = await this.client.get(this.key);
-			if (raw) JSON.parse(raw).forEach((t) => this.cache.set(t.id, t));
-			this.initialized = true;
-		} catch {
+			if (raw) JSON.parse(raw).forEach((t) => {
+				if (!this.cache.has(t.id)) this.cache.set(t.id, t);
+			});
+		} catch (error) {
+			console.error("[TaskQueue] Redis initialize failed:", error);
+		} finally {
 			this.initialized = true;
+			this.readyCallbacks.forEach((cb) => cb());
+			this.readyCallbacks.clear();
+			if (this.pendingSync) {
+				this.pendingSync = false;
+				this.flush();
+			}
 		}
 	}
 	getAll() {
@@ -306,26 +369,35 @@ var RedisTaskStorage = class {
 	set(id, task) {
 		if (!isBrowser()) return;
 		this.cache.set(id, task);
-		this.syncToRedis();
+		this.scheduleSync();
 	}
 	remove(id) {
 		if (!isBrowser()) return;
 		this.cache.delete(id);
-		this.syncToRedis();
+		this.scheduleSync();
 	}
 	clear() {
 		if (!isBrowser()) return;
 		this.cache.clear();
-		this.client.del(this.key).catch(() => {});
+		this.client.del(this.key).catch((error) => {
+			console.error("[TaskQueue] Redis clear failed:", error);
+		});
+	}
+	scheduleSync() {
+		if (!this.initialized) {
+			this.pendingSync = true;
+			return;
+		}
+		this.flush();
 	}
-	syncToRedis() {
-		const tasks = this.getAll().map((task) => {
-			const { _processor, _icon, _completionActions, ...rest } = task;
-			return rest;
+	flush() {
+		this.writeChain = this.writeChain.then(async () => {
+			const value = JSON.stringify(this.getAll().map(toSerializableTask));
+			if (hasSetex(this.client)) await this.client.setex(this.key, this.ttl, value);
+			else await this.client.set(this.key, value);
+		}).catch((error) => {
+			console.error("[TaskQueue] Redis write failed:", error);
 		});
-		const value = JSON.stringify(tasks);
-		if ("setex" in this.client && typeof this.client.setex === "function") this.client.setex(this.key, this.ttl, value).catch(() => {});
-		else this.client.set(this.key, value).catch(() => {});
 	}
 };
 //#endregion
@@ -348,21 +420,62 @@ function detectStorage(options = {}) {
 	return new LocalTaskStorage(storageKey);
 }
 //#endregion
+//#region src/components/features/task-queue/engine/summary-store.ts
+/**
+* Holds the summary-dialog UI state that is intentionally decoupled from the
+* task-scheduling engine. Keeping this separate from {@link TaskQueue} means the
+* scheduler is not responsible for presentation state.
+*/
+var SummaryStore = class {
+	activeSummary = null;
+	globalRenderContent;
+	constructor(globalRenderContent) {
+		this.globalRenderContent = globalRenderContent;
+	}
+	show(title, items, options) {
+		this.activeSummary = {
+			title,
+			items,
+			renderContent: options?.renderContent
+		};
+	}
+	close() {
+		this.activeSummary = null;
+	}
+	getActive() {
+		return this.activeSummary;
+	}
+	getGlobalRenderContent() {
+		return this.globalRenderContent;
+	}
+};
+//#endregion
 //#region src/components/features/task-queue/engine/queue.ts
+const DEFAULT_TIMEOUT_MS = 3e5;
+const HEARTBEAT_INTERVAL_MS = 5e3;
+const HEARTBEAT_STALE_MS = 2e4;
 var TaskQueue = class {
 	storage;
 	concurrency;
 	runningCount = 0;
 	listeners = /* @__PURE__ */ new Set();
-	taskResolvers = /* @__PURE__ */ new Map();
 	snapshot = [];
 	notifyScheduled = false;
-	processors = /* @__PURE__ */ new Map();
-	cancelFunctions = /* @__PURE__ */ new Map();
-	onCompleteCallbacks = /* @__PURE__ */ new Map();
-	taskTimeouts = /* @__PURE__ */ new Map();
-	_activeSummary = null;
-	_summaryRenderContent;
+	/**
+	* Consolidated, engine-only runtime state (processor, live callbacks, timers)
+	* keyed by task id. Never serialized — persisted tasks only carry the
+	* serializable {@link TaskView} half.
+	*/
+	runtimes = /* @__PURE__ */ new Map();
+	summary;
+	disposed = false;
+	unsubscribeExternal;
+	/** Unique id for this queue instance, used to claim ownership of tasks it runs. */
+	instanceId = generateTaskId();
+	/** True when the backend broadcasts writes across tabs (localStorage). */
+	sharedStorage = false;
+	/** Keepalive that re-stamps this instance's live tasks in shared storage. */
+	heartbeatTimer;
 	constructor(config = {}) {
 		this.concurrency = config.concurrency ?? TASK_QUEUE_DEFAULTS.concurrency;
 		this.storage = config.storage ?? detectStorage({
@@ -370,7 +483,16 @@ var TaskQueue = class {
 			storageKey: config.storageKey,
 			storageType: config.storageType
 		});
-		this._summaryRenderContent = config.summaryRenderContent;
+		this.summary = new SummaryStore(config.summaryRenderContent);
+		this.sharedStorage = typeof this.storage.onExternalChange === "function";
+		this.storage.onReady?.(() => {
+			this.reconcileOrphans();
+			this.notify();
+		});
+		this.unsubscribeExternal = this.storage.onExternalChange?.(() => {
+			this.notify();
+		});
+		this.reconcileOrphans();
 		this.updateSnapshot();
 	}
 	subscribe = (listener) => {
@@ -394,12 +516,91 @@ var TaskQueue = class {
 	updateSnapshot() {
 		this.snapshot = this.storage.getAll();
 	}
+	/**
+	* Mark tasks a previous session left in a non-terminal state (no live
+	* processor exists for them) as failed, so they become dismissible and stop
+	* triggering the beforeunload guard instead of being stuck forever.
+	*/
+	reconcileOrphans() {
+		const tasks = this.storage.getAll();
+		const now = Date.now();
+		for (const task of tasks) {
+			if (!(task.status === "pending" || task.status === "running")) continue;
+			if (this.runtimes.has(task.id)) continue;
+			if (this.sharedStorage && this.isLiveForeignTask(task, now)) continue;
+			const reconciled = {
+				...task,
+				status: "failed",
+				cancelable: false,
+				retryable: false,
+				completedAt: Date.now(),
+				failedItems: [...task.failedItems, { message: "Task interrupted (page was reloaded)" }]
+			};
+			this.storage.set(task.id, reconciled);
+		}
+	}
+	/**
+	* True when a non-terminal task is claimed by a *different* instance whose
+	* heartbeat is still fresh — i.e. another live tab is running it. A task
+	* without an ownership stamp (legacy, or persisted by a now-dead session) is
+	* not "live foreign" and remains eligible for reconciliation.
+	*/
+	isLiveForeignTask(task, now) {
+		const owned = task;
+		if (owned._ownerId === void 0 || owned._heartbeatAt === void 0) return false;
+		if (owned._ownerId === this.instanceId) return false;
+		return now - owned._heartbeatAt < HEARTBEAT_STALE_MS;
+	}
+	/** Stamp this instance's ownership on a task before it is written to shared storage. */
+	withOwnership(task) {
+		if (!this.sharedStorage) return task;
+		return {
+			...task,
+			_ownerId: this.instanceId,
+			_heartbeatAt: Date.now()
+		};
+	}
+	/** Start the heartbeat keepalive if shared storage is in use and it is not already running. */
+	ensureHeartbeat() {
+		if (!this.sharedStorage || this.heartbeatTimer || this.disposed) return;
+		this.heartbeatTimer = setInterval(() => this.beat(), HEARTBEAT_INTERVAL_MS);
+	}
+	/**
+	* Refresh the ownership timestamp on every non-terminal task this instance is
+	* actively running, so other tabs keep seeing them as live. Self-stops once
+	* this instance has no more active tasks.
+	*/
+	beat() {
+		const now = Date.now();
+		let active = false;
+		for (const task of this.storage.getAll()) {
+			if (!this.runtimes.has(task.id)) continue;
+			if (task.status !== "running" && task.status !== "pending") continue;
+			active = true;
+			const owned = {
+				...task,
+				_ownerId: this.instanceId,
+				_heartbeatAt: now
+			};
+			this.storage.set(task.id, owned);
+		}
+		if (!active) this.stopHeartbeat();
+	}
+	stopHeartbeat() {
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = void 0;
+		}
+	}
 	enqueue = (options) => {
 		const id = generateTaskId();
 		const items = options.items;
 		let processor;
-		if ("processItem" in options && options.processItem) processor = this.buildProcessor(options);
-		else if ("processor" in options && options.processor) processor = options.processor;
+		let getItemId;
+		if ("processItem" in options && options.processItem) {
+			processor = this.buildProcessor(options);
+			getItemId = options.getItemId;
+		} else if ("processor" in options && options.processor) processor = options.processor;
 		else throw new Error("[TaskQueue] enqueue: must provide either processor or processItem");
 		const cancelable = options.cancelable ?? TASK_QUEUE_DEFAULTS.cancelable;
 		const confirmBeforeUnload = options.confirmBeforeUnload ?? true;
@@ -423,21 +624,24 @@ var TaskQueue = class {
 			completionActions: options.completionActions,
 			retryCount: 0,
 			createdAt: Date.now(),
-			_processor: processor,
 			_originalItems: items ? [...items] : void 0
 		};
-		this.processors.set(id, processor);
-		if (options.onComplete) this.onCompleteCallbacks.set(id, options.onComplete);
-		this.storage.set(id, task);
-		this.notify();
-		const timeout = options.timeout ?? 3e5;
-		const timeoutId = setTimeout(() => {
-			this.handleTaskTimeout(id);
-		}, timeout);
-		this.taskTimeouts.set(id, timeoutId);
+		const requestedTimeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+		const timeoutMs = requestedTimeout > 0 ? requestedTimeout : void 0;
+		this.runtimes.set(id, {
+			processor,
+			originalItems: items ? [...items] : void 0,
+			getItemId,
+			onComplete: options.onComplete,
+			timeoutMs
+		});
 		const promise = new Promise((resolve) => {
-			this.taskResolvers.set(id, resolve);
+			const runtime = this.runtimes.get(id);
+			if (runtime) runtime.resolve = resolve;
 		});
+		this.storage.set(id, this.withOwnership(task));
+		this.notify();
+		this.ensureHeartbeat();
 		this.drain();
 		return {
 			id,
@@ -447,63 +651,102 @@ var TaskQueue = class {
 	};
 	cancel = (taskId) => {
 		const task = this.storage.get(taskId);
-		if (!task || task.status !== "running") return;
-		const setCancelled = this.cancelFunctions.get(taskId);
-		if (setCancelled) setCancelled(true);
+		if (!task) return;
+		if (task.status === "running") {
+			this.runtimes.get(taskId)?.setCancelled?.(true);
+			return;
+		}
+		if (task.status === "pending") {
+			this.clearTaskTimeout(taskId);
+			const cancelled = {
+				...task,
+				status: "cancelled",
+				completedAt: Date.now()
+			};
+			this.storage.set(taskId, cancelled);
+			this.notify();
+			this.finalize(taskId, {
+				status: "cancelled",
+				completed: cancelled.completed,
+				failed: cancelled.failed,
+				failedItems: [...cancelled.failedItems],
+				result: cancelled.result
+			}, true);
+		}
 	};
 	retry = (taskId) => {
 		const task = this.storage.get(taskId);
 		if (!task) return;
 		if (task.status !== "failed" && task.status !== "cancelled") return;
-		const processor = this.processors.get(taskId);
-		if (!processor) {
+		const runtime = this.runtimes.get(taskId);
+		if (!runtime?.processor) {
 			console.error("[TaskQueue] retry: no processor found for task", taskId);
 			return;
 		}
-		if (task.items && task.items.length > 0) {
+		const isBatchTask = task.items && task.items.length > 0;
+		let next;
+		if (isBatchTask) {
 			const remainingItems = this.getRetryItems(task);
 			if (!remainingItems || remainingItems.length === 0) {
 				const succeededItems = task.succeededItems ?? [];
-				const originalItems = task._originalItems ?? task.items ?? [];
+				const originalItems = runtime.originalItems ?? task._originalItems ?? task.items ?? [];
 				if (succeededItems.length >= originalItems.length || task.completed >= (task.total ?? 0)) {
-					task.status = "completed";
-					task.completedAt = Date.now();
-					this.storage.set(taskId, task);
+					const completed = {
+						...task,
+						status: "completed",
+						completedAt: Date.now()
+					};
+					this.storage.set(taskId, completed);
 					this.notify();
+					this.finalize(taskId, {
+						status: "completed",
+						completed: completed.completed,
+						failed: completed.failed,
+						failedItems: [...completed.failedItems],
+						result: completed.result
+					}, false);
 					return;
 				}
 				console.warn("[TaskQueue] retry: no remaining items for task", taskId);
 				return;
 			}
-			task.status = "pending";
-			task.items = remainingItems;
-			task.failedItems = [];
-			task.failed = 0;
-			task.retryCount += 1;
-		} else {
-			task.status = "pending";
-			task.completed = 0;
-			task.failed = 0;
-			task.succeededItems = [];
-			task.failedItems = [];
-			task.result = void 0;
-			task.retryCount += 1;
-		}
-		task.startedAt = void 0;
-		task.completedAt = void 0;
-		this.processors.set(taskId, processor);
-		this.storage.set(taskId, task);
+			next = {
+				...task,
+				status: "pending",
+				items: remainingItems,
+				failedItems: [],
+				failed: 0,
+				retryCount: task.retryCount + 1,
+				startedAt: void 0,
+				completedAt: void 0
+			};
+		} else next = {
+			...task,
+			status: "pending",
+			completed: 0,
+			failed: 0,
+			succeededItems: [],
+			failedItems: [],
+			result: void 0,
+			retryCount: task.retryCount + 1,
+			startedAt: void 0,
+			completedAt: void 0
+		};
+		this.storage.set(taskId, this.withOwnership(next));
 		this.notify();
+		this.ensureHeartbeat();
 		this.drain();
 	};
 	getRetryItems(task) {
-		const originalItems = task._originalItems ?? task.items;
+		const runtime = this.runtimes.get(task.id);
+		const originalItems = runtime?.originalItems ?? task._originalItems ?? task.items;
 		if (!originalItems || originalItems.length === 0) return void 0;
+		const getItemId = runtime?.getItemId;
 		const succeededItems = task.succeededItems ?? [];
 		const failedItems = task.failedItems ?? [];
 		if (task.status === "cancelled" && succeededItems.length > 0) {
 			const remaining = originalItems.filter((item) => {
-				const itemId = this.resolveItemId(item);
+				const itemId = this.resolveItemId(item, getItemId);
 				if (!itemId) return true;
 				return !succeededItems.includes(itemId);
 			});
@@ -511,7 +754,7 @@ var TaskQueue = class {
 		}
 		if (task.status === "failed" && failedItems.length > 0) {
 			const failed = originalItems.filter((item) => {
-				const itemId = this.resolveItemId(item);
+				const itemId = this.resolveItemId(item, getItemId);
 				if (!itemId) return false;
 				return failedItems.some((fi) => fi.id === itemId);
 			});
@@ -521,7 +764,10 @@ var TaskQueue = class {
 	}
 	/** Extract ID from an item using custom extractor or shared utility */
 	resolveItemId(item, getItemId) {
-		if (getItemId) return getItemId(item);
+		if (getItemId) {
+			const custom = getItemId(item);
+			if (custom !== void 0) return custom;
+		}
 		const id = extractItemId(item);
 		if (id !== void 0) return id;
 		try {
@@ -535,38 +781,63 @@ var TaskQueue = class {
 		if (!task) return;
 		if (task.status === "running" || task.status === "pending") return;
 		this.storage.remove(taskId);
-		this.processors.delete(taskId);
-		this.onCompleteCallbacks.delete(taskId);
+		this.cleanupRuntime(taskId);
 		this.notify();
 	};
 	dismissAll = () => {
 		this.storage.getAll().forEach((task) => {
 			if (task.status !== "running" && task.status !== "pending") {
 				this.storage.remove(task.id);
-				this.processors.delete(task.id);
-				this.onCompleteCallbacks.delete(task.id);
+				this.cleanupRuntime(task.id);
 			}
 		});
 		this.notify();
 	};
 	showSummary = (title, items, options) => {
-		this._activeSummary = {
-			title,
-			items,
-			renderContent: options?.renderContent
-		};
+		this.summary.show(title, items, options);
 		this.notify();
 	};
 	closeSummary = () => {
-		this._activeSummary = null;
+		this.summary.close();
 		this.notify();
 	};
 	getActiveSummary = () => {
-		return this._activeSummary;
+		return this.summary.getActive();
 	};
 	getSummaryRenderContent = () => {
-		return this._summaryRenderContent;
+		return this.summary.getGlobalRenderContent();
 	};
+	/**
+	* Fully tear down the queue: cancel in-flight and pending tasks, clear all
+	* timers and listeners. Call from the provider on unmount so a re-mounted
+	* provider does not leave orphaned timers/listeners behind.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.stopHeartbeat();
+		this.storage.getAll().forEach((task) => {
+			if (task.status === "running" || task.status === "pending") this.cancel(task.id);
+		});
+		this.runtimes.forEach((runtime, taskId) => {
+			if (runtime.timeoutId) clearTimeout(runtime.timeoutId);
+			const resolve = runtime.resolve;
+			if (resolve) {
+				const task = this.storage.get(taskId);
+				resolve({
+					status: "cancelled",
+					completed: task?.completed ?? 0,
+					failed: task?.failed ?? 0,
+					failedItems: task ? [...task.failedItems] : [],
+					result: task?.result
+				});
+				runtime.resolve = void 0;
+			}
+		});
+		this.runtimes.clear();
+		this.listeners.clear();
+		this.unsubscribeExternal?.();
+	}
 	buildProcessor(options) {
 		const { processItem, itemConcurrency = 1, getItemId, errorStrategy = "continue" } = options;
 		return async (ctx) => {
@@ -623,81 +894,112 @@ var TaskQueue = class {
 	}
 	async runTask(task) {
 		this.runningCount += 1;
-		const processor = this.processors.get(task.id);
-		if (!processor) {
-			console.error("[TaskQueue] No processor found for task", task.id);
+		const runtime = this.runtimes.get(task.id);
+		if (!runtime?.processor) {
+			this.failOrphan(task.id);
 			this.runningCount -= 1;
+			this.drain();
 			return;
 		}
-		task._processor = processor;
+		runtime.timedOut = false;
+		if (runtime.timeoutMs != null) runtime.timeoutId = setTimeout(() => this.handleTaskTimeout(task.id), runtime.timeoutMs);
 		try {
-			const outcome = await executeTask(task, {
+			const outcome = await executeTask(task, runtime.processor, {
 				onUpdate: (updated) => {
+					if (this.runtimes.get(task.id)?.timedOut) return;
 					this.storage.set(updated.id, updated);
 					this.notify();
 				},
 				onCancelReady: (setCancelled) => {
-					this.cancelFunctions.set(task.id, setCancelled);
+					const rt = this.runtimes.get(task.id);
+					if (rt) rt.setCancelled = setCancelled;
 				},
 				onTaskComplete: () => {
 					this.clearTaskTimeout(task.id);
 				}
 			});
-			const onComplete = this.onCompleteCallbacks.get(task.id);
-			if (onComplete) try {
-				await onComplete(outcome);
-			} catch (error) {
-				console.error("[TaskQueue] onComplete callback error:", error);
-			}
-			const resolver = this.taskResolvers.get(task.id);
-			if (resolver) {
-				resolver(outcome);
-				this.taskResolvers.delete(task.id);
-			}
-			if (outcome.status === "completed") {
-				this.processors.delete(task.id);
-				this.onCompleteCallbacks.delete(task.id);
-			}
+			if (this.runtimes.get(task.id)?.timedOut) return;
+			await this.finalize(task.id, outcome, outcome.status !== "completed");
 		} finally {
 			this.runningCount -= 1;
-			this.cancelFunctions.delete(task.id);
+			const rt = this.runtimes.get(task.id);
+			if (rt) rt.setCancelled = void 0;
 			this.drain();
 		}
 	}
-	handleTaskTimeout(taskId) {
+	/**
+	* Resolve a task's awaited handle and fire its onComplete callback exactly
+	* once. When {@link keepForRetry} is false the runtime is discarded.
+	*/
+	async finalize(taskId, outcome, keepForRetry) {
+		this.clearTaskTimeout(taskId);
+		const runtime = this.runtimes.get(taskId);
+		if (runtime?.onComplete) try {
+			await runtime.onComplete(outcome);
+		} catch (error) {
+			console.error("[TaskQueue] onComplete callback error:", error);
+		}
+		const resolve = runtime?.resolve;
+		if (resolve) {
+			resolve(outcome);
+			if (runtime) runtime.resolve = void 0;
+		}
+		if (!keepForRetry) this.cleanupRuntime(taskId);
+	}
+	failOrphan(taskId) {
 		const task = this.storage.get(taskId);
-		if (!task || task.status !== "running") return;
-		const setCancelled = this.cancelFunctions.get(taskId);
-		if (setCancelled) setCancelled(true);
-		task.status = "failed";
-		task.completedAt = Date.now();
-		task.failedItems = [...task.failedItems, { message: "Task timeout: exceeded maximum execution time" }];
-		task.failed += 1;
-		this.storage.set(taskId, task);
+		if (!task) return;
+		const failed = {
+			...task,
+			status: "failed",
+			cancelable: false,
+			retryable: false,
+			completedAt: Date.now(),
+			failedItems: [...task.failedItems, { message: "Task interrupted (no active processor)" }]
+		};
+		this.storage.set(taskId, failed);
+		this.cleanupRuntime(taskId);
 		this.notify();
-		const resolver = this.taskResolvers.get(taskId);
-		if (resolver) {
-			resolver({
-				status: "failed",
-				completed: task.completed,
-				failed: task.failed,
-				failedItems: [...task.failedItems],
-				result: task.result
-			});
-			this.taskResolvers.delete(taskId);
+	}
+	handleTaskTimeout(taskId) {
+		const runtime = this.runtimes.get(taskId);
+		if (runtime) runtime.timeoutId = void 0;
+		const task = this.storage.get(taskId);
+		if (!task) {
+			this.cleanupRuntime(taskId);
+			return;
 		}
-		this.processors.delete(taskId);
-		this.onCompleteCallbacks.delete(taskId);
-		this.cancelFunctions.delete(taskId);
-		this.taskTimeouts.delete(taskId);
+		if (task.status !== "running") return;
+		if (runtime) runtime.timedOut = true;
+		runtime?.setCancelled?.(true);
+		const failed = {
+			...task,
+			status: "failed",
+			completedAt: Date.now(),
+			failedItems: [...task.failedItems, { message: "Task timeout: exceeded maximum execution time" }],
+			failed: task.failed + 1
+		};
+		this.storage.set(taskId, failed);
+		this.notify();
+		this.finalize(taskId, {
+			status: "failed",
+			completed: failed.completed,
+			failed: failed.failed,
+			failedItems: [...failed.failedItems],
+			result: failed.result
+		}, true);
 	}
 	clearTaskTimeout(taskId) {
-		const timeoutId = this.taskTimeouts.get(taskId);
-		if (timeoutId) {
-			clearTimeout(timeoutId);
-			this.taskTimeouts.delete(taskId);
+		const runtime = this.runtimes.get(taskId);
+		if (runtime?.timeoutId) {
+			clearTimeout(runtime.timeoutId);
+			runtime.timeoutId = void 0;
 		}
 	}
+	cleanupRuntime(taskId) {
+		this.clearTaskTimeout(taskId);
+		this.runtimes.delete(taskId);
+	}
 };
 //#endregion
 //#region src/components/features/task-queue/provider/task-queue-provider.tsx
@@ -709,9 +1011,8 @@ function TaskQueueProvider({ children, config }) {
 		const queue = queueRef.current;
 		return () => {
 			if (!queue) return;
-			queue.getSnapshot().forEach((task) => {
-				if (task.status === "running") queue.cancel(task.id);
-			});
+			queue.dispose();
+			queueRef.current = null;
 		};
 	}, []);
 	useEffect(() => {
@@ -1046,14 +1347,14 @@ function TaskStatusAction({ task, onCancel }) {
 	if (task.status === "running") return /* @__PURE__ */ jsxs("div", {
 		className: "relative size-5",
 		children: [/* @__PURE__ */ jsx("div", {
-			className: "pointer-events-none absolute inset-0 flex items-center justify-center transition-opacity group-hover:opacity-0",
+			className: "pointer-events-none absolute inset-0 flex items-center justify-center transition-opacity group-hover:opacity-0 group-focus-within:opacity-0",
 			children: /* @__PURE__ */ jsx(SpinnerIcon, { size: "sm" })
 		}), task.cancelable && /* @__PURE__ */ jsxs(Tooltip, { children: [/* @__PURE__ */ jsx(TooltipTrigger, {
 			asChild: true,
 			children: /* @__PURE__ */ jsx("button", {
 				type: "button",
 				onClick: onCancel,
-				className: cn("flex size-5 items-center justify-center rounded-md transition-colors", "text-muted-foreground hover:bg-accent hover:text-foreground", "absolute inset-0 opacity-0 transition-opacity group-hover:opacity-100"),
+				className: cn("flex size-5 items-center justify-center rounded-md transition-colors", "text-muted-foreground hover:bg-accent hover:text-foreground", "absolute inset-0 opacity-0 transition-opacity group-hover:opacity-100 focus-visible:opacity-100", "focus-visible:ring-ring focus-visible:ring-2 focus-visible:outline-none"),
 				"aria-label": "Cancel task",
 				children: /* @__PURE__ */ jsx(Icon, {
 					icon: X,
@@ -1114,7 +1415,10 @@ function TaskQueueTrigger({ ref, tasks, ...props }) {
 			const timer = setTimeout(setFlash, 5e3, false);
 			return () => clearTimeout(timer);
 		}
-		if (!isAllComplete) prevAllComplete.current = false;
+		if (!isAllComplete) {
+			prevAllComplete.current = false;
+			setFlash(false);
+		}
 	}, [isAllComplete]);
 	useEffect(() => {
 		if (tasks.length === 0) {