@datum-cloud/datum-ui 0.2.0-alpha.3 → 0.2.0-alpha.5

package/dist/task-queue-dropdown-DW72ikDH.mjs

@@ -0,0 +1,1356 @@
+import { t as cn } from "./cn-DWCc1QRE.mjs";
+import { t as Badge } from "./badge-bFgeYceE.mjs";
+import { t as SpinnerIcon } from "./spinner.icon-Bg8zgGh0.mjs";
+import { t as Button } from "./button-C1wRfGtT.mjs";
+import { t as Icon } from "./icon-wrapper-9ticVbRL.mjs";
+import { t as Dialog } from "./dialog-bnMMf9GD.mjs";
+import { c as TableRow, i as TableCell, n as TableBody, o as TableHead, s as TableHeader, t as Table } from "./table-CsXBcQLI.mjs";
+import { a as TooltipTrigger, n as Tooltip, r as TooltipContent, t as Tooltip$1 } from "./tooltip-Dd3ActSS.mjs";
+import { h as DropdownMenuTrigger, r as DropdownMenuContent, t as DropdownMenu } from "./dropdown-DtSa_lqc.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";
+import { formatDistanceToNowStrict } from "date-fns";
+
+//#region src/components/features/task-queue/engine/executor.ts
+function createTaskContext(task, callbacks) {
+	let cancelled = false;
+	let shouldStop = false;
+	const cleanupCallbacks = [];
+	const updateTask = () => {
+		callbacks.onUpdate({
+			...task,
+			succeededItems: [...task.succeededItems],
+			failedItems: [...task.failedItems]
+		});
+	};
+	return {
+		ctx: {
+			get items() {
+				return task.items ?? [];
+			},
+			get cancelled() {
+				return cancelled || shouldStop;
+			},
+			get failedItems() {
+				return [...task.failedItems];
+			},
+			succeed(itemId) {
+				task.completed += 1;
+				if (itemId) task.succeededItems = [...task.succeededItems, itemId];
+				updateTask();
+			},
+			fail(itemId, message) {
+				task.failed += 1;
+				if (itemId || message) task.failedItems = [...task.failedItems, {
+					id: itemId,
+					message: message ?? "Unknown error"
+				}];
+				if (task.errorStrategy === "stop") shouldStop = true;
+				updateTask();
+			},
+			setTitle(title) {
+				task.title = title;
+				updateTask();
+			},
+			setResult(result) {
+				task.result = result;
+			},
+			onCancel(cleanup) {
+				cleanupCallbacks.push(cleanup);
+			}
+		},
+		getCancelled: () => cancelled,
+		setCancelled: (v) => {
+			cancelled = v;
+			if (v) cleanupCallbacks.forEach((cleanup) => {
+				try {
+					cleanup();
+				} catch (error) {
+					console.error("[TaskQueue] Cleanup callback error:", error);
+				}
+			});
+		},
+		getShouldStop: () => shouldStop
+	};
+}
+async function executeTask(task, callbacks) {
+	const processor = task._processor;
+	if (!processor) return {
+		status: "failed",
+		completed: 0,
+		failed: 0,
+		failedItems: [{ message: "No processor attached" }]
+	};
+	task.status = "running";
+	task.startedAt = Date.now();
+	if (!task.succeededItems) task.succeededItems = [];
+	callbacks.onUpdate({ ...task });
+	const { ctx, getCancelled, setCancelled, getShouldStop } = createTaskContext(task, callbacks);
+	callbacks.onCancelReady?.(setCancelled);
+	try {
+		await processor(ctx);
+		if (getCancelled()) task.status = "cancelled";
+		else if (getShouldStop() || task.failed > 0) task.status = "failed";
+		else task.status = "completed";
+	} catch (error) {
+		task.status = "failed";
+		const message = error instanceof Error ? error.message : "Unknown error";
+		task.failedItems = [...task.failedItems, { message }];
+		task.failed += 1;
+	}
+	task.completedAt = Date.now();
+	callbacks.onUpdate({ ...task });
+	callbacks.onTaskComplete?.();
+	return {
+		status: task.status,
+		completed: task.completed,
+		failed: task.failed,
+		failedItems: [...task.failedItems],
+		result: task.result
+	};
+}
+
+//#endregion
+//#region src/components/features/task-queue/constants.ts
+const TASK_QUEUE_DEFAULTS = {
+	concurrency: 3,
+	errorStrategy: "continue",
+	cancelable: true,
+	retryable: true
+};
+const TASK_STORAGE_KEY = "datum-task-queue";
+
+//#endregion
+//#region src/components/features/task-queue/utils/index.ts
+/**
+* Check if code is running in a browser environment.
+* Used for SSR safety in storage and other browser-dependent code.
+*/
+function isBrowser() {
+	return typeof window !== "undefined" && typeof localStorage !== "undefined";
+}
+function generateTaskId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return `task_${crypto.randomUUID()}`;
+	return `task_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Extract an ID from an item using common patterns.
+* Checks: primitives (string/number) → obj.id → obj.name → obj.key → obj.uuid
+*/
+function extractItemId(item) {
+	if (typeof item === "string" || typeof item === "number") return String(item);
+	if (item && typeof item === "object") {
+		const obj = item;
+		if (typeof obj.id === "string" || typeof obj.id === "number") return String(obj.id);
+		if (typeof obj.name === "string") return obj.name;
+		if (typeof obj.key === "string") return obj.key;
+		if (typeof obj.uuid === "string") return obj.uuid;
+	}
+}
+/**
+* Create metadata for project-scoped tasks.
+* Use this when enqueueing tasks that operate on project resources.
+*/
+function createProjectMetadata(project, org, extra) {
+	return {
+		scope: "project",
+		projectId: project.id,
+		projectName: project.name,
+		orgId: org.id,
+		orgName: org.name,
+		...extra
+	};
+}
+/**
+* Create metadata for organization-scoped tasks.
+* Use this when enqueueing tasks that operate on org-level resources.
+*/
+function createOrgMetadata(org, extra) {
+	return {
+		scope: "org",
+		orgId: org.id,
+		orgName: org.name,
+		...extra
+	};
+}
+/**
+* Create metadata for user-scoped tasks.
+* Use this when enqueueing tasks that operate on user-level resources.
+*/
+function createUserMetadata(extra) {
+	return {
+		scope: "user",
+		...extra
+	};
+}
+
+//#endregion
+//#region src/components/features/task-queue/engine/storage/local-storage.ts
+var LocalTaskStorage = class {
+	key;
+	constructor(key = TASK_STORAGE_KEY) {
+		this.key = key;
+	}
+	getAll() {
+		if (!isBrowser()) return [];
+		try {
+			const raw = localStorage.getItem(this.key);
+			return raw ? JSON.parse(raw) : [];
+		} catch {
+			return [];
+		}
+	}
+	get(id) {
+		if (!isBrowser()) return void 0;
+		return this.getAll().find((t) => t.id === id);
+	}
+	set(id, task) {
+		if (!isBrowser()) return;
+		const tasks = this.getAll();
+		const index = tasks.findIndex((t) => t.id === id);
+		if (index >= 0) tasks[index] = task;
+		else tasks.push(task);
+		this.persist(tasks);
+	}
+	remove(id) {
+		if (!isBrowser()) return;
+		const tasks = this.getAll().filter((t) => t.id !== id);
+		this.persist(tasks);
+	}
+	clear() {
+		if (!isBrowser()) return;
+		try {
+			localStorage.removeItem(this.key);
+		} catch {}
+	}
+	persist(tasks) {
+		try {
+			const serializable = tasks.map((task) => {
+				const { _processor, _icon, _completionActions, ...rest } = task;
+				return rest;
+			});
+			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.");
+		}
+	}
+};
+
+//#endregion
+//#region src/components/features/task-queue/engine/storage/memory-storage.ts
+/**
+* In-memory task storage.
+*
+* Tasks are stored in a Map and lost on page reload.
+* Use with beforeunload warning to alert users of active tasks.
+*
+* SSR-safe: works on both server and client (just empty on server).
+*/
+var MemoryTaskStorage = class {
+	tasks = /* @__PURE__ */ new Map();
+	getAll() {
+		return Array.from(this.tasks.values());
+	}
+	get(id) {
+		return this.tasks.get(id);
+	}
+	set(id, task) {
+		this.tasks.set(id, task);
+	}
+	remove(id) {
+		this.tasks.delete(id);
+	}
+	clear() {
+		this.tasks.clear();
+	}
+};
+
+//#endregion
+//#region src/components/features/task-queue/engine/storage/redis-storage.ts
+const DEFAULT_TTL = 3600 * 24 * 7;
+var RedisTaskStorage = class {
+	client;
+	key;
+	cache = /* @__PURE__ */ new Map();
+	initialized = false;
+	initPromise = null;
+	ttl;
+	constructor(client, key = TASK_STORAGE_KEY, ttl = DEFAULT_TTL) {
+		this.client = client;
+		this.key = key;
+		this.ttl = ttl;
+		if (isBrowser()) this.initPromise = this.initialize();
+	}
+	/**
+	* Wait for initialization to complete.
+	* Call this before accessing data if you need guaranteed consistency.
+	*/
+	async waitForInit() {
+		if (this.initPromise) await this.initPromise;
+	}
+	async initialize() {
+		if (this.initialized) return;
+		if (!isBrowser()) {
+			this.initialized = true;
+			return;
+		}
+		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 {
+			this.initialized = true;
+		}
+	}
+	getAll() {
+		return Array.from(this.cache.values());
+	}
+	get(id) {
+		return this.cache.get(id);
+	}
+	set(id, task) {
+		if (!isBrowser()) return;
+		this.cache.set(id, task);
+		this.syncToRedis();
+	}
+	remove(id) {
+		if (!isBrowser()) return;
+		this.cache.delete(id);
+		this.syncToRedis();
+	}
+	clear() {
+		if (!isBrowser()) return;
+		this.cache.clear();
+		this.client.del(this.key).catch(() => {});
+	}
+	syncToRedis() {
+		const tasks = this.getAll().map((task) => {
+			const { _processor, _icon, _completionActions, ...rest } = task;
+			return rest;
+		});
+		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
+//#region src/components/features/task-queue/engine/storage/detect-storage.ts
+/**
+* Auto-detects and returns the appropriate storage backend.
+*
+* Storage types:
+* - `memory` (default): In-memory storage, tasks lost on reload
+* - `local`: Browser localStorage, tasks persist across reloads
+* - `auto`: Uses Redis if available, otherwise localStorage
+*
+* All storage backends are SSR-safe and will return empty data on the server.
+*/
+function detectStorage(options = {}) {
+	const { redisClient, storageKey, storageType = "memory" } = options;
+	if (storageType === "memory") return new MemoryTaskStorage();
+	if (storageType === "local") return new LocalTaskStorage(storageKey);
+	if (redisClient && redisClient.status === "ready") return new RedisTaskStorage(redisClient, storageKey);
+	return new LocalTaskStorage(storageKey);
+}
+
+//#endregion
+//#region src/components/features/task-queue/engine/queue.ts
+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;
+	constructor(config = {}) {
+		this.concurrency = config.concurrency ?? TASK_QUEUE_DEFAULTS.concurrency;
+		this.storage = config.storage ?? detectStorage({
+			redisClient: config.redisClient,
+			storageKey: config.storageKey,
+			storageType: config.storageType
+		});
+		this._summaryRenderContent = config.summaryRenderContent;
+		this.updateSnapshot();
+	}
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+	getSnapshot = () => {
+		return this.snapshot;
+	};
+	notify() {
+		if (this.notifyScheduled) return;
+		this.notifyScheduled = true;
+		queueMicrotask(() => {
+			this.notifyScheduled = false;
+			this.updateSnapshot();
+			this.listeners.forEach((listener) => listener());
+		});
+	}
+	updateSnapshot() {
+		this.snapshot = this.storage.getAll();
+	}
+	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;
+		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;
+		const task = {
+			id,
+			title: options.title,
+			status: "pending",
+			icon: options.icon,
+			category: options.category,
+			metadata: options.metadata,
+			items,
+			total: items?.length,
+			completed: 0,
+			failed: 0,
+			succeededItems: [],
+			failedItems: [],
+			errorStrategy: options.errorStrategy ?? TASK_QUEUE_DEFAULTS.errorStrategy,
+			cancelable,
+			retryable: options.retryable ?? TASK_QUEUE_DEFAULTS.retryable,
+			confirmBeforeUnload,
+			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 promise = new Promise((resolve) => {
+			this.taskResolvers.set(id, resolve);
+		});
+		this.drain();
+		return {
+			id,
+			cancel: () => this.cancel(id),
+			promise
+		};
+	};
+	cancel = (taskId) => {
+		const task = this.storage.get(taskId);
+		if (!task || task.status !== "running") return;
+		const setCancelled = this.cancelFunctions.get(taskId);
+		if (setCancelled) setCancelled(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) {
+			console.error("[TaskQueue] retry: no processor found for task", taskId);
+			return;
+		}
+		if (task.items && task.items.length > 0) {
+			const remainingItems = this.getRetryItems(task);
+			if (!remainingItems || remainingItems.length === 0) {
+				const succeededItems = task.succeededItems ?? [];
+				const 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);
+					this.notify();
+					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);
+		this.notify();
+		this.drain();
+	};
+	getRetryItems(task) {
+		const originalItems = task._originalItems ?? task.items;
+		if (!originalItems || originalItems.length === 0) return void 0;
+		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);
+				if (!itemId) return true;
+				return !succeededItems.includes(itemId);
+			});
+			return remaining.length > 0 ? remaining : void 0;
+		}
+		if (task.status === "failed" && failedItems.length > 0) {
+			const failed = originalItems.filter((item) => {
+				const itemId = this.resolveItemId(item);
+				if (!itemId) return false;
+				return failedItems.some((fi) => fi.id === itemId);
+			});
+			return failed.length > 0 ? failed : void 0;
+		}
+		return originalItems;
+	}
+	/** Extract ID from an item using custom extractor or shared utility */
+	resolveItemId(item, getItemId) {
+		if (getItemId) return getItemId(item);
+		const id = extractItemId(item);
+		if (id !== void 0) return id;
+		try {
+			return JSON.stringify(item);
+		} catch {
+			return;
+		}
+	}
+	dismiss = (taskId) => {
+		const task = this.storage.get(taskId);
+		if (!task) return;
+		if (task.status === "running" || task.status === "pending") return;
+		this.storage.remove(taskId);
+		this.processors.delete(taskId);
+		this.onCompleteCallbacks.delete(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.notify();
+	};
+	showSummary = (title, items, options) => {
+		this._activeSummary = {
+			title,
+			items,
+			renderContent: options?.renderContent
+		};
+		this.notify();
+	};
+	closeSummary = () => {
+		this._activeSummary = null;
+		this.notify();
+	};
+	getActiveSummary = () => {
+		return this._activeSummary;
+	};
+	getSummaryRenderContent = () => {
+		return this._summaryRenderContent;
+	};
+	buildProcessor(options) {
+		const { processItem, itemConcurrency = 1, getItemId, errorStrategy = "continue" } = options;
+		return async (ctx) => {
+			const pending = [...ctx.items];
+			const inFlight = [];
+			while (pending.length > 0 || inFlight.length > 0) {
+				if (ctx.cancelled) break;
+				if (errorStrategy === "stop" && ctx.failedItems.length > 0) break;
+				while (inFlight.length < itemConcurrency && pending.length > 0) {
+					const item = pending.shift();
+					const itemId = this.resolveItemId(item, getItemId) ?? String(item);
+					const promise = this.processOneItem(item, itemId, processItem, ctx).finally(() => {
+						const idx = inFlight.indexOf(promise);
+						if (idx !== -1) inFlight.splice(idx, 1);
+					});
+					inFlight.push(promise);
+				}
+				if (inFlight.length > 0) await Promise.race(inFlight);
+			}
+		};
+	}
+	async processOneItem(item, itemId, processItem, ctx) {
+		let manuallyHandled = false;
+		const itemCtx = {
+			get cancelled() {
+				return ctx.cancelled;
+			},
+			succeed: (id) => {
+				manuallyHandled = true;
+				ctx.succeed(id ?? itemId);
+			},
+			fail: (id, message) => {
+				manuallyHandled = true;
+				ctx.fail(id ?? itemId, message);
+			}
+		};
+		try {
+			await processItem(item, itemCtx);
+			if (!manuallyHandled) ctx.succeed(itemId);
+		} catch (error) {
+			if (!manuallyHandled) {
+				const message = error instanceof Error ? error.message : "Unknown error";
+				ctx.fail(itemId, message);
+			}
+		}
+	}
+	drain() {
+		const pending = this.storage.getAll().filter((t) => t.status === "pending");
+		while (this.runningCount < this.concurrency && pending.length > 0) {
+			const next = pending.shift();
+			if (!next) break;
+			this.runTask(next);
+		}
+	}
+	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);
+			this.runningCount -= 1;
+			return;
+		}
+		task._processor = processor;
+		try {
+			const outcome = await executeTask(task, {
+				onUpdate: (updated) => {
+					this.storage.set(updated.id, updated);
+					this.notify();
+				},
+				onCancelReady: (setCancelled) => {
+					this.cancelFunctions.set(task.id, 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);
+			}
+		} finally {
+			this.runningCount -= 1;
+			this.cancelFunctions.delete(task.id);
+			this.drain();
+		}
+	}
+	handleTaskTimeout(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);
+		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);
+		}
+		this.processors.delete(taskId);
+		this.onCompleteCallbacks.delete(taskId);
+		this.cancelFunctions.delete(taskId);
+		this.taskTimeouts.delete(taskId);
+	}
+	clearTaskTimeout(taskId) {
+		const timeoutId = this.taskTimeouts.get(taskId);
+		if (timeoutId) {
+			clearTimeout(timeoutId);
+			this.taskTimeouts.delete(taskId);
+		}
+	}
+};
+
+//#endregion
+//#region src/components/features/task-queue/provider/task-queue-provider.tsx
+const TaskQueueContext = createContext(null);
+function TaskQueueProvider({ children, config }) {
+	const queueRef = useRef(null);
+	if (!queueRef.current) queueRef.current = new TaskQueue(config);
+	useEffect(() => {
+		const queue = queueRef.current;
+		return () => {
+			if (!queue) return;
+			queue.getSnapshot().forEach((task) => {
+				if (task.status === "running") queue.cancel(task.id);
+			});
+		};
+	}, []);
+	useEffect(() => {
+		const handleBeforeUnload = (e) => {
+			if ((queueRef.current?.getSnapshot() ?? []).some((t) => (t.status === "running" || t.status === "pending") && t.confirmBeforeUnload !== false)) {
+				e.preventDefault();
+				e.returnValue = "Tasks in progress will be lost.";
+				return e.returnValue;
+			}
+		};
+		window.addEventListener("beforeunload", handleBeforeUnload);
+		return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+	}, []);
+	return /* @__PURE__ */ jsx(TaskQueueContext, {
+		value: useMemo(() => ({ queue: queueRef.current }), []),
+		children
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/hooks/use-task-queue.ts
+const EMPTY_TASKS = [];
+function useTaskQueue(options) {
+	const context = use(TaskQueueContext);
+	if (!context) throw new Error("useTaskQueue must be used within a TaskQueueProvider");
+	const { queue } = context;
+	const allTasks = useSyncExternalStore(queue.subscribe, queue.getSnapshot, () => EMPTY_TASKS);
+	const tasks = useMemo(() => {
+		if (!options?.status) return allTasks;
+		return allTasks.filter((t) => t.status === options.status);
+	}, [allTasks, options?.status]);
+	const activeSummary = useSyncExternalStore(queue.subscribe, queue.getActiveSummary, () => null);
+	const summaryRenderContent = queue.getSummaryRenderContent();
+	return useMemo(() => ({
+		enqueue: queue.enqueue,
+		cancel: queue.cancel,
+		retry: queue.retry,
+		dismiss: queue.dismiss,
+		dismissAll: queue.dismissAll,
+		showSummary: queue.showSummary,
+		closeSummary: queue.closeSummary,
+		activeSummary,
+		summaryRenderContent,
+		tasks
+	}), [
+		tasks,
+		activeSummary,
+		summaryRenderContent
+	]);
+}
+
+//#endregion
+//#region src/components/features/task-queue/hooks/use-task-scope.ts
+/**
+* Detect the current scope from URL params.
+* Returns project scope if projectId is present, org scope if only orgId, otherwise global.
+*
+* @param params - Route params (e.g. from useParams() in react-router)
+*/
+function useCurrentScope(params) {
+	return useMemo(() => {
+		if (params.projectId) return {
+			type: "project",
+			projectId: params.projectId,
+			orgId: params.orgId
+		};
+		if (params.orgId) return {
+			type: "org",
+			orgId: params.orgId
+		};
+		return { type: "global" };
+	}, [params.projectId, params.orgId]);
+}
+/**
+* Check if task metadata matches the current scope.
+*/
+function matchesCurrentScope(metadata, scope) {
+	if (!metadata) return false;
+	if (scope.type === "project") return metadata.projectId === scope.projectId;
+	if (scope.type === "org") return metadata.orgId === scope.orgId && !metadata.projectId;
+	return false;
+}
+/**
+* Get the context label to display for a task.
+* Returns formatted label with scope type: "Project: Name", "Org: Name", etc.
+*/
+function getContextLabel(metadata) {
+	if (!metadata) return void 0;
+	const scope = metadata.scope;
+	if (scope === "project" && metadata.projectName) return `Project: ${metadata.projectName}`;
+	if (scope === "org" && metadata.orgName) return `Org: ${metadata.orgName}`;
+	if (scope === "user") return "User";
+	if (scope === "edge" && metadata.projectName) return `AI Edge: ${metadata.projectName}`;
+	if (metadata.projectName) return `Project: ${metadata.projectName}`;
+	if (metadata.orgName) return `Org: ${metadata.orgName}`;
+	if (scope) return scope.charAt(0).toUpperCase() + scope.slice(1);
+}
+/**
+* Hook that returns tasks with a flag indicating whether to show context labels.
+* Labels are shown when:
+* - User is on a global page (account, etc.)
+* - Tasks are from mixed scopes (not all match current scope)
+*
+* @param tasks - Array of tasks to evaluate
+* @param params - Route params (e.g. from useParams() in react-router)
+*/
+function useTasksWithLabels(tasks, params) {
+	const currentScope = useCurrentScope(params);
+	return {
+		tasks,
+		showLabels: useMemo(() => {
+			if (tasks.length === 0) return false;
+			if (currentScope.type === "global") return true;
+			return !tasks.every((task) => matchesCurrentScope(task.metadata, currentScope));
+		}, [tasks, currentScope])
+	};
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-panel-header.tsx
+function TaskPanelHeader() {
+	return /* @__PURE__ */ jsx("div", {
+		className: "border-border flex items-center border-b px-4 py-3",
+		children: /* @__PURE__ */ jsx("span", {
+			className: "text-sm font-medium",
+			children: "Tasks"
+		})
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-panel-actions.tsx
+function TaskPanelActions({ task }) {
+	const { showSummary } = useTaskQueue();
+	const actions = resolveActions(task);
+	const hasBatch = task.total != null;
+	const hasFailedMessages = task.failedItems.length > 0 && task.failedItems.some((f) => f.message);
+	if (!hasBatch && task.status === "failed" && hasFailedMessages && actions.length === 0) return /* @__PURE__ */ jsx("div", {
+		className: "flex items-center justify-end gap-1.5",
+		children: /* @__PURE__ */ jsx(Button, {
+			htmlType: "button",
+			type: "quaternary",
+			theme: "outline",
+			size: "xs",
+			onClick: () => showSummary(task.title, task.failedItems.map((item, i) => ({
+				id: item.id ?? `error-${i}`,
+				label: item.id ?? "Error",
+				status: "failed",
+				message: item.message
+			}))),
+			children: "Details"
+		})
+	});
+	if (actions.length === 0) return null;
+	return /* @__PURE__ */ jsx("div", {
+		className: "flex items-center justify-end gap-1.5",
+		children: actions.map((action, i) => /* @__PURE__ */ jsx(Button, {
+			htmlType: "button",
+			...action
+		}, i))
+	});
+}
+const TERMINAL_STATUSES = [
+	"completed",
+	"failed",
+	"cancelled"
+];
+function resolveActions(task) {
+	if (!task.completionActions) return [];
+	if (!TERMINAL_STATUSES.includes(task.status)) return [];
+	if (typeof task.completionActions === "function") {
+		const originalItems = task._originalItems ?? task.items ?? [];
+		const failedMap = new Map(task.failedItems.filter((f) => f.id).map((f) => [f.id, f]));
+		const succeededSet = new Set(task.succeededItems);
+		const items = originalItems.map((item) => {
+			const id = extractItemId(item);
+			if (!id) return null;
+			const failed = failedMap.get(id);
+			if (failed) return {
+				id,
+				status: "failed",
+				message: failed.message,
+				data: item
+			};
+			if (succeededSet.has(id)) return {
+				id,
+				status: "succeeded",
+				data: item
+			};
+			return null;
+		}).filter((item) => item !== null);
+		return task.completionActions(task.result, {
+			status: task.status,
+			completed: task.completed,
+			failed: task.failed,
+			items
+		});
+	}
+	return task.completionActions;
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-panel-counter.tsx
+function TaskPanelCounter({ total, completed, failed = 0, status }) {
+	const hasBatch = total != null;
+	const parts = [];
+	if (status === "completed") parts.push({ text: "Completed" });
+	else if (status === "failed") if (hasBatch) {
+		if (completed > 0) parts.push({ text: `${completed} completed` });
+		parts.push({
+			text: `${failed} failed`,
+			destructive: true
+		});
+	} else parts.push({
+		text: "Failed",
+		destructive: true
+	});
+	else if (status === "cancelled") {
+		parts.push({ text: "Cancelled" });
+		if (hasBatch && completed > 0) parts.push({ text: `${completed} completed` });
+	} else if (hasBatch) {
+		parts.push({ text: `${completed + failed}/${total}` });
+		if (failed > 0) parts.push({
+			text: `${failed} failed`,
+			destructive: true
+		});
+	}
+	if (parts.length === 0) return null;
+	return /* @__PURE__ */ jsx("span", {
+		className: "text-muted-foreground text-xs",
+		children: parts.map((part, i) => /* @__PURE__ */ jsxs("span", { children: [i > 0 && ", ", /* @__PURE__ */ jsx("span", {
+			className: cn(part.destructive && "text-destructive"),
+			children: part.text
+		})] }, i))
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-panel-item.tsx
+function TaskPanelItem({ task, contextLabel, onCancel }) {
+	const hasBatch = task.total != null;
+	const isTerminal = task.status === "completed" || task.status === "failed" || task.status === "cancelled";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "group border-border flex flex-col gap-1 px-4 py-3 not-first:border-t",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-start gap-3",
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "mt-0.5 flex shrink-0 items-center",
+					children: /* @__PURE__ */ jsx(TaskIcon, { task })
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "flex min-w-0 flex-1 flex-col gap-0.5",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "truncate text-sm font-medium",
+							children: task.title
+						}),
+						task.status === "pending" && /* @__PURE__ */ jsx("span", {
+							className: "text-muted-foreground text-xs",
+							children: "Waiting..."
+						}),
+						hasBatch && task.status === "running" && /* @__PURE__ */ jsx(TaskPanelCounter, {
+							total: task.total,
+							completed: task.completed,
+							failed: task.failed
+						}),
+						isTerminal && /* @__PURE__ */ jsx(TaskPanelCounter, {
+							total: task.total,
+							completed: task.completed,
+							failed: task.failed,
+							status: task.status
+						}),
+						contextLabel && /* @__PURE__ */ jsxs("span", {
+							className: "text-muted-foreground flex items-center gap-1 text-xs",
+							children: [/* @__PURE__ */ jsx(Icon, {
+								icon: CornerDownRightIcon,
+								className: "size-3 shrink-0 opacity-60"
+							}), /* @__PURE__ */ jsx("span", {
+								className: "truncate",
+								children: contextLabel
+							})]
+						})
+					]
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "flex shrink-0 items-center",
+					children: /* @__PURE__ */ jsx(TaskStatusAction, {
+						task,
+						onCancel
+					})
+				})
+			]
+		}), /* @__PURE__ */ jsx(TaskPanelActions, { task })]
+	});
+}
+/** Left-side task icon - shows task icon when running, status icon when complete */
+function TaskIcon({ task }) {
+	if (task.status === "running" || task.status === "pending") {
+		if (task.icon) return /* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground [&>svg]:size-4",
+			children: task.icon
+		});
+		return /* @__PURE__ */ jsx(Icon, {
+			icon: FileIcon,
+			className: "text-muted-foreground size-4"
+		});
+	}
+	if (task.status === "completed" && task.failed > 0) return /* @__PURE__ */ jsx(Icon, {
+		icon: CircleAlert,
+		className: "size-4 text-amber-500"
+	});
+	if (task.status === "completed") return /* @__PURE__ */ jsx(Icon, {
+		icon: CircleCheck,
+		className: "size-4 text-green-600 dark:text-green-400"
+	});
+	if (task.status === "failed") return /* @__PURE__ */ jsx(Icon, {
+		icon: XCircle,
+		className: "text-destructive size-4"
+	});
+	if (task.status === "cancelled") return /* @__PURE__ */ jsx(Icon, {
+		icon: Ban,
+		className: "text-muted-foreground size-4"
+	});
+	return /* @__PURE__ */ jsx(Icon, {
+		icon: FileIcon,
+		className: "text-muted-foreground size-4"
+	});
+}
+/** Format completedAt timestamp as human-readable relative time */
+function formatCompletedAt(completedAt) {
+	if (!completedAt) return "";
+	if (Date.now() - completedAt < 1e3) return "just now";
+	return `${formatDistanceToNowStrict(new Date(completedAt), { addSuffix: false })} ago`;
+}
+/** Right-side: spinner/cancel for active tasks, timestamp for terminal tasks */
+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",
+			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"),
+				"aria-label": "Cancel task",
+				children: /* @__PURE__ */ jsx(Icon, {
+					icon: X,
+					className: "size-4"
+				})
+			})
+		}), /* @__PURE__ */ jsx(TooltipContent, {
+			side: "left",
+			children: "Cancel"
+		})] })]
+	});
+	if (task.status === "pending") return /* @__PURE__ */ jsx("div", {
+		className: "flex size-5 items-center justify-center",
+		children: /* @__PURE__ */ jsx(SpinnerIcon, {
+			size: "sm",
+			className: "opacity-50"
+		})
+	});
+	return /* @__PURE__ */ jsx("span", {
+		className: "text-muted-foreground/60 text-xs whitespace-nowrap",
+		children: formatCompletedAt(task.completedAt)
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-panel.tsx
+/**
+* @deprecated Use TaskQueueDropdown instead — renders as a header-anchored dropdown.
+* TaskPanel is kept for backward compatibility but is no longer used in the main layout.
+*/
+function TaskPanel() {
+	const { tasks, cancel } = useTaskQueue();
+	if (tasks.length === 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("bg-background fixed right-4 bottom-4 z-50 w-96 overflow-hidden", "border-border/50 rounded-xl border shadow-xl shadow-black/10", "animate-in slide-in-from-bottom-4 fade-in duration-200"),
+		children: [/* @__PURE__ */ jsx(TaskPanelHeader, {}), /* @__PURE__ */ jsx("div", {
+			className: "max-h-80 overflow-y-auto",
+			children: tasks.map((task) => /* @__PURE__ */ jsx(TaskPanelItem, {
+				task,
+				contextLabel: getContextLabel(task.metadata),
+				onCancel: () => cancel(task.id)
+			}, task.id))
+		})]
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-queue-trigger.tsx
+function TaskQueueTrigger({ ref, tasks, ...props }) {
+	const runningCount = tasks.filter((t) => t.status === "running").length;
+	const activeCount = runningCount + tasks.filter((t) => t.status === "pending").length;
+	const hasRunning = runningCount > 0;
+	const isAllComplete = tasks.length > 0 && activeCount === 0 && tasks.every((t) => t.status === "completed" || t.status === "failed" || t.status === "cancelled");
+	const [flash, setFlash] = useState(false);
+	const prevAllComplete = useRef(false);
+	useEffect(() => {
+		if (isAllComplete && !prevAllComplete.current) {
+			prevAllComplete.current = true;
+			setFlash(true);
+			const timer = setTimeout(() => setFlash(false), 5e3);
+			return () => clearTimeout(timer);
+		}
+		if (!isAllComplete) prevAllComplete.current = false;
+	}, [isAllComplete]);
+	useEffect(() => {
+		if (tasks.length === 0) {
+			setFlash(false);
+			prevAllComplete.current = false;
+		}
+	}, [tasks.length]);
+	return /* @__PURE__ */ jsx(Tooltip$1, {
+		message: "Tasks",
+		children: /* @__PURE__ */ jsxs(Button, {
+			ref,
+			type: "quaternary",
+			theme: "borderless",
+			size: "small",
+			className: cn("hover:bg-sidebar-accent relative h-7 w-7 rounded-lg p-0 transition-colors duration-300", flash && "bg-primary/10"),
+			"aria-label": `Tasks${activeCount > 0 ? ` (${activeCount} active)` : ""}`,
+			...props,
+			children: [
+				/* @__PURE__ */ jsx(Icon, {
+					icon: ListTodo,
+					className: cn("text-icon-header size-4", flash ? "text-primary" : "text-icon-header")
+				}),
+				hasRunning && /* @__PURE__ */ jsx("span", { className: "border-t-primary pointer-events-none absolute inset-[-3px] animate-spin rounded-full border-2 border-transparent" }),
+				activeCount > 0 && /* @__PURE__ */ jsx(Badge, {
+					type: "tertiary",
+					theme: "solid",
+					className: "bg-primary text-primary-foreground text-2xs absolute -top-1 -right-1 flex size-4 items-center justify-center rounded-full p-0 leading-0",
+					children: activeCount > 99 ? "99+" : activeCount
+				})
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-summary-dialog.tsx
+function getStatusConfig(status) {
+	switch (status) {
+		case "success": return {
+			icon: CircleCheck,
+			label: "Success",
+			className: "text-green-600"
+		};
+		case "failed": return {
+			icon: XCircle,
+			label: "Failed",
+			className: "text-destructive"
+		};
+	}
+}
+function StatusCell({ item }) {
+	const config = getStatusConfig(item.status);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col gap-0.5",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-1.5",
+			children: [/* @__PURE__ */ jsx(Icon, {
+				icon: config.icon,
+				className: cn("size-4", config.className)
+			}), /* @__PURE__ */ jsx("span", {
+				className: cn("text-xs font-medium", config.className),
+				children: config.label
+			})]
+		}), item.message && item.status !== "success" && /* @__PURE__ */ jsx("span", {
+			className: "text-muted-foreground pl-5.5 text-xs text-wrap",
+			children: item.message
+		})]
+	});
+}
+function DefaultTableContent({ items }) {
+	const sorted = useMemo(() => [...items].sort((a, b) => {
+		if (a.status === "failed" && b.status !== "failed") return -1;
+		if (a.status !== "failed" && b.status === "failed") return 1;
+		return 0;
+	}), [items]);
+	return /* @__PURE__ */ jsx("div", {
+		className: "max-h-[400px] overflow-auto rounded-xl border",
+		children: /* @__PURE__ */ jsxs(Table, { children: [/* @__PURE__ */ jsx(TableHeader, {
+			className: "bg-muted/50 sticky top-0",
+			children: /* @__PURE__ */ jsxs(TableRow, { children: [/* @__PURE__ */ jsx(TableHead, { children: "Item" }), /* @__PURE__ */ jsx(TableHead, {
+				className: "max-w-80",
+				children: "Status"
+			})] })
+		}), /* @__PURE__ */ jsx(TableBody, { children: sorted.length === 0 ? /* @__PURE__ */ jsx(TableRow, { children: /* @__PURE__ */ jsx(TableCell, {
+			colSpan: 2,
+			className: "text-muted-foreground py-6 text-center",
+			children: "No items"
+		}) }) : sorted.map((item) => /* @__PURE__ */ jsxs(TableRow, { children: [/* @__PURE__ */ jsx(TableCell, {
+			className: "font-medium",
+			children: item.label
+		}), /* @__PURE__ */ jsx(TableCell, {
+			className: "max-w-80 break-all text-wrap whitespace-normal",
+			children: /* @__PURE__ */ jsx(StatusCell, { item })
+		})] }, item.id)) })] })
+	});
+}
+function useTaskSummaryItems(taskId, getItemLabel) {
+	const { tasks } = useTaskQueue();
+	return useMemo(() => {
+		if (!taskId || !getItemLabel) return [];
+		const task = tasks.find((t) => t.id === taskId);
+		if (!task) return [];
+		const succeeded = task.succeededItems.map((id) => ({
+			id,
+			label: getItemLabel(id),
+			status: "success"
+		}));
+		return [...task.failedItems.map((item) => ({
+			id: item.id ?? "",
+			label: getItemLabel(item.id ?? ""),
+			status: "failed",
+			message: item.message
+		})), ...succeeded];
+	}, [
+		taskId,
+		getItemLabel,
+		tasks
+	]);
+}
+function TaskSummaryDialog(props) {
+	const { open, onOpenChange, title, description, actions, renderContent } = props;
+	const taskIdItems = useTaskSummaryItems("taskId" in props ? props.taskId : void 0, "getItemLabel" in props ? props.getItemLabel : void 0);
+	const resolvedItems = props.items ?? taskIdItems;
+	const successCount = resolvedItems.filter((i) => i.status === "success").length;
+	const failedCount = resolvedItems.filter((i) => i.status === "failed").length;
+	return /* @__PURE__ */ jsx(Dialog, {
+		open,
+		onOpenChange,
+		children: /* @__PURE__ */ jsxs(Dialog.Content, {
+			className: "w-full sm:max-w-[774px]",
+			children: [
+				/* @__PURE__ */ jsx(Dialog.Header, {
+					title,
+					description: description ?? `${successCount} succeeded, ${failedCount} failed`,
+					onClose: () => onOpenChange(false),
+					className: "border-b-0"
+				}),
+				/* @__PURE__ */ jsx(Dialog.Body, {
+					className: "px-5 py-0",
+					children: renderContent ? renderContent(resolvedItems) : /* @__PURE__ */ jsx(DefaultTableContent, { items: resolvedItems })
+				}),
+				/* @__PURE__ */ jsxs(Dialog.Footer, {
+					className: "border-t-0",
+					children: [actions, /* @__PURE__ */ jsx(Button, {
+						type: "primary",
+						theme: "solid",
+						onClick: () => onOpenChange(false),
+						children: "Done"
+					})]
+				})
+			]
+		})
+	});
+}
+
+//#endregion
+//#region src/components/features/task-queue/core/task-queue-dropdown.tsx
+const autoOpenedForIds = /* @__PURE__ */ new Set();
+function TaskQueueDropdown() {
+	const { tasks, cancel, dismissAll, activeSummary, closeSummary, summaryRenderContent } = useTaskQueue();
+	const [open, setOpen] = useState(() => tasks.some((t) => !autoOpenedForIds.has(t.id)));
+	useEffect(() => {
+		if (tasks.some((t) => !autoOpenedForIds.has(t.id))) setOpen(true);
+		for (const t of tasks) autoOpenedForIds.add(t.id);
+		if (autoOpenedForIds.size > tasks.length) {
+			const currentIds = new Set(tasks.map((t) => t.id));
+			for (const id of autoOpenedForIds) if (!currentIds.has(id)) autoOpenedForIds.delete(id);
+		}
+	}, [tasks]);
+	const hasDismissable = tasks.some((t) => t.status !== "running" && t.status !== "pending");
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs(DropdownMenu, {
+		open,
+		onOpenChange: setOpen,
+		children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsx(TaskQueueTrigger, { tasks })
+		}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+			align: "end",
+			className: "w-96 rounded-lg p-0",
+			onCloseAutoFocus: (e) => e.preventDefault(),
+			children: [
+				/* @__PURE__ */ jsx(TaskPanelHeader, {}),
+				/* @__PURE__ */ jsx("div", {
+					className: "max-h-[350px] overflow-y-auto",
+					children: tasks.length === 0 && !activeSummary ? /* @__PURE__ */ jsxs("div", {
+						className: "flex flex-col items-center justify-center px-4 py-12 text-center",
+						children: [/* @__PURE__ */ jsx(CheckCircle2, { className: "text-muted-foreground/30 mb-3 h-12 w-12" }), /* @__PURE__ */ jsx("p", {
+							className: "text-muted-foreground text-sm",
+							children: "No tasks currently scheduled"
+						})]
+					}) : tasks.map((task) => /* @__PURE__ */ jsx(TaskPanelItem, {
+						task,
+						contextLabel: getContextLabel(task.metadata),
+						onCancel: () => cancel(task.id)
+					}, task.id))
+				}),
+				hasDismissable && /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: () => {
+						dismissAll();
+					},
+					className: "border-border hover:bg-accent flex w-full cursor-pointer items-center justify-center gap-2 border-t px-3 py-2 transition-colors",
+					children: /* @__PURE__ */ jsx("span", {
+						className: "text-destructive text-xs",
+						children: "Clear tasks"
+					})
+				})
+			]
+		})]
+	}), activeSummary && /* @__PURE__ */ jsx(TaskSummaryDialog, {
+		open: true,
+		onOpenChange: (isOpen) => {
+			if (!isOpen) closeSummary();
+		},
+		title: activeSummary.title,
+		items: activeSummary.items,
+		renderContent: activeSummary.renderContent ?? summaryRenderContent
+	})] });
+}
+
+//#endregion
+export { RedisTaskStorage as _, TaskPanelItem as a, createProjectMetadata as b, TaskPanelHeader as c, useCurrentScope as d, useTasksWithLabels as f, detectStorage as g, TaskQueue as h, TaskPanel as i, getContextLabel as l, TaskQueueProvider as m, TaskSummaryDialog as n, TaskPanelCounter as o, useTaskQueue as p, TaskQueueTrigger as r, TaskPanelActions as s, TaskQueueDropdown as t, matchesCurrentScope as u, LocalTaskStorage as v, createUserMetadata as x, createOrgMetadata as y };