@pablopunk/webr 0.1.1

package/dist/server/chunks/App_BmsGAwGf.mjs

@@ -0,0 +1,4314 @@
+import { S as createAstro, f as renderHead, i as renderComponent, m as createRenderInstruction, p as addAttribute, s as renderSlot, u as renderTemplate } from "./server_DS45LC4q.mjs";
+import { t as createComponent } from "./compiler_CpXox_xS.mjs";
+import { createContext, memo, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import { Archive, ArchiveRestore, ArrowDown, ArrowLeft, ArrowRight, ArrowUp, Check, ChevronDown, ChevronRight, Circle, CircleAlert, CircleCheck, CircleHelp, Copy, Cpu, Folder, FolderTree, GitBranch, ImagePlus, LayoutList, LoaderCircle, MessageCircleQuestion, Monitor, Moon, PanelBottom, PanelLeft, PanelLeftClose, PanelLeftOpen, PanelRight, Plus, Search, Settings2, SquarePen, SquareTerminal, Sun, TerminalSquare, Trash2, TriangleAlert, X } from "lucide-react";
+import { createRoot } from "react-dom/client";
+import { AlertDialog } from "@base-ui/react/alert-dialog";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Tooltip } from "@base-ui/react/tooltip";
+import { BotAvatar, botAvatarTypes } from "bot-avatars";
+import { Combobox } from "@base-ui/react/combobox";
+import { QueryClient, QueryClientProvider, useQuery } from "@tanstack/react-query";
+import { Dialog } from "@base-ui/react/dialog";
+import { encode } from "uqr";
+import { ContextMenu } from "@base-ui/react/context-menu";
+import { Menu } from "@base-ui/react/menu";
+import { useStore } from "zustand";
+import { createStore } from "zustand/vanilla";
+import { useShallow } from "zustand/react/shallow";
+//#region node_modules/.pnpm/astro@7.3.5_@types+node@22.20.4_tsx@4.23.15_yaml@2.9.1/node_modules/astro/dist/runtime/server/render/script.js
+async function renderScript(result, id) {
+	const inlined = result.inlinedScripts.get(id);
+	let content = "";
+	if (inlined != null) {
+		if (inlined) content = `<script type="module">${inlined}<\/script>`;
+	} else {
+		const resolved = await result.resolve(id);
+		content = `<script type="module" src="${result.userAssetsBase ? (result.base === "/" ? "" : result.base) + result.userAssetsBase : ""}${resolved}"><\/script>`;
+	}
+	return createRenderInstruction({
+		type: "script",
+		id,
+		content
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/astro@7.3.5_@types+node@22.20.4_tsx@4.23.15_yaml@2.9.1/node_modules/astro/components/ClientRouter.astro
+createAstro("https://astro.build");
+var $$ClientRouter = createComponent(($$result, $$props, $$slots) => {
+	const Astro = $$result.createAstro($$props, $$slots);
+	Astro.self = $$ClientRouter;
+	const { fallback = "animate" } = Astro.props;
+	return renderTemplate`<meta name="astro-view-transitions-enabled" content="true"><meta name="astro-view-transitions-fallback"${addAttribute(fallback, "content")}>${renderScript($$result, "/Users/pablopunk/src/herdr-web/node_modules/.pnpm/astro@7.3.5_@types+node@22.20.4_tsx@4.23.15_yaml@2.9.1/node_modules/astro/components/ClientRouter.astro?astro&type=script&index=0&lang.ts")}`;
+}, "/Users/pablopunk/src/herdr-web/node_modules/.pnpm/astro@7.3.5_@types+node@22.20.4_tsx@4.23.15_yaml@2.9.1/node_modules/astro/components/ClientRouter.astro", void 0);
+//#endregion
+//#region src/assets/fonts/jetbrains-mono.woff2?url
+var jetbrains_mono_default = "/_astro/jetbrains-mono.CFJaiWaY.woff2";
+//#endregion
+//#region src/layouts/Base.astro
+createAstro("https://astro.build");
+var $$Base = createComponent(($$result, $$props, $$slots) => {
+	const Astro = $$result.createAstro($$props, $$slots);
+	Astro.self = $$Base;
+	const { title = "Webr" } = Astro.props;
+	return renderTemplate`<html lang="en" data-theme="light"><head>${renderComponent($$result, "ClientRouter", $$ClientRouter, {})}<meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover"><meta name="color-scheme" content="light dark"><meta name="theme-color" media="(prefers-color-scheme: light)" content="#f8f8f7"><meta name="theme-color" media="(prefers-color-scheme: dark)" content="#121313"><meta name="apple-mobile-web-app-capable" content="yes"><meta name="mobile-web-app-capable" content="yes"><meta name="apple-mobile-web-app-title" content="Webr"><meta name="apple-mobile-web-app-status-bar-style" content="default"><link rel="icon" href="/favicon.ico" sizes="48x48"><link rel="icon" type="image/png" sizes="32x32" href="/favicon-32.png"><link rel="apple-touch-icon" href="/apple-touch-icon.png"><link rel="manifest" href="/manifest.webmanifest"><title>${title} · Webr</title><link rel="preload" as="font" type="font/woff2"${addAttribute(jetbrains_mono_default, "href")} crossorigin><link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin><link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&display=swap" rel="stylesheet"><script>
+      function restoreWebrTheme() {
+        let preference = 'system';
+        try { preference = localStorage.getItem('webr-theme') || 'system'; } catch {}
+        document.documentElement.dataset.theme = preference === 'system'
+          ? (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
+          : preference;
+      }
+      restoreWebrTheme();
+      document.addEventListener('astro:before-swap', (event) => { event.newDocument.documentElement.dataset.theme = document.documentElement.dataset.theme; });
+      document.addEventListener('astro:after-swap', restoreWebrTheme);
+    <\/script>${renderHead($$result)}</head><body>${renderSlot($$result, $$slots["default"])}</body></html>`;
+}, "/Users/pablopunk/src/herdr-web/src/layouts/Base.astro", void 0);
+//#endregion
+//#region src/components/dialogs.tsx
+var root;
+var showing;
+var show = (request) => {
+	root ??= createRoot(document.body.appendChild(document.createElement("div")));
+	showing?.resolve(false);
+	showing = request;
+	const settle = (accepted) => {
+		if (showing !== request) return;
+		showing = void 0;
+		root?.render(null);
+		request.resolve(accepted);
+	};
+	root.render(/* @__PURE__ */ jsx(DialogView, {
+		request,
+		settle
+	}));
+};
+function DialogView({ request, settle }) {
+	return /* @__PURE__ */ jsx(AlertDialog.Root, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) settle(false);
+		},
+		children: /* @__PURE__ */ jsxs(AlertDialog.Portal, { children: [/* @__PURE__ */ jsx(AlertDialog.Backdrop, { className: "dialog-backdrop" }), /* @__PURE__ */ jsxs(AlertDialog.Popup, {
+			className: "dialog",
+			children: [/* @__PURE__ */ jsx(AlertDialog.Description, {
+				className: "dialog-message",
+				children: request.message
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "dialog-actions",
+				children: [request.cancelLabel && /* @__PURE__ */ jsx(AlertDialog.Close, {
+					className: "dialog-button",
+					children: request.cancelLabel
+				}), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					autoFocus: true,
+					className: `dialog-button is-primary ${request.danger ? "is-danger" : ""}`,
+					onClick: () => settle(true),
+					children: request.confirmLabel
+				})]
+			})]
+		})] })
+	});
+}
+var confirmDialog = (message, { confirmLabel = "Confirm", danger = false } = {}) => new Promise((resolve) => show({
+	message,
+	confirmLabel,
+	cancelLabel: "Cancel",
+	danger,
+	resolve
+}));
+var alertDialog = (message) => new Promise((resolve) => show({
+	message,
+	confirmLabel: "OK",
+	resolve: () => resolve()
+}));
+//#endregion
+//#region src/components/Tooltip.tsx
+function Tooltip$1({ label, side = "top", children }) {
+	return /* @__PURE__ */ jsxs(Tooltip.Root, { children: [/* @__PURE__ */ jsx(Tooltip.Trigger, { render: children }), /* @__PURE__ */ jsx(Tooltip.Portal, { children: /* @__PURE__ */ jsx(Tooltip.Positioner, {
+		className: "tooltip-positioner",
+		side,
+		sideOffset: 8,
+		collisionPadding: 8,
+		children: /* @__PURE__ */ jsx(Tooltip.Popup, {
+			className: "tooltip-popup",
+			children: label
+		})
+	}) })] });
+}
+//#endregion
+//#region src/lib/avatars.ts
+var GOLDEN_ANGLE_DEGREES = 137.508;
+var hueFarFromThePreviousThread = (index) => (index * GOLDEN_ANGLE_DEGREES % 360).toFixed(3);
+function avatarForThread(thread) {
+	const index = thread.avatarIndex;
+	return {
+		type: botAvatarTypes[index % botAvatarTypes.length],
+		color: `hsl(${hueFarFromThePreviousThread(index)} 72% 58%)`,
+		seed: index * .61803398875 % 1
+	};
+}
+//#endregion
+//#region src/components/ThreadAvatar.tsx
+var TIME_FOR_A_JUMP_TO_LAND_MS = 2e3;
+var FACE_FORWARD = 0;
+function usePauseAfterLanding(working) {
+	const [paused, setPaused] = useState(!working);
+	useEffect(() => {
+		if (working) {
+			setPaused(false);
+			return;
+		}
+		const timer = setTimeout(() => setPaused(true), TIME_FOR_A_JUMP_TO_LAND_MS);
+		return () => clearTimeout(timer);
+	}, [working]);
+	return paused;
+}
+function ThreadAvatar({ thread, working, size }) {
+	const paused = usePauseAfterLanding(working);
+	const remountIntoTheRestPose = paused ? "rest" : "moving";
+	return /* @__PURE__ */ jsx(BotAvatar, {
+		...avatarForThread(thread),
+		state: working ? "working" : "default",
+		size,
+		paused,
+		turn: working ? void 0 : FACE_FORWARD
+	}, remountIntoTheRestPose);
+}
+//#endregion
+//#region src/components/shortcuts.ts
+var shortcutLabels = {
+	nextThread: "Next thread",
+	previousThread: "Previous thread",
+	nextPane: "Next pane",
+	previousPane: "Previous pane",
+	toggleSidebar: "Toggle sidebar",
+	newThread: "New thread",
+	toggleTerminal: "Toggle terminal"
+};
+var defaultShortcuts = {
+	nextThread: "ctrl+j",
+	previousThread: "ctrl+k",
+	nextPane: "ctrl+l",
+	previousPane: "ctrl+h",
+	toggleSidebar: "ctrl+b",
+	newThread: "ctrl+x",
+	toggleTerminal: "ctrl+q"
+};
+function getShortcuts() {
+	try {
+		const saved = JSON.parse(localStorage.getItem("webr-shortcuts") ?? "{}");
+		return {
+			...defaultShortcuts,
+			...saved
+		};
+	} catch {
+		return defaultShortcuts;
+	}
+}
+function shortcutKeys(combo) {
+	const keys = {
+		ctrl: "⌃",
+		alt: "⌥",
+		meta: "⌘",
+		shift: "⇧",
+		space: "Space",
+		escape: "Esc"
+	};
+	return combo.split("+").map((key) => keys[key] ?? key.toUpperCase());
+}
+function formatShortcut(combo) {
+	return shortcutKeys(combo).join("");
+}
+function keyCombo(event) {
+	const modifiers = [
+		event.ctrlKey && "ctrl",
+		event.altKey && "alt",
+		event.metaKey && "meta",
+		event.shiftKey && "shift"
+	].filter(Boolean);
+	const key = event.key.toLowerCase() === " " ? "space" : event.key.toLowerCase();
+	if ([
+		"control",
+		"alt",
+		"meta",
+		"shift"
+	].includes(key)) return "";
+	return [...modifiers, key].join("+");
+}
+function isReservedShortcut(combo) {
+	return /^(meta\+(w|t|r|l|n)|ctrl\+(w|t|r|n))$/.test(combo) || !/(ctrl|alt|meta)\+/.test(combo);
+}
+//#endregion
+//#region src/components/ThemeControl.tsx
+function applyTheme(preference) {
+	const dark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+	document.documentElement.dataset.theme = preference === "system" ? dark ? "dark" : "light" : preference;
+}
+function ThemeControl({ expanded = false }) {
+	const [preference, setPreference] = useState("system");
+	useEffect(() => {
+		const saved = localStorage.getItem("webr-theme");
+		const initial = saved === "light" || saved === "dark" ? saved : "system";
+		setPreference(initial);
+		applyTheme(initial);
+		const media = window.matchMedia("(prefers-color-scheme: dark)");
+		const onChange = () => {
+			const current = localStorage.getItem("webr-theme") || "system";
+			setPreference(current);
+			applyTheme(current);
+		};
+		media.addEventListener("change", onChange);
+		window.addEventListener("webr-theme-change", onChange);
+		return () => {
+			media.removeEventListener("change", onChange);
+			window.removeEventListener("webr-theme-change", onChange);
+		};
+	}, []);
+	const select = (value) => {
+		setPreference(value);
+		localStorage.setItem("webr-theme", value);
+		applyTheme(value);
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: expanded ? "theme-control theme-control--expanded" : "theme-control",
+		role: "group",
+		"aria-label": "Color theme",
+		children: [
+			["system", Monitor],
+			["light", Sun],
+			["dark", Moon]
+		].map(([value, Icon]) => /* @__PURE__ */ jsx(Tooltip$1, {
+			label: `${value[0].toUpperCase()}${value.slice(1)} theme`,
+			children: /* @__PURE__ */ jsxs("button", {
+				type: "button",
+				"aria-label": `${value} theme`,
+				"aria-pressed": preference === value,
+				className: preference === value ? "theme-option is-selected" : "theme-option",
+				onClick: () => select(value),
+				children: [/* @__PURE__ */ jsx(Icon, {
+					size: 15,
+					strokeWidth: 1.8
+				}), expanded && /* @__PURE__ */ jsx("span", { children: value })]
+			})
+		}, value))
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/astro@7.3.5_@types+node@22.20.4_tsx@4.23.15_yaml@2.9.1/node_modules/astro/dist/transitions/router.js
+var navigateOnServerWarned = false;
+async function navigate(href, options) {
+	if (!navigateOnServerWarned) {
+		const warning = /* @__PURE__ */ new Error("The view transitions client API was called during a server side render. This may be unintentional as the navigate() function is expected to be called in response to user interactions. Please make sure that your usage is correct.");
+		warning.name = "Warning";
+		console.warn(warning);
+		navigateOnServerWarned = true;
+	}
+}
+//#endregion
+//#region src/client/thread-actions.ts
+var actionErrors = {
+	machine_disconnected: "The machine is not connected.",
+	launch_in_progress: "Wait for the launch to finish, then try again.",
+	thread_not_found: "This thread does not exist anymore."
+};
+async function post$1(path, body = {}) {
+	const response = await fetch(path, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body)
+	});
+	const result = await response.json().catch(() => ({}));
+	if (!response.ok) throw new Error(actionErrors[result.error ?? ""] ?? "Herdr could not complete this action.");
+	return result;
+}
+var setThreadArchived = (thread, archived) => post$1(`/api/threads/${encodeURIComponent(thread.id)}/archive`, {
+	machineId: thread.machineId,
+	archived
+});
+var renameThread = (thread, title) => post$1(`/api/threads/${encodeURIComponent(thread.id)}/rename`, {
+	machineId: thread.machineId,
+	title
+});
+var toggleThreadTerminal = (thread, direction) => post$1(`/api/threads/${encodeURIComponent(thread.id)}/terminal`, {
+	machineId: thread.machineId,
+	direction
+});
+var closeThreadTerminal = (thread) => post$1(`/api/threads/${encodeURIComponent(thread.id)}/terminal/close`, { machineId: thread.machineId });
+var deleteThreadPermanently = (thread) => post$1(`/api/threads/${encodeURIComponent(thread.id)}/delete`, { machineId: thread.machineId });
+var deleteArchivedThreads = () => post$1("/api/archive/delete");
+var plural = (count, one, many) => count === 1 ? one : many;
+function deleteWarning(threads) {
+	const count = threads.length;
+	const worktrees = threads.filter((thread) => thread.ownsWorktree).length;
+	const subject = plural(count, "Delete this thread", `Delete ${count} threads`);
+	const closes = plural(count, "its terminal", "their terminals");
+	if (!worktrees) return `${subject} permanently? This closes ${closes}. Your project files stay untouched.`;
+	return `${subject} permanently? This closes ${closes} and removes ${worktrees === count ? plural(count, "its worktree", "their worktrees") : `${worktrees} ${plural(worktrees, "worktree", "worktrees")}`}, including uncommitted changes.`;
+}
+//#endregion
+//#region src/lib/terminal-split.ts
+var threadAgent = (thread) => thread.panes.find((pane) => pane.kind === "agent") ?? thread.panes[0];
+var threadShell = (thread) => {
+	const main = threadAgent(thread);
+	return thread.panes.find((pane) => pane.kind === "shell" && pane.id !== main?.id);
+};
+var peekSide = (shell, area) => shell.x > area.x && shell.y === area.y ? "right" : "bottom";
+var terminalDirection = (side) => side === "right" ? "right" : "down";
+function hiddenTerminalLayout(thread, layout) {
+	const shell = threadShell(thread);
+	const agent = threadAgent(thread);
+	const shellRect = shell && layout.panes.find((rect) => rect.paneId === shell.id)?.rect;
+	const otherPanes = thread.panes.filter((pane) => pane.id !== shell?.id && pane.id !== agent?.id);
+	if (!thread.terminalHidden || !shell || !agent || !shellRect || otherPanes.length) return void 0;
+	return {
+		shell,
+		agent,
+		side: peekSide(shellRect, layout.area)
+	};
+}
+function currentTerminalDirection(thread, layouts, narrow) {
+	const shell = threadShell(thread);
+	const layout = layouts.find((layout) => layout.panes.some((rect) => rect.paneId === shell?.id));
+	const rect = layout?.panes.find((rect) => rect.paneId === shell?.id)?.rect;
+	return rect && layout ? terminalDirection(peekSide(rect, layout.area)) : narrow ? "down" : "right";
+}
+function span(name) {
+	const start = performance.now();
+	return () => {
+		return performance.now() - start;
+	};
+}
+var perfNow = () => performance.now();
+function startPerf() {}
+//#endregion
+//#region src/components/CommandPalette.tsx
+var reportFailure$1 = (error) => alertDialog(error instanceof Error ? error.message : "Herdr could not complete this action.");
+function CommandPalette({ open, onClose, projects, threads, thread, focusedPane, mode, onModeChange, onToggleSidebar, onFocusPane, onTerminalAction, onToggleTerminal, onCloseTerminal }) {
+	const [query, setQuery] = useState("");
+	const [selected, setSelected] = useState(0);
+	const [shortcuts, setShortcuts] = useState(defaultShortcuts);
+	const input = useRef(null);
+	useEffect(() => {
+		if (!open) return;
+		setQuery("");
+		setSelected(0);
+		setShortcuts(getShortcuts());
+		requestAnimationFrame(() => input.current?.focus());
+	}, [open]);
+	const navigateThread = (offset) => {
+		const index = threads.findIndex((item) => item.id === thread?.id);
+		const target = threads[((index === -1 && offset < 0 ? 0 : index) + offset + threads.length) % threads.length];
+		if (target) navigate(`/threads/${encodeURIComponent(target.id)}`);
+	};
+	const focusPane = (offset) => {
+		if (thread?.panes.length) onFocusPane(thread.panes[(thread.panes.findIndex((pane) => pane.id === focusedPane) + offset + thread.panes.length) % thread.panes.length].id);
+	};
+	const matching = useMemo(() => [
+		{
+			label: "New thread",
+			icon: /* @__PURE__ */ jsx(SquarePen, { size: 16 }),
+			shortcut: "newThread",
+			run: () => {
+				navigate(`/new${thread ? `?project=${encodeURIComponent(thread.projectId)}` : ""}`);
+			}
+		},
+		{
+			label: "Settings",
+			icon: /* @__PURE__ */ jsx(Settings2, { size: 16 }),
+			run: () => {
+				navigate("/settings");
+			}
+		},
+		...[],
+		{
+			label: "Toggle sidebar",
+			icon: /* @__PURE__ */ jsx(PanelLeft, { size: 16 }),
+			shortcut: "toggleSidebar",
+			run: onToggleSidebar
+		},
+		...threads.length ? [{
+			label: "Next thread",
+			icon: /* @__PURE__ */ jsx(ArrowDown, { size: 16 }),
+			shortcut: "nextThread",
+			run: () => navigateThread(1)
+		}, {
+			label: "Previous thread",
+			icon: /* @__PURE__ */ jsx(ArrowUp, { size: 16 }),
+			shortcut: "previousThread",
+			run: () => navigateThread(-1)
+		}] : [],
+		{
+			label: "Group threads by project",
+			icon: /* @__PURE__ */ jsx(FolderTree, { size: 16 }),
+			detail: mode === "projects" ? "Selected" : void 0,
+			run: () => onModeChange("projects")
+		},
+		{
+			label: "Show all threads",
+			icon: /* @__PURE__ */ jsx(LayoutList, { size: 16 }),
+			detail: mode === "threads" ? "Selected" : void 0,
+			run: () => onModeChange("threads")
+		},
+		...[
+			"system",
+			"light",
+			"dark"
+		].map((theme) => ({
+			label: `${theme[0].toUpperCase()}${theme.slice(1)} theme`,
+			icon: theme === "system" ? /* @__PURE__ */ jsx(Monitor, { size: 16 }) : theme === "light" ? /* @__PURE__ */ jsx(Sun, { size: 16 }) : /* @__PURE__ */ jsx(Moon, { size: 16 }),
+			run: () => {
+				localStorage.setItem("webr-theme", theme);
+				applyTheme(theme);
+				window.dispatchEvent(new Event("webr-theme-change"));
+			}
+		})),
+		...thread ? [
+			{
+				label: thread.archivedAt ? "Unarchive thread" : "Archive thread",
+				icon: thread.archivedAt ? /* @__PURE__ */ jsx(ArchiveRestore, { size: 16 }) : /* @__PURE__ */ jsx(Archive, { size: 16 }),
+				run: () => {
+					setThreadArchived(thread, !thread.archivedAt).catch(reportFailure$1);
+				}
+			},
+			{
+				label: "Copy thread link",
+				icon: /* @__PURE__ */ jsx(Copy, { size: 16 }),
+				run: () => {
+					navigator.clipboard.writeText(location.href);
+				}
+			},
+			...thread.bindingState === "attached" ? threadShell(thread) ? [{
+				label: "Toggle terminal",
+				icon: /* @__PURE__ */ jsx(SquareTerminal, { size: 16 }),
+				shortcut: "toggleTerminal",
+				run: () => onToggleTerminal()
+			}, {
+				label: "Close terminal",
+				icon: /* @__PURE__ */ jsx(X, { size: 16 }),
+				detail: "Stops its shell",
+				run: onCloseTerminal
+			}] : [{
+				label: "Toggle terminal (side)",
+				icon: /* @__PURE__ */ jsx(PanelRight, { size: 16 }),
+				shortcut: "toggleTerminal",
+				run: () => onToggleTerminal("right")
+			}, {
+				label: "Toggle terminal (below)",
+				icon: /* @__PURE__ */ jsx(PanelBottom, { size: 16 }),
+				run: () => onToggleTerminal("down")
+			}] : [],
+			...thread.bindingState === "attached" ? [
+				{
+					label: "Request terminal control",
+					icon: /* @__PURE__ */ jsx(TerminalSquare, { size: 16 }),
+					run: () => onTerminalAction("control")
+				},
+				{
+					label: "Release terminal control",
+					icon: /* @__PURE__ */ jsx(TerminalSquare, { size: 16 }),
+					run: () => onTerminalAction("release")
+				},
+				{
+					label: "Take over terminal control",
+					icon: /* @__PURE__ */ jsx(TerminalSquare, { size: 16 }),
+					run: () => {
+						confirmDialog("Replace the active controller of this terminal?", { confirmLabel: "Take over" }).then((accepted) => {
+							if (accepted) onTerminalAction("takeover");
+						});
+					}
+				}
+			] : [],
+			{
+				label: "Next pane",
+				icon: /* @__PURE__ */ jsx(ArrowRight, { size: 16 }),
+				shortcut: "nextPane",
+				run: () => focusPane(1)
+			},
+			{
+				label: "Previous pane",
+				icon: /* @__PURE__ */ jsx(ArrowLeft, { size: 16 }),
+				shortcut: "previousPane",
+				run: () => focusPane(-1)
+			},
+			...thread.panes.map((pane, index) => ({
+				label: `Focus ${pane.title}`,
+				icon: /* @__PURE__ */ jsx(TerminalSquare, { size: 16 }),
+				detail: `Pane ${index + 1}`,
+				run: () => onFocusPane(pane.id)
+			}))
+		] : [],
+		...threads.map((item) => ({
+			label: item.title,
+			icon: /* @__PURE__ */ jsx(ThreadAvatar, {
+				thread: item,
+				working: item.status === "working",
+				size: 22
+			}),
+			detail: projects.find((project) => project.id === item.projectId)?.name,
+			run: () => {
+				navigate(`/threads/${encodeURIComponent(item.id)}`);
+			}
+		}))
+	], [
+		projects,
+		threads,
+		thread,
+		focusedPane,
+		mode,
+		onModeChange,
+		onToggleSidebar,
+		onFocusPane,
+		onTerminalAction,
+		onToggleTerminal,
+		onCloseTerminal
+	]).filter((command) => `${command.label} ${command.detail ?? ""}`.toLowerCase().includes(query.toLowerCase().trim()));
+	if (!open) return null;
+	const run = (command) => {
+		onClose();
+		command.run();
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: "palette-overlay",
+		onMouseDown: (event) => {
+			if (event.target === event.currentTarget) onClose();
+		},
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "palette",
+			role: "dialog",
+			"aria-modal": "true",
+			"aria-label": "Command palette",
+			onKeyDown: (event) => {
+				if (event.key === "Escape") {
+					event.preventDefault();
+					onClose();
+				}
+				if (event.key === "ArrowDown") {
+					event.preventDefault();
+					setSelected((value) => (value + 1) % (matching.length || 1));
+				}
+				if (event.key === "ArrowUp") {
+					event.preventDefault();
+					setSelected((value) => (value - 1 + (matching.length || 1)) % (matching.length || 1));
+				}
+				if (event.key === "Enter" && matching.length) {
+					event.preventDefault();
+					run(matching[Math.min(selected, matching.length - 1)]);
+				}
+				if (event.key === "Tab") {
+					event.preventDefault();
+					input.current?.focus();
+				}
+			},
+			children: [
+				/* @__PURE__ */ jsx("input", {
+					ref: input,
+					"aria-label": "Search commands and threads",
+					placeholder: "Search threads and actions…",
+					value: query,
+					onChange: (event) => {
+						setQuery(event.target.value);
+						setSelected(0);
+					}
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "palette-results",
+					role: "listbox",
+					"aria-label": "Results",
+					children: [matching.map((command, index) => /* @__PURE__ */ jsxs("button", {
+						role: "option",
+						"aria-selected": selected === index,
+						className: selected === index ? "is-selected" : "",
+						onMouseEnter: () => setSelected(index),
+						onClick: () => run(command),
+						children: [
+							/* @__PURE__ */ jsx("span", {
+								className: "palette-icon",
+								"aria-hidden": "true",
+								children: command.icon
+							}),
+							/* @__PURE__ */ jsx("span", {
+								className: "palette-label",
+								children: command.label
+							}),
+							command.detail && /* @__PURE__ */ jsx("small", { children: command.detail }),
+							command.shortcut && /* @__PURE__ */ jsx(Tooltip$1, {
+								label: shortcuts[command.shortcut],
+								children: /* @__PURE__ */ jsx("kbd", { children: formatShortcut(shortcuts[command.shortcut]) })
+							})
+						]
+					}, `${command.label}-${index}`)), !matching.length && /* @__PURE__ */ jsx("p", { children: "No results" })]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "palette-help",
+					children: [
+						"↑↓ Navigate ",
+						/* @__PURE__ */ jsx("span", { children: "↵ Select" }),
+						" ",
+						/* @__PURE__ */ jsx("span", { children: "Esc Close" })
+					]
+				})
+			]
+		})
+	});
+}
+//#endregion
+//#region src/client/pairing.ts
+var POLL_INTERVAL_MS = 2e3;
+var post = (path) => fetch(path, {
+	method: "POST",
+	headers: { "Content-Type": "application/json" },
+	body: "{}"
+});
+async function createInvite() {
+	const response = await post("/api/pair/invites");
+	if (!response.ok) throw new Error("Webr could not create a code.");
+	return response.json();
+}
+async function listDevices() {
+	const response = await fetch("/api/devices");
+	if (!response.ok) throw new Error("Webr could not list devices.");
+	return response.json();
+}
+async function listAuditEvents() {
+	const response = await fetch("/api/audit");
+	if (!response.ok) throw new Error("Webr could not load recent activity.");
+	return response.json();
+}
+var revokeDevice = (id) => post(`/api/devices/${encodeURIComponent(id)}/revoke`);
+var decidePairRequest = (id, decision) => post(`/api/pair/${encodeURIComponent(id)}/${decision}`);
+async function fetchPending() {
+	try {
+		const response = await fetch("/api/pair/pending");
+		return response.ok ? await response.json() : [];
+	} catch {
+		return [];
+	}
+}
+var notificationsGranted = () => typeof Notification !== "undefined" && Notification.permission === "granted";
+var canWatchInBackground = () => document.visibilityState === "visible" || notificationsGranted();
+function notifyHiddenTab(requests, alreadyNotified) {
+	if (document.visibilityState === "visible" || !notificationsGranted()) return;
+	for (const request of requests) {
+		if (alreadyNotified.has(request.id)) continue;
+		alreadyNotified.add(request.id);
+		new Notification("A device wants to connect to Webr", {
+			body: `${request.deviceName} · ${request.source}`,
+			tag: request.id
+		});
+	}
+}
+function usePendingPairRequests() {
+	const [pending, setPending] = useState([]);
+	const notified = useRef(/* @__PURE__ */ new Set());
+	const refresh = useCallback(async () => {
+		if (!canWatchInBackground()) return;
+		const requests = await fetchPending();
+		notifyHiddenTab(requests, notified.current);
+		setPending(requests);
+	}, []);
+	useEffect(() => {
+		refresh();
+		const timer = setInterval(() => void refresh(), POLL_INTERVAL_MS);
+		document.addEventListener("visibilitychange", refresh);
+		return () => {
+			clearInterval(timer);
+			document.removeEventListener("visibilitychange", refresh);
+		};
+	}, [refresh]);
+	return {
+		pending,
+		decide: useCallback(async (id, decision) => {
+			setPending((current) => current.filter((request) => request.id !== id));
+			await decidePairRequest(id, decision).catch(() => void 0);
+			await refresh();
+		}, [refresh])
+	};
+}
+function relativeTime$1(timestamp, now = Date.now()) {
+	const seconds = Math.round((timestamp - now) / 1e3);
+	const [unit, size] = [
+		["day", 86400],
+		["hour", 3600],
+		["minute", 60]
+	].find(([, size]) => Math.abs(seconds) >= size) ?? ["second", 1];
+	return Math.abs(seconds) < 45 ? "just now" : new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(Math.round(seconds / size), unit);
+}
+var notificationsSupported = () => typeof Notification !== "undefined";
+var notificationPermission = () => notificationsSupported() ? Notification.permission : "denied";
+var requestNotificationPermission = () => Notification.requestPermission();
+function describeAuditEvent({ kind, deviceName, source }) {
+	const device = deviceName ?? "A device";
+	const where = source ? ` from ${source}` : "";
+	return {
+		pair_requested: `${device} asked to connect${where}`,
+		pair_approved: `${device} was approved${where}`,
+		pair_denied: `${device} was declined${where}`,
+		invite_created: `A connection code was created${where}`,
+		invite_redeemed: `${device} connected with a code${where}`,
+		device_revoked: `${device} was disconnected`,
+		session_expired: `${device} was signed out after being idle`
+	}[kind];
+}
+function relativeFuture(timestamp, now = Date.now()) {
+	return timestamp <= now ? "expired" : new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(...futureUnit(timestamp - now));
+}
+function futureUnit(milliseconds) {
+	const days = Math.round(milliseconds / 864e5);
+	return days >= 1 ? [days, "day"] : [Math.max(1, Math.round(milliseconds / 36e5)), "hour"];
+}
+//#endregion
+//#region src/components/PairingPrompt.tsx
+function PairingPrompt() {
+	const { pending, decide } = usePendingPairRequests();
+	const request = pending[0];
+	return /* @__PURE__ */ jsx(AlertDialog.Root, {
+		open: !!request,
+		onOpenChange: (open) => {
+			if (!open && request) decide(request.id, "deny");
+		},
+		children: /* @__PURE__ */ jsxs(AlertDialog.Portal, { children: [/* @__PURE__ */ jsx(AlertDialog.Backdrop, { className: "dialog-backdrop" }), /* @__PURE__ */ jsx(AlertDialog.Popup, {
+			className: "dialog pairing-prompt",
+			children: request && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsxs(AlertDialog.Title, {
+					className: "pairing-title",
+					children: [
+						"Allow ",
+						request.deviceName,
+						" to connect?"
+					]
+				}),
+				/* @__PURE__ */ jsxs(AlertDialog.Description, {
+					className: "dialog-message",
+					children: [
+						"Requested from ",
+						request.source,
+						". Only approve if this code matches the one shown on that device."
+					]
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "pairing-code",
+					"aria-label": `Code ${request.code}`,
+					children: request.code
+				}),
+				pending.length > 1 && /* @__PURE__ */ jsxs("p", {
+					className: "settings-note",
+					children: [pending.length - 1, " more waiting"]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "dialog-actions",
+					children: [/* @__PURE__ */ jsx("button", {
+						type: "button",
+						className: "dialog-button",
+						onClick: () => void decide(request.id, "deny"),
+						children: "Deny"
+					}), /* @__PURE__ */ jsx("button", {
+						type: "button",
+						autoFocus: true,
+						className: "dialog-button is-primary",
+						onClick: () => void decide(request.id, "approve"),
+						children: "Approve"
+					})]
+				})
+			] })
+		})] })
+	});
+}
+//#endregion
+//#region src/components/CrashReport.tsx
+var CrashReport = ({ children }) => /* @__PURE__ */ jsx(Fragment$1, { children });
+//#endregion
+//#region src/client/image-attach.ts
+var attachableTypes = [
+	"image/png",
+	"image/jpeg",
+	"image/gif",
+	"image/webp"
+];
+var uploadErrors = {
+	image_too_large: "This image is larger than 20 MB.",
+	unsupported_image: "Only PNG, JPEG, GIF and WebP images can be attached.",
+	uploads_unsupported_target: "Images can be attached only on the Local machine for now.",
+	machine_disconnected: "The machine is not connected."
+};
+var isAttachableImage = (file) => attachableTypes.includes(file.type);
+var imageFilesFrom = (data) => data?.files ? [...data.files].filter(isAttachableImage) : [];
+var carriesFiles = (data) => !!data?.types && [...data.types].includes("Files");
+var escapePathForTerminal = (path) => path.replace(/([\s\\'"()&;$`!*?[\]{}<>|#~])/g, "\\$1");
+async function uploadImage(machineId, file) {
+	if (!isAttachableImage(file)) throw new Error(uploadErrors.unsupported_image);
+	if (file.size > 20971520) throw new Error(uploadErrors.image_too_large);
+	const response = await fetch(`/api/uploads?machineId=${encodeURIComponent(machineId)}`, {
+		method: "POST",
+		headers: { "Content-Type": file.type },
+		body: file
+	});
+	const result = await response.json().catch(() => ({}));
+	if (!response.ok || !result.path) throw new Error(uploadErrors[result.error ?? ""] ?? "The image could not be attached.");
+	return result.path;
+}
+var THUMBNAIL_SIZE = 160;
+var readAsDataUrl = (file) => new Promise((done, fail) => {
+	const reader = new FileReader();
+	reader.onload = () => done(String(reader.result));
+	reader.onerror = () => fail(reader.error);
+	reader.readAsDataURL(file);
+});
+async function thumbnailDataUrl(file) {
+	if (typeof createImageBitmap !== "function") return readAsDataUrl(file);
+	const bitmap = await createImageBitmap(file);
+	const scale = Math.min(1, THUMBNAIL_SIZE / Math.max(bitmap.width, bitmap.height));
+	const canvas = document.createElement("canvas");
+	canvas.width = Math.max(1, Math.round(bitmap.width * scale));
+	canvas.height = Math.max(1, Math.round(bitmap.height * scale));
+	canvas.getContext("2d")?.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
+	bitmap.close();
+	return canvas.toDataURL("image/jpeg", .8);
+}
+async function uploadImagesAsTerminalText(machineId, files) {
+	const paths = [];
+	for (const file of files) paths.push(await uploadImage(machineId, file));
+	return paths.map(escapePathForTerminal).join(" ") + " ";
+}
+//#endregion
+//#region src/lib/uuid.ts
+var hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+function uuid() {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const text = hex(bytes);
+	return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`;
+}
+//#endregion
+//#region src/components/usePromptImages.ts
+var ONLY_IMAGES$1 = "Only PNG, JPEG, GIF and WebP images can be attached.";
+var promptWithImages = (prompt, images) => [prompt.trim(), ...images.map((image) => escapePathForTerminal(image.path))].filter(Boolean).join(" ");
+function usePromptImages({ machineId }) {
+	const [dragging, setDragging] = useState(false);
+	const [attachments, setAttachments] = useState([]);
+	const [uploading, setUploading] = useState(0);
+	const [error, setError] = useState("");
+	const depth = useRef(0);
+	const attach = async (files) => {
+		if (!files.length) {
+			setError(ONLY_IMAGES$1);
+			return;
+		}
+		setError("");
+		setUploading((count) => count + files.length);
+		for (const file of files) try {
+			const path = await uploadImage(machineId, file);
+			const preview = await thumbnailDataUrl(file);
+			setAttachments((current) => [...current, {
+				id: uuid(),
+				name: file.name || "image",
+				preview,
+				path
+			}]);
+		} catch (cause) {
+			setError(cause instanceof Error ? cause.message : "The image could not be attached.");
+		} finally {
+			setUploading((count) => count - 1);
+		}
+	};
+	const remove = (id) => setAttachments((current) => current.filter((image) => image.id !== id));
+	return {
+		dragging,
+		attachments,
+		setAttachments,
+		uploading,
+		error,
+		remove,
+		handlers: {
+			onDragEnter: (event) => {
+				if (!carriesFiles(event.dataTransfer)) return;
+				event.preventDefault();
+				depth.current += 1;
+				setDragging(true);
+			},
+			onDragOver: (event) => {
+				if (!carriesFiles(event.dataTransfer)) return;
+				event.preventDefault();
+				event.dataTransfer.dropEffect = "copy";
+			},
+			onDragLeave: (event) => {
+				if (!carriesFiles(event.dataTransfer)) return;
+				depth.current = Math.max(0, depth.current - 1);
+				if (!depth.current) setDragging(false);
+			},
+			onDrop: (event) => {
+				if (!carriesFiles(event.dataTransfer)) return;
+				event.preventDefault();
+				depth.current = 0;
+				setDragging(false);
+				attach(imageFilesFrom(event.dataTransfer));
+			},
+			onPaste: (event) => {
+				const images = imageFilesFrom(event.clipboardData);
+				if (!images.length) return;
+				event.preventDefault();
+				attach(images);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/components/ComposerCombobox.tsx
+function ComposerCombobox({ label, value, options, onChange, icon, allowCustom = false, action }) {
+	const [query, setQuery] = useState("");
+	const selected = options.find((option) => option.value === value) ?? {
+		value,
+		label: value
+	};
+	const search = query.trim();
+	const items = options.filter((option) => option.label.toLowerCase().includes(search.toLowerCase()));
+	const custom = allowCustom && search && !options.some((option) => option.value === search) ? {
+		value: search,
+		label: `Use “${search}”`
+	} : null;
+	return /* @__PURE__ */ jsxs(Combobox.Root, {
+		items: custom ? [...items, custom] : items,
+		value: selected,
+		filter: null,
+		inputValue: query,
+		onInputValueChange: setQuery,
+		onOpenChange: () => setQuery(""),
+		itemToStringLabel: (option) => option.label,
+		isItemEqualToValue: (a, b) => a.value === b.value,
+		onValueChange: (option) => {
+			if (option && !option.disabled) onChange(option.value);
+		},
+		children: [/* @__PURE__ */ jsx(Tooltip$1, {
+			label: `${label}: ${selected.label}`,
+			children: /* @__PURE__ */ jsxs(Combobox.Trigger, {
+				className: "composer-select",
+				"aria-label": `${label}: ${selected.label}`,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "composer-select-icon",
+						"aria-hidden": "true",
+						children: selected.icon ?? icon
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "composer-select-label",
+						children: selected.shortLabel ?? (selected.label || label)
+					}),
+					/* @__PURE__ */ jsx(ChevronDown, {
+						className: "composer-select-caret",
+						size: 11,
+						"aria-hidden": "true"
+					})
+				]
+			})
+		}), /* @__PURE__ */ jsx(Combobox.Portal, { children: /* @__PURE__ */ jsx(Combobox.Positioner, {
+			className: "composer-select-positioner",
+			sideOffset: 6,
+			align: "start",
+			collisionPadding: 12,
+			children: /* @__PURE__ */ jsxs(Combobox.Popup, {
+				className: "composer-select-popup",
+				"aria-label": `${label} options`,
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: "composer-select-search",
+						children: [/* @__PURE__ */ jsx(Search, {
+							size: 14,
+							"aria-hidden": "true"
+						}), /* @__PURE__ */ jsx(Combobox.Input, {
+							"aria-label": `Search ${label.toLowerCase()}`,
+							placeholder: `Search ${label.toLowerCase()}…`,
+							maxLength: allowCustom ? 120 : void 0
+						})]
+					}),
+					/* @__PURE__ */ jsx(Combobox.Empty, {
+						className: "composer-select-empty",
+						children: "No matches"
+					}),
+					/* @__PURE__ */ jsx(Combobox.List, {
+						className: "composer-select-list",
+						children: (option) => /* @__PURE__ */ jsxs(Combobox.Item, {
+							value: option,
+							disabled: option.disabled,
+							className: "composer-select-option",
+							children: [
+								option.icon && /* @__PURE__ */ jsx("span", {
+									"aria-hidden": "true",
+									children: option.icon
+								}),
+								/* @__PURE__ */ jsx("span", {
+									className: "composer-select-option-label",
+									children: option.label
+								}),
+								/* @__PURE__ */ jsx(Combobox.ItemIndicator, {
+									className: "composer-select-check",
+									children: /* @__PURE__ */ jsx(Check, { size: 14 })
+								})
+							]
+						}, option.value)
+					}),
+					action && /* @__PURE__ */ jsxs("button", {
+						type: "button",
+						className: "composer-select-action",
+						onClick: action.onClick,
+						children: [action.icon, /* @__PURE__ */ jsx("span", { children: action.label })]
+					})
+				]
+			})
+		}) })]
+	});
+}
+//#endregion
+//#region src/components/ProjectIcon.tsx
+function ProjectIcon({ project }) {
+	const image = useRef(null);
+	const [loaded, setLoaded] = useState(false);
+	const [failed, setFailed] = useState(false);
+	useEffect(() => {
+		if (image.current?.complete) {
+			setLoaded(image.current.naturalWidth > 0);
+			setFailed(image.current.naturalWidth === 0);
+		}
+	}, [project.iconUrl]);
+	return /* @__PURE__ */ jsxs("span", {
+		className: `thread-project ${loaded ? "has-icon" : ""}`,
+		style: { "--project-color": project.color },
+		"aria-hidden": "true",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "thread-project-letter",
+			children: project.initial
+		}), project.iconUrl && !failed && /* @__PURE__ */ jsx("img", {
+			ref: image,
+			src: project.iconUrl,
+			alt: "",
+			decoding: "async",
+			onLoad: () => setLoaded(true),
+			onError: () => setFailed(true)
+		})]
+	});
+}
+//#endregion
+//#region src/components/ProjectPicker.tsx
+function ProjectPicker({ projects, projectId, onChange, onAddProject }) {
+	return /* @__PURE__ */ jsx(ComposerCombobox, {
+		label: "Project",
+		value: projectId,
+		onChange,
+		icon: /* @__PURE__ */ jsx(Folder, { size: 14 }),
+		action: onAddProject ? {
+			label: "Add project",
+			icon: /* @__PURE__ */ jsx(Plus, { size: 14 }),
+			onClick: onAddProject
+		} : void 0,
+		options: projects.map((project) => ({
+			value: project.id,
+			label: project.name,
+			icon: /* @__PURE__ */ jsx(ProjectIcon, { project }, project.id)
+		}))
+	});
+}
+//#endregion
+//#region src/components/LaunchSelectors.tsx
+function LaunchSelectors({ machine, machines, projects, projectId, harness, model, onMachineChange, onProjectChange, onHarnessChange, onModelChange, onAddProject }) {
+	const models = machine.harnesses.find((choice) => choice.id === harness)?.models ?? [];
+	return /* @__PURE__ */ jsxs("div", {
+		className: "composer-selectors",
+		children: [
+			/* @__PURE__ */ jsx(ComposerCombobox, {
+				label: "Machine",
+				value: machine.id,
+				onChange: onMachineChange,
+				icon: /* @__PURE__ */ jsx(Monitor, { size: 14 }),
+				options: machines.map((choice) => ({
+					value: choice.id,
+					label: `${choice.name}${choice.connected ? "" : " · Not connected"}`,
+					shortLabel: choice.name,
+					disabled: !choice.connected
+				}))
+			}),
+			/* @__PURE__ */ jsx(ProjectPicker, {
+				projects,
+				projectId,
+				onChange: onProjectChange,
+				onAddProject
+			}, machine.id),
+			/* @__PURE__ */ jsx(ComposerCombobox, {
+				label: "Harness",
+				value: harness,
+				onChange: onHarnessChange,
+				icon: /* @__PURE__ */ jsx(TerminalSquare, { size: 14 }),
+				options: machine.harnesses.map((choice) => ({
+					value: choice.id,
+					label: choice.name,
+					shortLabel: choice.name === "Claude Code" ? "Claude" : choice.name
+				}))
+			}),
+			/* @__PURE__ */ jsx(ComposerCombobox, {
+				label: "Model",
+				value: model,
+				onChange: onModelChange,
+				icon: /* @__PURE__ */ jsx(Cpu, { size: 14 }),
+				allowCustom: machine.harnesses.find((choice) => choice.id === harness)?.customModels ?? false,
+				options: models.map((name) => ({
+					value: name,
+					label: name,
+					shortLabel: name.split("/").at(-1)
+				}))
+			}, `${machine.id}:${harness}`)
+		]
+	});
+}
+//#endregion
+//#region src/client/catalog.ts
+function useMachineCatalog(machineId, connected, configVersion = 1, session = "", projectId = "") {
+	return useQuery({
+		queryKey: [
+			"machine-catalog",
+			machineId,
+			session,
+			configVersion,
+			projectId
+		],
+		enabled: !!machineId && connected,
+		queryFn: async ({ signal }) => {
+			const response = await fetch("/api/catalog/" + encodeURIComponent(machineId) + (projectId ? "?projectId=" + encodeURIComponent(projectId) : ""), { signal });
+			if (!response.ok) throw new Error("Machine catalog is not available.");
+			return await response.json();
+		}
+	});
+}
+//#endregion
+//#region src/client/directory-suggestions.ts
+var looksLikePath = (value) => value.startsWith("/") || value.startsWith("~");
+var onlyStrings = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+function useDirectorySuggestions(machineId, prefix) {
+	const [suggestions, setSuggestions] = useState([]);
+	useEffect(() => {
+		if (!looksLikePath(prefix)) {
+			setSuggestions([]);
+			return;
+		}
+		const controller = new AbortController();
+		fetch(`/api/directories?machineId=${encodeURIComponent(machineId)}&prefix=${encodeURIComponent(prefix)}`, { signal: controller.signal }).then((response) => response.ok ? response.json() : []).then((body) => setSuggestions(onlyStrings(body))).catch(() => {});
+		return () => controller.abort();
+	}, [machineId, prefix]);
+	return suggestions;
+}
+//#endregion
+//#region src/components/CreateWorkspace.tsx
+var isAbsoluteOrHome = (path) => path.startsWith("/") || path.startsWith("~/");
+function CreateWorkspace({ machineId, onCreated }) {
+	const [path, setPath] = useState("");
+	const [label, setLabel] = useState("");
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState("");
+	const [highlighted, setHighlighted] = useState(0);
+	const [open, setOpen] = useState(false);
+	const suggestions = useDirectorySuggestions(machineId, path);
+	const showing = open && suggestions.length > 0 && !(suggestions.length === 1 && suggestions[0] === path);
+	const accept = (value) => {
+		setPath(value);
+		setHighlighted(0);
+		setOpen(true);
+	};
+	const onKeyDown = (event) => {
+		if (!showing) return;
+		if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+			event.preventDefault();
+			setHighlighted((index) => (index + (event.key === "ArrowDown" ? 1 : suggestions.length - 1)) % suggestions.length);
+		} else if (event.key === "Tab") {
+			event.preventDefault();
+			accept(suggestions[highlighted] ?? suggestions[0]);
+		} else if (event.key === "Enter") {
+			event.preventDefault();
+			accept(suggestions[highlighted] ?? suggestions[0]);
+			setOpen(false);
+		} else if (event.key === "Escape") setOpen(false);
+	};
+	const operation = useRef(null);
+	const submit = async (event) => {
+		event.preventDefault();
+		setBusy(true);
+		setError("");
+		const payload = JSON.stringify({
+			machineId,
+			path,
+			label
+		});
+		if (operation.current?.payload !== payload) operation.current = {
+			payload,
+			key: uuid()
+		};
+		try {
+			const response = await fetch("/api/workspaces", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"Idempotency-Key": operation.current.key
+				},
+				body: payload
+			});
+			const result = await response.json();
+			if (!response.ok) throw new Error(result.error ?? "Could not create workspace");
+			if (result.state === "unknown") throw new Error("The result is not known; check Herdr before you create another workspace.");
+			onCreated();
+		} catch (cause) {
+			setError(cause instanceof Error ? cause.message : "Could not create workspace");
+		} finally {
+			setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs("form", {
+		className: "thread-composer workspace-composer",
+		onSubmit: submit,
+		"aria-label": "Create workspace",
+		"aria-busy": busy,
+		children: [
+			/* @__PURE__ */ jsxs("label", {
+				className: "path-field",
+				children: [
+					"Project folder",
+					/* @__PURE__ */ jsx("input", {
+						value: path,
+						onChange: (event) => {
+							setPath(event.target.value);
+							setHighlighted(0);
+							setOpen(true);
+						},
+						onKeyDown,
+						onBlur: () => setOpen(false),
+						placeholder: "/absolute/path/to/project",
+						autoComplete: "off",
+						spellCheck: false,
+						role: "combobox",
+						"aria-expanded": showing,
+						"aria-autocomplete": "list",
+						required: true,
+						pattern: "(/|~/).*"
+					}),
+					showing && /* @__PURE__ */ jsx("ul", {
+						className: "path-suggestions",
+						role: "listbox",
+						children: suggestions.map((suggestion, index) => /* @__PURE__ */ jsx("li", {
+							role: "option",
+							"aria-selected": index === highlighted,
+							"data-highlighted": index === highlighted || void 0,
+							onMouseDown: (event) => {
+								event.preventDefault();
+								accept(suggestion);
+							},
+							children: suggestion
+						}, suggestion))
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("label", { children: ["Workspace name", /* @__PURE__ */ jsx("input", {
+				value: label,
+				onChange: (event) => setLabel(event.target.value),
+				required: true,
+				maxLength: 80
+			})] }),
+			/* @__PURE__ */ jsx("button", {
+				type: "submit",
+				disabled: busy || !isAbsoluteOrHome(path) || !label.trim(),
+				children: busy ? "Creating…" : "Create workspace"
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				className: "form-error",
+				role: "alert",
+				children: error
+			})
+		]
+	});
+}
+//#endregion
+//#region src/client/new-session-behavior.ts
+var newSessionBehaviorLabels = {
+	main: "Main checkout",
+	worktree: "New worktree",
+	remember: "Remember by project"
+};
+var behaviorKey = "webr-new-session-behavior";
+var legacyWorktreeKey = "webr-new-worktree";
+var lastWorktreeKey = (machineId, projectId) => `webr-last-worktree:${machineId}:${projectId}`;
+var isBehavior = (value) => value === "main" || value === "worktree" || value === "remember";
+var behaviorFromLegacySetting = () => localStorage.getItem(legacyWorktreeKey) === "false" ? "main" : "worktree";
+function readNewSessionBehavior() {
+	const stored = localStorage.getItem(behaviorKey);
+	return isBehavior(stored) ? stored : behaviorFromLegacySetting();
+}
+function writeNewSessionBehavior(behavior) {
+	localStorage.setItem(behaviorKey, behavior);
+}
+function recordWorktreeChoice(machineId, projectId, worktree) {
+	localStorage.setItem(lastWorktreeKey(machineId, projectId), String(worktree));
+}
+var rememberedWorktreeChoice = (machineId, projectId) => localStorage.getItem(lastWorktreeKey(machineId, projectId)) !== "false";
+function initialWorktreeChoice(machineId, projectId) {
+	const behavior = readNewSessionBehavior();
+	return behavior === "remember" ? rememberedWorktreeChoice(machineId, projectId) : behavior === "worktree";
+}
+//#endregion
+//#region src/client/new-thread-draft.ts
+var draftKey = "webr-new-thread-draft";
+var isImage = (value) => !!value && typeof value === "object" && [
+	"id",
+	"name",
+	"preview",
+	"path"
+].every((field) => typeof value[field] === "string");
+function readNewThreadDraft() {
+	try {
+		const stored = JSON.parse(localStorage.getItem(draftKey) ?? "{}");
+		return {
+			prompt: typeof stored.prompt === "string" ? stored.prompt : "",
+			images: Array.isArray(stored.images) ? stored.images.filter(isImage) : []
+		};
+	} catch {
+		return {
+			prompt: "",
+			images: []
+		};
+	}
+}
+function writeNewThreadDraft(draft) {
+	try {
+		if (!draft.prompt && !draft.images.length) localStorage.removeItem(draftKey);
+		else localStorage.setItem(draftKey, JSON.stringify(draft));
+	} catch {}
+}
+var clearNewThreadDraft = () => writeNewThreadDraft({
+	prompt: "",
+	images: []
+});
+//#endregion
+//#region src/components/NewThreadView.tsx
+var harnessPreference = (machineId, projectId) => `webr-last-harness:${machineId}:${projectId}`;
+function NewThreadView({ projects, machines, selectedProjectId, onOpenSidebar }) {
+	const [projectId, setProjectId] = useState(projects.find((project) => project.id === selectedProjectId)?.id ?? projects[0]?.id ?? "");
+	const [machineId, setMachineId] = useState(machines.find((machine) => selectedProjectId && Object.hasOwn(machine.projectPaths, selectedProjectId))?.id ?? machines[0]?.id ?? "");
+	const [harness, setHarness] = useState("");
+	const [model, setModel] = useState("Default");
+	const [worktree, setWorktree] = useState(true);
+	const [prompt, setPrompt] = useState("");
+	const [busy, setBusy] = useState(false);
+	const [error, setError] = useState("");
+	const [creatingWorkspace, setCreatingWorkspace] = useState(false);
+	const operation = useRef(null);
+	const images = usePromptImages({ machineId });
+	const baseMachine = machines.find((machine) => machine.id === machineId) ?? {
+		id: "",
+		name: "No target",
+		connected: false,
+		session: "",
+		projectPaths: {},
+		harnesses: []
+	};
+	const catalog = useMachineCatalog(machineId, baseMachine.connected, baseMachine.configVersion, baseMachine.session, projectId);
+	const machine = {
+		...baseMachine,
+		harnesses: baseMachine.connected ? catalog.data?.harnesses ?? [] : []
+	};
+	const machineProjects = projects.filter((project) => Object.hasOwn(machine.projectPaths, project.id)).map((project) => ({
+		...project,
+		path: machine.projectPaths[project.id],
+		iconUrl: machineId === "local" ? project.iconUrl : void 0
+	}));
+	const selectedHarness = machine.harnesses.find((choice) => choice.id === harness);
+	const canSubmit = !!(prompt.trim() && !images.uploading && model.trim() && machine.connected && machineProjects.some((project) => project.id === projectId) && selectedHarness?.launchEnabled) && !busy;
+	const draftRestored = useRef(false);
+	useEffect(() => {
+		const draft = readNewThreadDraft();
+		setPrompt(draft.prompt);
+		images.setAttachments(draft.images);
+		draftRestored.current = true;
+	}, []);
+	useEffect(() => {
+		if (draftRestored.current) writeNewThreadDraft({
+			prompt,
+			images: images.attachments
+		});
+	}, [prompt, images.attachments]);
+	useEffect(() => {
+		setWorktree(initialWorktreeChoice(machineId, projectId));
+	}, [machineId, projectId]);
+	useEffect(() => {
+		if (!projectId || !catalog.data) return;
+		const choices = catalog.data.harnesses;
+		const previous = localStorage.getItem(harnessPreference(machineId, projectId));
+		setHarness(choices.find((choice) => choice.id === previous)?.id ?? choices.find((choice) => choice.launchEnabled)?.id ?? choices[0]?.id ?? "");
+		setModel("Default");
+	}, [
+		machineId,
+		projectId,
+		catalog.data
+	]);
+	useEffect(() => {
+		if (!machineId && machines.length) setMachineId(machines.find((machine) => machine.id === "local")?.id ?? machines[0].id);
+		if (!projectId && machineProjects.length) setProjectId(machineProjects[0].id);
+	}, [
+		machines,
+		machineId,
+		machineProjects,
+		projectId
+	]);
+	const changeMachine = (id) => {
+		const next = machines.find((machine) => machine.id === id);
+		if (!next?.connected) return;
+		setMachineId(id);
+		if (!Object.hasOwn(next.projectPaths, projectId)) setProjectId(projects.find((project) => Object.hasOwn(next.projectPaths, project.id))?.id ?? "");
+		setHarness("");
+		setModel("Default");
+		setError("");
+	};
+	const changeProject = (id) => {
+		setProjectId(id);
+		setHarness("");
+		setModel("Default");
+		setError("");
+	};
+	const changeHarness = (id) => {
+		setHarness(id);
+		setModel("Default");
+		if (projectId) localStorage.setItem(harnessPreference(machineId, projectId), id);
+	};
+	const submit = async (event) => {
+		event.preventDefault();
+		if (!canSubmit) return;
+		setBusy(true);
+		setError("");
+		const payload = JSON.stringify({
+			prompt: promptWithImages(prompt, images.attachments),
+			projectId,
+			machineId,
+			agent: harness,
+			model: model.trim(),
+			worktree
+		});
+		if (operation.current?.payload !== payload) operation.current = {
+			payload,
+			key: uuid()
+		};
+		try {
+			const result = await fetch("/api/threads", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"Idempotency-Key": operation.current.key
+				},
+				body: payload
+			});
+			const response = await result.json();
+			if (!result.ok) throw new Error(response.error || "Could not create thread");
+			recordWorktreeChoice(machineId, projectId, worktree);
+			clearNewThreadDraft();
+			await navigate(`/threads/${encodeURIComponent(response.id)}`);
+		} catch (cause) {
+			setError(cause instanceof Error ? cause.message : "Could not create thread");
+			setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs("main", {
+		className: "new-thread-page",
+		"aria-label": "New thread",
+		children: [
+			/* @__PURE__ */ jsx("button", {
+				className: "mobile-menu",
+				onClick: onOpenSidebar,
+				children: "Threads"
+			}),
+			/* @__PURE__ */ jsx("h1", { children: "What do you want to build today?" }),
+			machine.connected && machine.id === "local" && (!machineProjects.length || creatingWorkspace) ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx("p", { children: !machineProjects.length ? "This Herdr session has no projects yet." : "Add a project to this Herdr session." }),
+				/* @__PURE__ */ jsx(CreateWorkspace, {
+					machineId: machine.id,
+					onCreated: () => setCreatingWorkspace(false)
+				}),
+				!!machineProjects.length && /* @__PURE__ */ jsx("button", {
+					className: "workspace-cancel",
+					onClick: () => setCreatingWorkspace(false),
+					children: "Cancel"
+				})
+			] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsxs("form", {
+					className: `thread-composer ${images.dragging ? "is-dropping" : ""}`,
+					onSubmit: submit,
+					"aria-busy": busy,
+					...images.handlers,
+					children: [
+						(images.attachments.length > 0 || images.uploading > 0) && /* @__PURE__ */ jsxs("ul", {
+							className: "composer-images",
+							"aria-label": "Attached images",
+							children: [images.attachments.map((image) => /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("img", {
+								src: image.preview,
+								alt: image.name
+							}), /* @__PURE__ */ jsx(Tooltip$1, {
+								label: "Remove image",
+								children: /* @__PURE__ */ jsx("button", {
+									type: "button",
+									"aria-label": `Remove ${image.name}`,
+									onClick: () => images.remove(image.id),
+									children: /* @__PURE__ */ jsx(X, {
+										size: 12,
+										strokeWidth: 2.4
+									})
+								})
+							})] }, image.id)), Array.from({ length: images.uploading }, (_, index) => /* @__PURE__ */ jsx("li", {
+								className: "is-uploading",
+								"aria-label": "Uploading image"
+							}, "uploading-" + index))]
+						}),
+						/* @__PURE__ */ jsx("textarea", {
+							autoFocus: true,
+							required: true,
+							maxLength: 8e3,
+							value: prompt,
+							onChange: (event) => setPrompt(event.target.value),
+							onKeyDown: (event) => {
+								if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+									event.preventDefault();
+									event.currentTarget.form?.requestSubmit();
+								}
+							},
+							"aria-label": "Thread prompt",
+							placeholder: "Write a prompt, or drop an image…"
+						}),
+						/* @__PURE__ */ jsxs("div", {
+							className: "composer-toolbar",
+							children: [
+								/* @__PURE__ */ jsx(LaunchSelectors, {
+									machine,
+									machines,
+									projects: machineProjects,
+									projectId,
+									harness,
+									model,
+									onMachineChange: changeMachine,
+									onProjectChange: changeProject,
+									onHarnessChange: changeHarness,
+									onModelChange: setModel,
+									onAddProject: machine.connected && machine.id === "local" ? () => setCreatingWorkspace(true) : void 0
+								}),
+								/* @__PURE__ */ jsx(Tooltip$1, {
+									label: worktree ? "new worktree" : "current checkout",
+									children: /* @__PURE__ */ jsxs("label", {
+										className: "worktree-option",
+										children: [/* @__PURE__ */ jsx("input", {
+											type: "checkbox",
+											checked: worktree,
+											onChange: (event) => setWorktree(event.target.checked),
+											"aria-label": "Create a new worktree"
+										}), /* @__PURE__ */ jsx(GitBranch, {
+											size: 15,
+											"aria-hidden": "true"
+										})]
+									})
+								}),
+								/* @__PURE__ */ jsx("div", {
+									className: "composer-actions",
+									children: /* @__PURE__ */ jsx(Tooltip$1, {
+										label: "Create thread",
+										children: /* @__PURE__ */ jsx("button", {
+											className: "composer-send",
+											type: "submit",
+											disabled: !canSubmit,
+											"aria-label": "Create thread",
+											children: busy ? "…" : /* @__PURE__ */ jsx(ArrowUp, {
+												size: 18,
+												strokeWidth: 2.2
+											})
+										})
+									})
+								})
+							]
+						})
+					]
+				}),
+				(selectedHarness?.reason || !machines.length || machine.error || catalog.isError) && /* @__PURE__ */ jsx("p", {
+					className: "composer-preview-note",
+					children: selectedHarness?.reason ?? (!machines.length ? "No target is configured." : machine.error ? `Machine is not connected: ${machine.error.replaceAll("_", " ")}.` : "The machine catalog is not available.")
+				}),
+				images.error && /* @__PURE__ */ jsx("p", {
+					className: "form-error",
+					role: "alert",
+					children: images.error
+				}),
+				error && /* @__PURE__ */ jsx("p", {
+					className: "form-error",
+					role: "alert",
+					children: error
+				})
+			] })
+		]
+	});
+}
+//#endregion
+//#region src/client/terminal-clipboard.ts
+var OSC_CLIPBOARD = 52;
+var OSC_52_CLIPBOARD_READ_REQUEST = "?";
+function decodeOsc52ClipboardWrite(data) {
+	const payload = data.slice(data.indexOf(";") + 1);
+	if (!data.includes(";") || !payload || payload === OSC_52_CLIPBOARD_READ_REQUEST) return void 0;
+	try {
+		return new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(payload), (char) => char.charCodeAt(0)));
+	} catch {
+		return;
+	}
+}
+function copyThroughDocumentCopyEvent(text) {
+	const fill = (event) => {
+		event.clipboardData?.setData("text/plain", text);
+		event.preventDefault();
+	};
+	document.addEventListener("copy", fill, true);
+	try {
+		return document.execCommand("copy");
+	} catch {
+		return false;
+	} finally {
+		document.removeEventListener("copy", fill, true);
+	}
+}
+async function writeClipboardText(text) {
+	try {
+		await navigator.clipboard.writeText(text);
+		return true;
+	} catch {
+		return copyThroughDocumentCopyEvent(text);
+	}
+}
+var hasOwnTextSelection = (target) => {
+	if ((target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) && target.selectionStart !== target.selectionEnd) return true;
+	return !!document.getSelection()?.toString();
+};
+function bindTerminalClipboard(host, terminal, canWriteFromTerminalOutput, onCopied) {
+	const copySelectionOnRelease = () => {
+		if (terminal.hasSelection()) writeClipboardText(terminal.getSelection()).then(onCopied);
+	};
+	const copySelectionOnShortcut = (event) => {
+		if (event.defaultPrevented || !terminal.hasSelection() || hasOwnTextSelection(event.target)) return;
+		event.clipboardData?.setData("text/plain", terminal.getSelection());
+		event.preventDefault();
+		onCopied(true);
+	};
+	const osc52 = terminal.parser.registerOscHandler(OSC_CLIPBOARD, (data) => {
+		const text = decodeOsc52ClipboardWrite(data);
+		if (text !== void 0 && canWriteFromTerminalOutput()) writeClipboardText(text).then(onCopied);
+		return true;
+	});
+	host.addEventListener("mouseup", copySelectionOnRelease);
+	window.addEventListener("copy", copySelectionOnShortcut);
+	return () => {
+		osc52.dispose();
+		host.removeEventListener("mouseup", copySelectionOnRelease);
+		window.removeEventListener("copy", copySelectionOnShortcut);
+	};
+}
+//#endregion
+//#region src/components/QrCode.tsx
+var QUIET_ZONE = 2;
+function QrCode({ value, label }) {
+	const { data, size } = encode(value);
+	const modules = data.flatMap((row, y) => row.flatMap((dark, x) => dark ? [`M${x + QUIET_ZONE} ${y + QUIET_ZONE}h1v1h-1z`] : []));
+	const span = size + 4;
+	return /* @__PURE__ */ jsxs("svg", {
+		className: "qr-code",
+		role: "img",
+		"aria-label": label,
+		viewBox: `0 0 ${span} ${span}`,
+		shapeRendering: "crispEdges",
+		children: [/* @__PURE__ */ jsx("rect", {
+			width: span,
+			height: span,
+			fill: "#fff"
+		}), /* @__PURE__ */ jsx("path", {
+			d: modules.join(""),
+			fill: "#000"
+		})]
+	});
+}
+//#endregion
+//#region src/components/NotificationSetting.tsx
+function NotificationSetting() {
+	const [permission, setPermission] = useState(notificationPermission);
+	if (!notificationsSupported() || permission !== "default") return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "settings-row",
+		children: [/* @__PURE__ */ jsxs("span", { children: ["Notify me about new requests", /* @__PURE__ */ jsx("small", {
+			className: "device-meta",
+			children: "Shown when Webr is open in a hidden tab."
+		})] }), /* @__PURE__ */ jsx("button", {
+			type: "button",
+			className: "dialog-button",
+			onClick: () => void requestNotificationPermission().then(setPermission),
+			children: "Turn on"
+		})]
+	});
+}
+//#endregion
+//#region src/components/RemoteActivity.tsx
+var VISIBLE_EVENTS = 8;
+function RemoteActivity({ refreshKey }) {
+	const [events, setEvents] = useState([]);
+	useEffect(() => {
+		listAuditEvents().then(setEvents, () => void 0);
+	}, [refreshKey]);
+	if (!events.length) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "remote-activity",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "settings-subtitle",
+			children: "Recent activity"
+		}), events.slice(0, VISIBLE_EVENTS).map((event) => /* @__PURE__ */ jsxs("p", {
+			className: "activity-row",
+			children: [/* @__PURE__ */ jsx("span", { children: describeAuditEvent(event) }), /* @__PURE__ */ jsx("time", {
+				dateTime: new Date(event.at).toISOString(),
+				children: relativeTime$1(event.at)
+			})]
+		}, event.id))]
+	});
+}
+//#endregion
+//#region src/components/RemoteAccess.tsx
+function InviteDialog({ invite, onClose }) {
+	const [urlIndex, setUrlIndex] = useState(0);
+	const [copied, setCopied] = useState(false);
+	const url = invite.urls[urlIndex];
+	const copy = () => writeClipboardText(invite.token).then((ok) => {
+		if (!ok) return;
+		setCopied(true);
+		setTimeout(() => setCopied(false), 1500);
+	});
+	return /* @__PURE__ */ jsx(Dialog.Root, {
+		open: true,
+		onOpenChange: (open) => {
+			if (!open) onClose();
+		},
+		children: /* @__PURE__ */ jsxs(Dialog.Portal, { children: [/* @__PURE__ */ jsx(Dialog.Backdrop, { className: "dialog-backdrop" }), /* @__PURE__ */ jsxs(Dialog.Popup, {
+			className: "dialog pairing-invite",
+			children: [
+				/* @__PURE__ */ jsx(Dialog.Title, {
+					className: "pairing-title",
+					children: "Connect a device"
+				}),
+				url ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+					/* @__PURE__ */ jsx(Dialog.Description, {
+						className: "dialog-message",
+						children: "Scan with the device’s camera, or open Webr there and enter the code."
+					}),
+					/* @__PURE__ */ jsx(QrCode, {
+						value: url,
+						label: "QR code to connect a device"
+					}),
+					invite.urls.length > 1 && /* @__PURE__ */ jsx("div", {
+						className: "theme-control theme-control--labels",
+						role: "group",
+						"aria-label": "Address",
+						children: invite.urls.map((address, index) => /* @__PURE__ */ jsx("button", {
+							type: "button",
+							"aria-pressed": index === urlIndex,
+							className: index === urlIndex ? "theme-option is-selected" : "theme-option",
+							onClick: () => setUrlIndex(index),
+							children: new URL(address).host
+						}, address))
+					})
+				] }) : /* @__PURE__ */ jsxs(Dialog.Description, {
+					className: "dialog-message",
+					children: [
+						"Webr only listens on this computer. Restart it with ",
+						/* @__PURE__ */ jsx("code", { children: "--lan" }),
+						" or ",
+						/* @__PURE__ */ jsx("code", { children: "--origin <url>" }),
+						" so other devices can reach it."
+					]
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "pairing-token",
+					children: [/* @__PURE__ */ jsx("code", { children: invite.token }), /* @__PURE__ */ jsx("button", {
+						type: "button",
+						className: "dialog-button",
+						onClick: () => void copy(),
+						"aria-label": "Copy code",
+						children: copied ? /* @__PURE__ */ jsx(Check, { size: 14 }) : /* @__PURE__ */ jsx(Copy, { size: 14 })
+					})]
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "settings-note",
+					children: "Works once and expires in 5 minutes."
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "dialog-actions",
+					children: /* @__PURE__ */ jsx(Dialog.Close, {
+						className: "dialog-button is-primary",
+						children: "Done"
+					})
+				})
+			]
+		})] })
+	});
+}
+function RemoteAccess() {
+	const [devices, setDevices] = useState([]);
+	const [invite, setInvite] = useState();
+	const [error, setError] = useState("");
+	const refresh = useCallback(() => listDevices().then(setDevices, () => void 0), []);
+	useEffect(() => {
+		refresh();
+	}, [refresh]);
+	const showInvite = () => createInvite().then((created) => {
+		setError("");
+		setInvite(created);
+	}, (failure) => setError(failure.message));
+	const revoke = async (device) => {
+		if (!await confirmDialog(`Disconnect ${device.name}? It will need to be approved again.`, {
+			confirmLabel: "Disconnect",
+			danger: true
+		})) return;
+		await revokeDevice(device.id);
+		if (device.current) location.reload();
+		else await refresh();
+	};
+	return /* @__PURE__ */ jsxs("section", {
+		id: "remote-access",
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "settings-section-title",
+				children: /* @__PURE__ */ jsx("h2", { children: "Remote access" })
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "settings-note",
+				children: "Other devices ask to connect and you approve them here. This computer never needs a code."
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "settings-row",
+				children: [/* @__PURE__ */ jsx("span", { children: "Connect a device" }), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "dialog-button",
+					onClick: () => void showInvite(),
+					children: "Show code"
+				})]
+			}),
+			/* @__PURE__ */ jsx(NotificationSetting, {}),
+			error && /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				className: "form-error",
+				children: error
+			}),
+			devices.map((device) => /* @__PURE__ */ jsxs("div", {
+				className: "settings-row",
+				children: [/* @__PURE__ */ jsxs("span", { children: [
+					device.name,
+					device.current && /* @__PURE__ */ jsx("em", {
+						className: "device-tag",
+						children: "This device"
+					}),
+					/* @__PURE__ */ jsxs("small", {
+						className: "device-meta",
+						children: [
+							"Active ",
+							relativeTime$1(device.lastSeenAt),
+							" · Signs out ",
+							relativeFuture(device.expiresAt),
+							" if unused"
+						]
+					})
+				] }), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "dialog-button",
+					onClick: () => void revoke(device),
+					children: "Disconnect"
+				})]
+			}, device.id)),
+			/* @__PURE__ */ jsx(RemoteActivity, { refreshKey: devices }),
+			invite && /* @__PURE__ */ jsx(InviteDialog, {
+				invite,
+				onClose: () => setInvite(void 0)
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/SettingsView.tsx
+function SettingsView({ onOpenSidebar }) {
+	const [behavior, setBehavior] = useState("worktree");
+	const [shortcuts, setShortcuts] = useState(defaultShortcuts);
+	const [recording, setRecording] = useState(null);
+	const [error, setError] = useState("");
+	useEffect(() => {
+		setBehavior(readNewSessionBehavior());
+		setShortcuts(getShortcuts());
+	}, []);
+	const recordKey = (event, action) => {
+		event.preventDefault();
+		event.stopPropagation();
+		if (event.key === "Escape") {
+			setRecording(null);
+			setError("");
+			return;
+		}
+		const combo = keyCombo(event);
+		if (!combo) return;
+		if (isReservedShortcut(combo) || combo === "meta+k") {
+			setError("Choose a shortcut with a modifier that does not conflict with the browser or ⌘K.");
+			return;
+		}
+		if (Object.entries(shortcuts).some(([name, key]) => name !== action && key === combo)) {
+			setError("That shortcut is already in use.");
+			return;
+		}
+		const next = {
+			...shortcuts,
+			[action]: combo
+		};
+		setShortcuts(next);
+		localStorage.setItem("webr-shortcuts", JSON.stringify(next));
+		setRecording(null);
+		setError("");
+	};
+	return /* @__PURE__ */ jsxs("main", {
+		className: "form-page settings-page",
+		children: [
+			/* @__PURE__ */ jsx("button", {
+				className: "mobile-menu",
+				onClick: onOpenSidebar,
+				children: "Threads"
+			}),
+			/* @__PURE__ */ jsx("h1", { children: "Settings" }),
+			/* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h2", { children: "Appearance" }), /* @__PURE__ */ jsxs("div", {
+				className: "settings-row",
+				children: [/* @__PURE__ */ jsx("span", { children: "Theme" }), /* @__PURE__ */ jsx(ThemeControl, { expanded: true })]
+			})] }),
+			/* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h2", { children: "New threads" }), /* @__PURE__ */ jsxs("div", {
+				className: "settings-row",
+				children: [/* @__PURE__ */ jsx("span", { children: "New session behavior" }), /* @__PURE__ */ jsx("div", {
+					className: "theme-control theme-control--labels",
+					role: "group",
+					"aria-label": "New session behavior",
+					children: Object.keys(newSessionBehaviorLabels).map((choice) => /* @__PURE__ */ jsx("button", {
+						type: "button",
+						"aria-pressed": behavior === choice,
+						className: behavior === choice ? "theme-option is-selected" : "theme-option",
+						onClick: () => {
+							setBehavior(choice);
+							writeNewSessionBehavior(choice);
+						},
+						children: newSessionBehaviorLabels[choice]
+					}, choice))
+				})]
+			})] }),
+			/* @__PURE__ */ jsx(RemoteAccess, {}),
+			/* @__PURE__ */ jsxs("section", {
+				id: "shortcuts",
+				children: [
+					/* @__PURE__ */ jsxs("div", {
+						className: "settings-section-title",
+						children: [/* @__PURE__ */ jsx("h2", { children: "Keyboard shortcuts" }), /* @__PURE__ */ jsx("button", {
+							onClick: () => {
+								setShortcuts(defaultShortcuts);
+								localStorage.removeItem("webr-shortcuts");
+								setRecording(null);
+								setError("");
+							},
+							children: "Reset"
+						})]
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "settings-note",
+						children: "Press ⌘K for all actions and threads."
+					}),
+					Object.keys(shortcutLabels).map((action) => /* @__PURE__ */ jsxs("div", {
+						className: "settings-row",
+						children: [/* @__PURE__ */ jsx("span", { children: shortcutLabels[action] }), /* @__PURE__ */ jsx("button", {
+							className: "shortcut-key",
+							"data-recording": recording === action,
+							onClick: () => {
+								setRecording(action);
+								setError("");
+							},
+							onKeyDown: (event) => recording === action && recordKey(event, action),
+							"aria-label": `Change ${shortcutLabels[action]} shortcut`,
+							children: recording === action ? "Press keys…" : shortcutKeys(shortcuts[action]).map((key, index) => /* @__PURE__ */ jsx("kbd", { children: key }, index))
+						})]
+					}, action)),
+					error && /* @__PURE__ */ jsx("p", {
+						role: "alert",
+						className: "form-error",
+						children: error
+					})
+				]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/lib/models.ts
+var harnessNames = {
+	claude: "Claude Code",
+	codex: "Codex",
+	opencode: "OpenCode",
+	pi: "Pi"
+};
+function harnessName(agent) {
+	return Object.hasOwn(harnessNames, agent) ? harnessNames[agent] : agent;
+}
+function relativeTime(value) {
+	const minutes = Math.max(0, Math.floor((Date.now() - new Date(value).getTime()) / 6e4));
+	if (minutes < 1) return "now";
+	if (minutes < 60) return `${minutes}m`;
+	if (minutes < 1440) return `${Math.floor(minutes / 60)}h`;
+	return `${Math.floor(minutes / 1440)}d`;
+}
+//#endregion
+//#region src/lib/launch.ts
+var launchSteps = [
+	{
+		id: "validate",
+		label: "Checking the machine",
+		active: "Checking the machine…"
+	},
+	{
+		id: "checkout",
+		label: "Creating the worktree",
+		active: "Creating the worktree…"
+	},
+	{
+		id: "start",
+		label: "Starting the agent",
+		active: "Starting the agent…"
+	},
+	{
+		id: "prompt",
+		label: "Sending your prompt",
+		active: "Sending your prompt…"
+	}
+];
+var RECENT_FAILURE_MS = 6e5;
+var launchStepIndex = (step) => step === "checkout_complete" ? 2 : Math.max(0, launchSteps.findIndex((item) => item.id === step));
+var isLaunching = (thread) => ["pending", "running"].includes(thread.operation?.state ?? "") && !thread.panes.some((pane) => pane.kind === "agent");
+var launchFailed = (thread) => ["failed", "unknown"].includes(thread.operation?.state ?? "") && !thread.panes.some((pane) => pane.kind === "agent");
+var launchLabel = (thread) => launchSteps[launchStepIndex(thread.operation?.step ?? "validate")].active;
+var failedRecently = (thread, now) => now - Date.parse(thread.updatedAt) < RECENT_FAILURE_MS;
+var isListedThread = (thread, now = Date.now()) => thread.panes.some((pane) => pane.kind === "agent") || isLaunching(thread) || launchFailed(thread) && failedRecently(thread, now);
+//#endregion
+//#region src/components/OpenWorktree.tsx
+var projectQuery = (project) => new URLSearchParams({
+	machineId: project.machineId ?? "local",
+	projectId: project.id
+});
+var worktreeName = (worktree) => worktree.branch ?? worktree.label;
+var folderName = (worktree) => worktree.path.split("/").at(-1) ?? "";
+var matchesSearch = (worktree, query) => `${worktreeName(worktree)} ${folderName(worktree)}`.toLowerCase().includes(query.trim().toLowerCase());
+var fetchWorktrees = async (project, signal) => {
+	const response = await fetch(`/api/worktrees?${projectQuery(project)}`, { signal });
+	if (!response.ok) throw new Error("Could not list worktrees.");
+	return await response.json();
+};
+var openWorktree = async (project, worktree) => {
+	const response = await fetch("/api/worktrees/open", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			machineId: project.machineId ?? "local",
+			projectId: project.id,
+			path: worktree.path
+		})
+	});
+	if (!response.ok) throw new Error("Could not open this worktree.");
+	return (await response.json()).id;
+};
+var openAndShow = async (project, worktree) => {
+	try {
+		await navigate(`/threads/${encodeURIComponent(await openWorktree(project, worktree))}`);
+	} catch (error) {
+		alertDialog(error instanceof Error ? error.message : "Could not open this worktree.");
+	}
+};
+var keepTypingInsideInput = (event) => {
+	if (event.key.length === 1 || event.key === "Backspace") event.stopPropagation();
+};
+function WorktreeSearch({ project }) {
+	const [query, setQuery] = useState("");
+	const worktrees = useQuery({
+		queryKey: [
+			"worktrees",
+			project.machineId,
+			project.id
+		],
+		queryFn: ({ signal }) => fetchWorktrees(project, signal),
+		staleTime: 0,
+		gcTime: 0
+	});
+	const matches = (worktrees.data ?? []).filter((worktree) => matchesSearch(worktree, query));
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsxs("div", {
+		className: "composer-select-search",
+		children: [/* @__PURE__ */ jsx(Search, {
+			size: 14,
+			"aria-hidden": "true"
+		}), /* @__PURE__ */ jsx("input", {
+			autoFocus: true,
+			"aria-label": "Search worktrees",
+			placeholder: "Search worktrees…",
+			value: query,
+			onChange: (event) => setQuery(event.target.value),
+			onKeyDown: keepTypingInsideInput
+		})]
+	}), /* @__PURE__ */ jsxs("div", {
+		className: "worktree-menu-list",
+		children: [
+			matches.map((worktree) => /* @__PURE__ */ jsx(Tooltip$1, {
+				label: worktree.path,
+				side: "right",
+				children: /* @__PURE__ */ jsxs(Menu.Item, {
+					className: "thread-menu-item",
+					onClick: () => void openAndShow(project, worktree),
+					children: [/* @__PURE__ */ jsx(GitBranch, {
+						size: 14,
+						"aria-hidden": "true"
+					}), /* @__PURE__ */ jsxs("span", {
+						className: "worktree-menu-name",
+						children: [worktreeName(worktree), /* @__PURE__ */ jsx("small", { children: folderName(worktree) })]
+					})]
+				})
+			}, worktree.path)),
+			worktrees.isError && /* @__PURE__ */ jsx("p", {
+				className: "worktree-menu-note",
+				role: "alert",
+				children: "Could not list worktrees."
+			}),
+			worktrees.data && !matches.length && /* @__PURE__ */ jsx("p", {
+				className: "worktree-menu-note",
+				children: worktrees.data.length ? "No matches" : "Every worktree already has a thread"
+			})
+		]
+	})] });
+}
+function OpenWorktree({ projects }) {
+	return /* @__PURE__ */ jsxs(Menu.Root, { children: [/* @__PURE__ */ jsx(Tooltip$1, {
+		label: "Open existing worktree",
+		children: /* @__PURE__ */ jsx(Menu.Trigger, {
+			className: "sidebar-open-worktree",
+			"aria-label": "Open existing worktree",
+			disabled: !projects.length,
+			children: /* @__PURE__ */ jsx(Search, {
+				size: 16,
+				"aria-hidden": "true"
+			})
+		})
+	}), /* @__PURE__ */ jsx(Menu.Portal, { children: /* @__PURE__ */ jsx(Menu.Positioner, {
+		className: "thread-menu-positioner",
+		sideOffset: 6,
+		align: "start",
+		children: /* @__PURE__ */ jsx(Menu.Popup, {
+			className: "thread-menu",
+			children: projects.map((project) => /* @__PURE__ */ jsxs(Menu.SubmenuRoot, { children: [/* @__PURE__ */ jsxs(Menu.SubmenuTrigger, {
+				className: "thread-menu-item",
+				children: [
+					/* @__PURE__ */ jsx(ProjectIcon, { project }),
+					/* @__PURE__ */ jsx("span", { children: project.name }),
+					/* @__PURE__ */ jsx(ChevronRight, {
+						size: 14,
+						"aria-hidden": "true",
+						className: "worktree-menu-chevron"
+					})
+				]
+			}), /* @__PURE__ */ jsx(Menu.Portal, { children: /* @__PURE__ */ jsx(Menu.Positioner, {
+				className: "thread-menu-positioner",
+				sideOffset: 4,
+				alignOffset: -4,
+				children: /* @__PURE__ */ jsx(Menu.Popup, {
+					className: "thread-menu worktree-menu",
+					children: /* @__PURE__ */ jsx(WorktreeSearch, { project })
+				})
+			}) })] }, `${project.machineId}:${project.id}`))
+		})
+	}) })] });
+}
+//#endregion
+//#region src/components/ThreadTitleEditor.tsx
+function ThreadTitleEditor({ thread, onDone, onError }) {
+	const [title, setTitle] = useState(thread.title);
+	const input = useRef(null);
+	const finished = useRef(false);
+	useEffect(() => {
+		input.current?.focus();
+		input.current?.select();
+	}, []);
+	const finish = (save) => {
+		if (finished.current) return;
+		finished.current = true;
+		onDone();
+		const next = title.trim();
+		if (save && next && next !== thread.title) renameThread(thread, next).catch(onError);
+	};
+	return /* @__PURE__ */ jsx("input", {
+		ref: input,
+		className: "thread-name-input",
+		"aria-label": `Rename ${thread.title}`,
+		value: title,
+		maxLength: 90,
+		onChange: (event) => setTitle(event.target.value),
+		onBlur: () => finish(true),
+		onClick: (event) => event.stopPropagation(),
+		onKeyDown: (event) => {
+			event.stopPropagation();
+			if (event.key === "Enter") finish(true);
+			if (event.key === "Escape") finish(false);
+		}
+	});
+}
+//#endregion
+//#region src/components/useFlipList.ts
+var durationMs = 220;
+var itemSelector = "[data-flip-id]";
+var contentTops = (container) => {
+	const origin = container.getBoundingClientRect().top - container.scrollTop;
+	return new Map([...container.querySelectorAll(itemSelector)].map((element) => [element.dataset.flipId, {
+		element,
+		top: element.getBoundingClientRect().top - origin
+	}]));
+};
+function useFlipList(container) {
+	const previous = useRef(/* @__PURE__ */ new Map());
+	useLayoutEffect(() => {
+		if (!container.current) return;
+		const current = contentTops(container.current);
+		for (const [id, { element, top }] of current) {
+			const before = previous.current.get(id);
+			if (before === void 0 || Math.abs(before - top) < 1) continue;
+			element.animate([{ transform: `translateY(${before - top}px)` }, { transform: "none" }], {
+				duration: durationMs,
+				easing: "cubic-bezier(.2, .8, .2, 1)"
+			});
+		}
+		previous.current = new Map([...current].map(([id, { top }]) => [id, top]));
+	});
+}
+//#endregion
+//#region src/client/project-groups.ts
+function groupProjectLocations(projects, currentId) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const project of projects) {
+		const id = project.logicalId ?? project.id;
+		const group = groups.get(id);
+		if (group) {
+			group.locations.push(project.id);
+			if (project.id === currentId) group.project = project;
+		} else groups.set(id, {
+			id,
+			project,
+			locations: [project.id]
+		});
+	}
+	return [...groups.values()];
+}
+//#endregion
+//#region src/components/Sidebar.tsx
+var statusLabel = {
+	working: "Working",
+	blocked: "Needs input",
+	done: "Done",
+	idle: "Idle",
+	unknown: "Unknown"
+};
+var statusBadges = {
+	blocked: MessageCircleQuestion,
+	done: CircleCheck,
+	unknown: CircleHelp
+};
+var reportFailure = (error) => alertDialog(error instanceof Error ? error.message : "Herdr could not complete this action.");
+var confirmDelete = async (thread) => {
+	if (await confirmDialog(deleteWarning([thread]), {
+		confirmLabel: "Delete",
+		danger: true
+	})) await deleteThreadPermanently(thread).catch(reportFailure);
+};
+var ThreadRow = memo(function ThreadRow({ thread, project, machineName, current, showProject }) {
+	const archived = !!thread.archivedAt;
+	const ArchiveIcon = archived ? ArchiveRestore : Archive;
+	const archiveLabel = archived ? `Unarchive ${thread.title}` : `Archive ${thread.title}`;
+	const [renaming, setRenaming] = useState(false);
+	const editor = renaming ? /* @__PURE__ */ jsx(ThreadTitleEditor, {
+		thread,
+		onDone: () => setRenaming(false),
+		onError: reportFailure
+	}) : void 0;
+	return /* @__PURE__ */ jsxs(ContextMenu.Root, { children: [/* @__PURE__ */ jsxs(ContextMenu.Trigger, {
+		className: "thread-item",
+		"data-flip-id": thread.id,
+		onDoubleClick: (event) => {
+			event.preventDefault();
+			setRenaming(true);
+		},
+		children: [/* @__PURE__ */ jsx(ThreadLink, {
+			thread,
+			project,
+			machineName,
+			current,
+			showProject,
+			editor
+		}), /* @__PURE__ */ jsx(Tooltip$1, {
+			label: archived ? "Unarchive" : "Archive",
+			children: /* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "thread-archive",
+				"aria-label": archiveLabel,
+				onClick: () => void setThreadArchived(thread, !archived).catch(reportFailure),
+				children: /* @__PURE__ */ jsx(ArchiveIcon, {
+					size: 15,
+					strokeWidth: 1.8,
+					"aria-hidden": "true"
+				})
+			})
+		})]
+	}), /* @__PURE__ */ jsx(ContextMenu.Portal, { children: /* @__PURE__ */ jsx(ContextMenu.Positioner, {
+		className: "thread-menu-positioner",
+		children: /* @__PURE__ */ jsx(ContextMenu.Popup, {
+			className: "thread-menu",
+			children: /* @__PURE__ */ jsxs(ContextMenu.Item, {
+				className: "thread-menu-item is-danger",
+				onClick: () => void confirmDelete(thread),
+				children: [/* @__PURE__ */ jsx(Trash2, {
+					size: 14,
+					"aria-hidden": "true"
+				}), "Delete permanently"]
+			})
+		})
+	}) })] });
+});
+function ThreadLink({ thread, project, machineName, current, showProject, editor }) {
+	const launching = isLaunching(thread);
+	const failed = launchFailed(thread);
+	const StatusIcon = failed ? TriangleAlert : launching ? void 0 : statusBadges[thread.status];
+	const needsAttention = failed || thread.status === "blocked" || thread.status === "done";
+	const status = launching ? launchLabel(thread) : failed ? "Launch stopped" : statusLabel[thread.status];
+	const context = launching || failed ? status : showProject ? project?.name : harnessName(thread.agent);
+	const Row = editor ? "div" : "a";
+	return /* @__PURE__ */ jsx(Tooltip$1, {
+		label: `${thread.title} · ${project?.name ?? ""} · ${machineName} · ${harnessName(thread.agent)} · ${thread.model} · ${status}`,
+		side: "right",
+		children: /* @__PURE__ */ jsxs(Row, {
+			className: `thread-row ${current ? "is-current" : ""} ${needsAttention ? `needs-attention status-${failed ? "blocked" : thread.status}` : ""}`,
+			href: editor ? void 0 : `/threads/${encodeURIComponent(thread.id)}`,
+			"aria-current": current ? "page" : void 0,
+			"aria-label": `${thread.title} · ${project?.name ?? ""} · ${machineName} · ${status}`,
+			children: [
+				/* @__PURE__ */ jsxs("span", {
+					className: "thread-avatar",
+					"aria-hidden": "true",
+					children: [/* @__PURE__ */ jsx(ThreadAvatar, {
+						thread,
+						working: thread.status === "working" || launching,
+						size: 24
+					}), StatusIcon && /* @__PURE__ */ jsx(StatusIcon, {
+						className: `thread-status status-${failed ? "blocked" : thread.status}`,
+						size: 14,
+						strokeWidth: 2.2
+					})]
+				}),
+				/* @__PURE__ */ jsxs("span", {
+					className: "thread-copy",
+					children: [/* @__PURE__ */ jsxs("span", {
+						className: "thread-context",
+						children: [
+							showProject && project && !launching && !failed && /* @__PURE__ */ jsx(ProjectIcon, { project }),
+							thread.worktree && !launching && !failed && /* @__PURE__ */ jsx(GitBranch, {
+								className: "thread-worktree",
+								size: 11,
+								"aria-label": "Worktree"
+							}),
+							context
+						]
+					}), editor ?? /* @__PURE__ */ jsx("span", {
+						className: "thread-name",
+						children: thread.title
+					})]
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: "thread-time",
+					children: relativeTime(thread.updatedAt)
+				})
+			]
+		})
+	});
+}
+function ArchivedThreads({ threads, renderThread }) {
+	const [open, setOpen] = useState(false);
+	const [deleting, setDeleting] = useState(false);
+	const deleteAll = async () => {
+		if (!await confirmDialog(deleteWarning(threads), {
+			confirmLabel: "Delete all",
+			danger: true
+		})) return;
+		setDeleting(true);
+		try {
+			const result = await deleteArchivedThreads();
+			if (result.failed.length) await alertDialog(`${result.failed.length} archived ${result.failed.length === 1 ? "thread" : "threads"} could not be deleted.`);
+		} catch (error) {
+			reportFailure(error);
+		} finally {
+			setDeleting(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs("section", {
+		className: "thread-group archived-threads",
+		"aria-label": "Archived threads",
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "group-header",
+			children: [/* @__PURE__ */ jsxs("button", {
+				className: "group-title",
+				onClick: () => setOpen((value) => !value),
+				"aria-expanded": open,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "group-chevron",
+						"aria-hidden": "true",
+						children: open ? /* @__PURE__ */ jsx(ChevronDown, { size: 14 }) : /* @__PURE__ */ jsx(ChevronRight, { size: 14 })
+					}),
+					/* @__PURE__ */ jsx(Archive, {
+						size: 14,
+						"aria-hidden": "true"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "group-name",
+						children: "Archived"
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "group-count",
+						children: threads.length
+					})
+				]
+			}), /* @__PURE__ */ jsx("button", {
+				type: "button",
+				className: "archived-delete-all",
+				onClick: () => void deleteAll(),
+				disabled: deleting,
+				children: deleting ? "Deleting…" : "Delete all"
+			})]
+		}), open && threads.map(renderThread)]
+	});
+}
+function Sidebar({ projects, threads, archived = [], machines, currentId, mode, onModeChange, collapsed, mobileOpen, onCollapse, onCloseMobile, onOpenPalette }) {
+	const [closedProjects, setClosedProjects] = useState([]);
+	const currentProjectId = threads.find((thread) => thread.id === currentId)?.projectId;
+	const projectGroups = groupProjectLocations(projects, currentProjectId);
+	const navigation = useRef(null);
+	useFlipList(navigation);
+	const threadLink = (thread, showProject) => {
+		const project = projects.find((item) => item.id === thread.projectId);
+		return /* @__PURE__ */ jsx(ThreadRow, {
+			thread,
+			project,
+			machineName: machines.find((machine) => machine.id === thread.machineId)?.name ?? thread.machineId,
+			current: currentId === thread.id,
+			showProject
+		}, thread.id);
+	};
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [mobileOpen && /* @__PURE__ */ jsx("button", {
+		className: "sidebar-scrim",
+		"aria-label": "Close sidebar",
+		onClick: onCloseMobile
+	}), /* @__PURE__ */ jsxs("aside", {
+		className: `sidebar ${collapsed ? "is-collapsed" : ""} ${mobileOpen ? "is-mobile-open" : ""}`,
+		"aria-label": "Threads",
+		onClick: (event) => {
+			if (mobileOpen && event.target.closest("a[href]")) onCloseMobile();
+		},
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "sidebar-header",
+				children: [
+					!collapsed && /* @__PURE__ */ jsxs("span", {
+						className: "brand",
+						children: [/* @__PURE__ */ jsx("img", {
+							src: "/brand-mark.png",
+							alt: "",
+							width: 20,
+							height: 20
+						}), "webr"]
+					}),
+					/* @__PURE__ */ jsx("button", {
+						className: "icon-button sidebar-collapse",
+						"aria-label": collapsed ? "Expand sidebar" : "Collapse sidebar",
+						onClick: onCollapse,
+						children: collapsed ? /* @__PURE__ */ jsx(PanelLeftOpen, { size: 16 }) : /* @__PURE__ */ jsx(PanelLeftClose, { size: 16 })
+					}),
+					/* @__PURE__ */ jsx("button", {
+						className: "icon-button mobile-close",
+						"aria-label": "Close sidebar",
+						onClick: onCloseMobile,
+						children: /* @__PURE__ */ jsx(X, { size: 16 })
+					})
+				]
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "sidebar-actions",
+				children: [
+					/* @__PURE__ */ jsx(Tooltip$1, {
+						label: "New thread",
+						children: /* @__PURE__ */ jsxs("a", {
+							className: "sidebar-new-thread",
+							href: `/new${currentProjectId ? `?project=${encodeURIComponent(currentProjectId)}` : ""}`,
+							"aria-label": "New thread",
+							children: [/* @__PURE__ */ jsx(SquarePen, {
+								size: 16,
+								"aria-hidden": "true"
+							}), !collapsed && /* @__PURE__ */ jsx("span", { children: "New thread" })]
+						})
+					}),
+					/* @__PURE__ */ jsx(OpenWorktree, { projects }),
+					!collapsed && /* @__PURE__ */ jsxs("div", {
+						className: "sidebar-view-switch",
+						role: "group",
+						"aria-label": "Sidebar layout",
+						children: [/* @__PURE__ */ jsx(Tooltip$1, {
+							label: "Show threads",
+							children: /* @__PURE__ */ jsx("button", {
+								type: "button",
+								"aria-label": "Show threads",
+								"aria-pressed": mode === "threads",
+								onClick: () => onModeChange("threads"),
+								children: /* @__PURE__ */ jsx(LayoutList, {
+									size: 16,
+									"aria-hidden": "true"
+								})
+							})
+						}), /* @__PURE__ */ jsx(Tooltip$1, {
+							label: "Group by project",
+							children: /* @__PURE__ */ jsx("button", {
+								type: "button",
+								"aria-label": "Group by project",
+								"aria-pressed": mode === "projects",
+								onClick: () => onModeChange("projects"),
+								children: /* @__PURE__ */ jsx(FolderTree, {
+									size: 16,
+									"aria-hidden": "true"
+								})
+							})
+						})]
+					})
+				]
+			}),
+			!collapsed && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsxs("nav", {
+					ref: navigation,
+					className: "thread-navigation",
+					"aria-label": "Agent threads",
+					children: [mode === "projects" ? projectGroups.filter((group) => threads.some((thread) => group.locations.includes(thread.projectId))).sort((a, b) => (threads.find((thread) => b.locations.includes(thread.projectId))?.updatedAt ?? "").localeCompare(threads.find((thread) => a.locations.includes(thread.projectId))?.updatedAt ?? "")).map(({ id, project, locations }) => /* @__PURE__ */ jsxs("section", {
+						className: "thread-group",
+						children: [/* @__PURE__ */ jsxs("div", {
+							className: "group-header",
+							children: [/* @__PURE__ */ jsxs("button", {
+								className: "group-title",
+								onClick: () => setClosedProjects((value) => value.includes(id) ? value.filter((item) => item !== id) : [...value, id]),
+								"aria-expanded": !closedProjects.includes(id),
+								children: [
+									/* @__PURE__ */ jsx("span", {
+										className: "group-chevron",
+										"aria-hidden": "true",
+										children: closedProjects.includes(id) ? /* @__PURE__ */ jsx(ChevronRight, { size: 14 }) : /* @__PURE__ */ jsx(ChevronDown, { size: 14 })
+									}),
+									/* @__PURE__ */ jsx(ProjectIcon, { project }),
+									/* @__PURE__ */ jsx("span", {
+										className: "group-name",
+										children: project.name
+									})
+								]
+							}), /* @__PURE__ */ jsx(Tooltip$1, {
+								label: `New thread in ${project.name}`,
+								children: /* @__PURE__ */ jsx("a", {
+									className: "group-new-thread",
+									href: `/new?project=${encodeURIComponent(project.id)}`,
+									"aria-label": `New thread in ${project.name}`,
+									children: /* @__PURE__ */ jsx(SquarePen, {
+										size: 15,
+										"aria-hidden": "true"
+									})
+								})
+							})]
+						}), !closedProjects.includes(id) && threads.filter((thread) => locations.includes(thread.projectId)).map((thread) => threadLink(thread, false))]
+					}, id)) : threads.map((thread) => threadLink(thread, true)), !threads.length && !archived.length && /* @__PURE__ */ jsx("p", {
+						className: "sidebar-empty",
+						children: "No agents yet. Press ⌘K to start one."
+					})]
+				}),
+				!!archived.length && /* @__PURE__ */ jsx(ArchivedThreads, {
+					threads: archived,
+					renderThread: (thread) => threadLink(thread, true)
+				}),
+				/* @__PURE__ */ jsxs("div", {
+					className: "sidebar-footer",
+					children: [/* @__PURE__ */ jsxs("a", {
+						className: "sidebar-settings",
+						href: "/settings",
+						children: [/* @__PURE__ */ jsx(Settings2, { size: 15 }), " Settings"]
+					}), /* @__PURE__ */ jsx(Tooltip$1, {
+						label: "Open command palette",
+						children: /* @__PURE__ */ jsx("button", {
+							type: "button",
+							className: "sidebar-palette",
+							"aria-label": "Open command palette",
+							onClick: onOpenPalette,
+							children: /* @__PURE__ */ jsx("kbd", { children: "⌘K" })
+						})
+					})]
+				})
+			] })
+		]
+	})] });
+}
+//#endregion
+//#region src/client/store.ts
+var equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+var share = (previous, next) => previous && equal(previous, next) ? previous : next;
+function createRuntimeStore(bootstrap) {
+	const retired = /* @__PURE__ */ new Map();
+	const awaiting = /* @__PURE__ */ new Set();
+	const store = createStore((set, get) => ({
+		projections: {},
+		threads: {},
+		projects: {},
+		threadIds: [],
+		projectIds: [],
+		connected: false,
+		connection: (connected) => set((state) => {
+			if (connected) return { connected };
+			for (const id of Object.keys(state.projections)) awaiting.add(id);
+			return {
+				connected,
+				projections: Object.fromEntries(Object.entries(state.projections).map(([id, projection]) => [id, {
+					...projection,
+					connected: false,
+					freshAt: null
+				}])),
+				threads: Object.fromEntries(Object.entries(state.threads).map(([id, thread]) => [id, {
+					...thread,
+					status: "unknown",
+					panes: [],
+					bindingState: "detached"
+				}]))
+			};
+		}),
+		install: (projection) => {
+			const old = get();
+			const previous = old.projections[projection.machineId];
+			const generations = retired.get(projection.machineId) ?? /* @__PURE__ */ new Set();
+			if (generations.has(projection.generation) || !awaiting.has(projection.machineId) && previous?.generation === projection.generation && previous.revision >= projection.revision) return;
+			awaiting.delete(projection.machineId);
+			if (previous && previous.generation !== projection.generation) generations.add(previous.generation);
+			if (generations.size > 8) generations.delete(generations.values().next().value);
+			retired.set(projection.machineId, generations);
+			const threads = Object.fromEntries(Object.entries(old.threads).filter(([, thread]) => thread.machineId !== projection.machineId));
+			for (const thread of projection.threads) threads[thread.id] = share(old.threads[thread.id], {
+				...thread,
+				panes: thread.panes.map((pane) => share(old.threads[thread.id]?.panes.find((oldPane) => oldPane.id === pane.id && oldPane.terminalId === pane.terminalId), pane))
+			});
+			const projections = {
+				...old.projections,
+				[projection.machineId]: projection
+			};
+			const projects = {};
+			for (const entry of Object.values(projections)) for (const project of entry.projects) projects[project.id] = share(old.projects[project.id], project);
+			const threadIds = Object.values(threads).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map((thread) => thread.id);
+			const projectIds = Object.keys(projects);
+			set({
+				projections,
+				threads,
+				projects,
+				threadIds: share(old.threadIds, threadIds),
+				projectIds: share(old.projectIds, projectIds)
+			});
+		}
+	}));
+	for (const projection of bootstrap.projections) store.getState().install(projection);
+	return store;
+}
+var createUiStore = () => createStore((set) => ({
+	focusedPanes: {},
+	focus: (scope, paneId) => set((state) => ({ focusedPanes: {
+		...state.focusedPanes,
+		[scope]: paneId
+	} }))
+}));
+function decodeFrame(packet) {
+	if (packet.length < 32) throw new Error("short_frame");
+	const view = new DataView(packet.buffer, packet.byteOffset, packet.byteLength);
+	const seq = Number(view.getBigUint64(12));
+	if (view.getUint32(0) !== 1212437041 || view.getUint32(24) !== packet.length - 32 || packet.length - 32 > 262144 || !Number.isSafeInteger(seq) || view.getUint8(28) > 1 || view.getUint8(29) || view.getUint16(30)) throw new Error("invalid_frame");
+	const frame = {
+		streamId: view.getUint32(4),
+		generation: view.getUint32(8),
+		seq,
+		width: view.getUint16(20),
+		height: view.getUint16(22),
+		full: !!view.getUint8(28),
+		bytes: packet.subarray(32)
+	};
+	if (!frame.streamId || !frame.generation || !frame.width || frame.width > 500 || !frame.height || frame.height > 300) throw new Error("invalid_dimensions");
+	return frame;
+}
+var FrameSequence = class {
+	seq;
+	accept(frame) {
+		if (this.seq === void 0 && !frame.full) throw new Error("baseline_required");
+		if (this.seq !== void 0 && frame.seq !== this.seq + 1) throw new Error("sequence_gap");
+		this.seq = frame.seq;
+	}
+};
+//#endregion
+//#region src/client/terminal-renderer.ts
+var TerminalRenderer = class {
+	terminal;
+	acknowledge;
+	budget;
+	frames = [];
+	bytes = 0;
+	writing = false;
+	closed = false;
+	constructor(terminal, acknowledge, budget = 524288) {
+		this.terminal = terminal;
+		this.acknowledge = acknowledge;
+		this.budget = budget;
+	}
+	push(frame) {
+		if (this.closed) return;
+		if (this.bytes + frame.bytes.length > this.budget) throw new Error("renderer_overload");
+		this.bytes += frame.bytes.length;
+		this.frames.push(frame);
+		this.frames.length;
+		this.bytes / 1024;
+		this.flush();
+	}
+	close() {
+		this.closed = true;
+		this.frames = [];
+		this.bytes = 0;
+	}
+	flush() {
+		if (this.closed || this.writing || !this.frames.length) return;
+		this.writing = true;
+		const frame = this.frames.shift();
+		this.terminal.resize(frame.width, frame.height);
+		const bytes = frame.full ? new Uint8Array(frame.bytes.length + 2) : frame.bytes;
+		if (frame.full) {
+			bytes.set([27, 99]);
+			bytes.set(frame.bytes, 2);
+		}
+		const writeStart = perfNow();
+		this.terminal.write(bytes, () => {
+			if (this.closed) return;
+			perfNow() - writeStart;
+			this.bytes -= frame.bytes.length;
+			this.writing = false;
+			this.acknowledge(frame);
+			this.flush();
+		});
+	}
+};
+//#endregion
+//#region src/shared/retry.ts
+var retryDelay = (attempt, random = Math.random) => Math.min(3e4, Math.round(Math.min(25e3, 1e3 * 2 ** Math.min(attempt, 5)) * (.8 + random() * .4)));
+//#endregion
+//#region src/client/terminal-manager.ts
+var conflictMessage = "Another controller owns this terminal.";
+var BrowserTerminalManager = class {
+	install;
+	onConnection;
+	metadata;
+	binary;
+	stopped = true;
+	epoch = 0;
+	nextId = 1;
+	panes = /* @__PURE__ */ new Map();
+	reconnect;
+	instance = "";
+	failures = 0;
+	connectedAt = 0;
+	scrollSentAt = /* @__PURE__ */ new Map();
+	inputSentAt = /* @__PURE__ */ new Map();
+	openedAt = /* @__PURE__ */ new Map();
+	constructor(install, onConnection) {
+		this.install = install;
+		this.onConnection = onConnection;
+	}
+	start() {
+		this.stopped = false;
+		this.connect();
+	}
+	stop() {
+		this.stopped = true;
+		clearTimeout(this.reconnect);
+		this.disconnect();
+	}
+	mount(pane) {
+		const id = this.nextId++;
+		this.panes.set(id, {
+			...pane,
+			generation: 1,
+			sequence: new FrameSequence(),
+			writable: false,
+			accepted: false,
+			baseline: false,
+			pending: 0,
+			resizing: false,
+			attempts: 0
+		});
+		this.open(id);
+		return {
+			close: () => {
+				const current = this.panes.get(id);
+				if (current) {
+					this.send({
+						type: "release",
+						streamId: id,
+						generation: current.generation
+					});
+					current.renderer?.close();
+				}
+				this.panes.delete(id);
+			},
+			input: (text, paste = false) => {
+				const current = this.panes.get(id);
+				if (current?.writable) {
+					this.inputSentAt.set(id, perfNow());
+					this.send({
+						type: "input",
+						streamId: id,
+						generation: current.generation,
+						text,
+						paste
+					});
+				}
+			},
+			control: (takeover = false) => {
+				const current = this.panes.get(id);
+				if (current && (current.mode !== "control" || takeover)) {
+					this.send({
+						type: "release",
+						streamId: id,
+						generation: current.generation
+					});
+					current.reason = void 0;
+					current.mode = "control";
+					++current.generation;
+					current.sequence = new FrameSequence();
+					this.open(id, takeover);
+				}
+			},
+			observe: () => {
+				const current = this.panes.get(id);
+				if (current && current.mode !== "observe") {
+					this.send({
+						type: "release",
+						streamId: id,
+						generation: current.generation
+					});
+					current.mode = "observe";
+					++current.generation;
+					current.sequence = new FrameSequence();
+					this.open(id);
+				}
+			},
+			resize: (cols, rows, claim = false) => {
+				const current = this.panes.get(id);
+				if (!current || cols === current.cols && rows === current.rows && !(claim && current.mode === "control" && current.accepted)) return;
+				current.cols = cols;
+				current.rows = rows;
+				if (current.mode === "control" && current.accepted) {
+					current.writable = false;
+					current.baseline = false;
+					current.resizing = true;
+					current.onState("Waiting for the resized full baseline.", false);
+					this.send({
+						type: "resize",
+						streamId: id,
+						generation: current.generation,
+						cols,
+						rows
+					});
+				} else {
+					this.send({
+						type: "release",
+						streamId: id,
+						generation: current.generation
+					});
+					++current.generation;
+					current.sequence = new FrameSequence();
+					this.open(id);
+				}
+			},
+			scroll: (direction, lines, column, row) => {
+				const current = this.panes.get(id);
+				if (current?.writable) {
+					this.scrollSentAt.set(id, perfNow());
+					this.send({
+						type: "scroll",
+						streamId: id,
+						generation: current.generation,
+						direction,
+						lines,
+						column,
+						row
+					});
+				}
+			},
+			mouse: (action, button, column, row, modifiers) => {
+				const current = this.panes.get(id);
+				if (current?.writable) this.send({
+					type: "mouse",
+					streamId: id,
+					generation: current.generation,
+					action,
+					button,
+					column,
+					row,
+					modifiers
+				});
+			}
+		};
+	}
+	command(machineId, threadId, terminalId, action) {
+		const entry = [...this.panes.entries()].find(([, pane]) => pane.machineId === machineId && pane.threadId === threadId && pane.terminalId === terminalId);
+		if (!entry) return;
+		const [id, pane] = entry;
+		pane.writable = false;
+		pane.reason = void 0;
+		this.send({
+			type: "release",
+			streamId: id,
+			generation: pane.generation
+		});
+		pane.mode = action === "release" ? "observe" : "control";
+		++pane.generation;
+		pane.sequence = new FrameSequence();
+		this.open(id, action === "takeover");
+	}
+	send(action) {
+		if (this.binary?.readyState !== WebSocket.OPEN || this.metadata?.readyState !== WebSocket.OPEN) return false;
+		if (this.binary.bufferedAmount > 32768) {
+			this.disconnect();
+			return false;
+		}
+		this.binary.send(JSON.stringify(action));
+		return true;
+	}
+	open(id, takeover = false) {
+		const pane = this.panes.get(id);
+		if (!pane) return;
+		pane.writable = false;
+		pane.accepted = false;
+		pane.baseline = false;
+		pane.pending = 0;
+		pane.resizing = false;
+		pane.renderer?.close();
+		pane.renderer = new TerminalRenderer(pane.terminal, (frame) => {
+			if (this.panes.get(id) !== pane || pane.generation !== frame.generation) return;
+			if (!this.send({
+				type: "ack",
+				streamId: id,
+				generation: frame.generation,
+				seq: frame.seq
+			})) return;
+			--pane.pending;
+			if (frame.full && (!pane.resizing || frame.width === pane.cols && frame.height === pane.rows)) {
+				pane.baseline = true;
+				pane.resizing = false;
+				const openedAt = this.openedAt.get(id);
+				if (openedAt !== void 0) {
+					perfNow() - openedAt;
+					this.openedAt.delete(id);
+				}
+			}
+			const ready = pane.mode === "control" && pane.accepted && pane.baseline;
+			pane.writable = ready;
+			if (frame.full) pane.onState(ready ? "Input control is active." : pane.reason ?? "Read-only", ready);
+		});
+		pane.onState(pane.mode === "control" ? "Waiting for terminal control." : pane.reason ?? "Read-only", false);
+		this.openedAt.set(id, perfNow());
+		this.send({
+			type: "open",
+			streamId: id,
+			generation: pane.generation,
+			machineId: pane.machineId,
+			threadId: pane.threadId,
+			terminalId: pane.terminalId,
+			mode: pane.mode,
+			cols: pane.cols,
+			rows: pane.rows,
+			takeover
+		});
+	}
+	connect() {
+		if (this.stopped) return;
+		this.instance = uuid();
+		const epoch = ++this.epoch;
+		const base = (location.protocol === "https:" ? "wss://" : "ws://") + location.host;
+		const metadata = new WebSocket(base + "/api/ws/metadata?instance=" + this.instance);
+		const binary = new WebSocket(base + "/api/ws/terminal?instance=" + this.instance);
+		this.metadata = metadata;
+		this.binary = binary;
+		binary.binaryType = "arraybuffer";
+		const opened = () => {
+			if (epoch !== this.epoch || metadata.readyState !== 1 || binary.readyState !== 1) return;
+			this.connectedAt = Date.now();
+			this.onConnection(true);
+			for (const [id, pane] of this.panes) {
+				++pane.generation;
+				pane.sequence = new FrameSequence();
+				pane.attempts = 0;
+				this.open(id);
+			}
+		};
+		metadata.onopen = opened;
+		binary.onopen = opened;
+		metadata.onmessage = (event) => {
+			if (epoch !== this.epoch) return;
+			try {
+				const record = JSON.parse(event.data);
+				if (record.type === "projection") this.install(record.projection);
+			} catch {
+				this.disconnect();
+			}
+		};
+		binary.onmessage = (event) => {
+			if (epoch !== this.epoch) return;
+			try {
+				if (typeof event.data === "string") {
+					const record = JSON.parse(event.data);
+					const pane = this.panes.get(record.streamId);
+					if (!pane || pane.generation !== record.generation) return;
+					if (record.type === "stream.opened") {
+						pane.accepted = !!record.writable && pane.mode === "control";
+						if (pane.accepted) {
+							pane.baseline = false;
+							pane.resizing = true;
+							this.send({
+								type: "resize",
+								streamId: record.streamId,
+								generation: record.generation,
+								cols: pane.cols,
+								rows: pane.rows
+							});
+						}
+						pane.writable = pane.accepted && pane.baseline;
+						pane.onState(pane.writable ? "Input control is active." : pane.reason ?? (pane.accepted ? "Waiting for the full baseline; input is disabled." : "Read-only"), pane.writable);
+					}
+					if (record.type === "stream.closed" || record.type === "stream.error") {
+						pane.writable = false;
+						pane.accepted = false;
+						pane.baseline = false;
+						pane.renderer?.close();
+						pane.onState(record.reason === "controller_conflict" ? conflictMessage : String(record.reason).replaceAll("_", " "), false);
+						if (record.type === "stream.error" && pane.mode === "control") {
+							pane.reason = record.reason === "controller_conflict" ? conflictMessage : String(record.reason).replaceAll("_", " ");
+							pane.mode = "observe";
+							++pane.generation;
+							pane.sequence = new FrameSequence();
+							this.open(record.streamId);
+							return;
+						}
+						if (record.reason === "stream_resync_required" && pane.attempts++ < 2) {
+							++pane.generation;
+							pane.sequence = new FrameSequence();
+							pane.mode = "observe";
+							this.open(record.streamId);
+						}
+					}
+					return;
+				}
+				const decodeStart = perfNow();
+				const frame = decodeFrame(new Uint8Array(event.data));
+				event.data.byteLength;
+				perfNow() - decodeStart;
+				const typedAt = this.inputSentAt.get(frame.streamId);
+				if (typedAt !== void 0) {
+					perfNow() - typedAt;
+					this.inputSentAt.delete(frame.streamId);
+				}
+				const scrolledAt = this.scrollSentAt.get(frame.streamId);
+				if (scrolledAt !== void 0) {
+					perfNow() - scrolledAt;
+					this.scrollSentAt.delete(frame.streamId);
+				}
+				const pane = this.panes.get(frame.streamId);
+				if (!pane || pane.generation !== frame.generation) return;
+				pane.sequence.accept(frame);
+				++pane.pending;
+				pane.pending;
+				pane.renderer?.push(frame);
+			} catch {
+				this.disconnect();
+			}
+		};
+		const lost = () => {
+			if (epoch === this.epoch) this.disconnect();
+		};
+		metadata.onclose = lost;
+		metadata.onerror = lost;
+		binary.onclose = lost;
+		binary.onerror = lost;
+	}
+	disconnect() {
+		if (this.connectedAt && Date.now() - this.connectedAt >= 3e4) this.failures = 0;
+		this.connectedAt = 0;
+		++this.epoch;
+		this.metadata?.close();
+		this.binary?.close();
+		this.metadata = void 0;
+		this.binary = void 0;
+		this.onConnection(false);
+		for (const pane of this.panes.values()) {
+			pane.renderer?.close();
+			pane.writable = false;
+			pane.mode = "observe";
+			pane.onState("Disconnected; input was not saved.", false);
+		}
+		clearTimeout(this.reconnect);
+		if (!this.stopped) this.reconnect = setTimeout(() => this.connect(), retryDelay(this.failures++));
+	}
+};
+//#endregion
+//#region src/client/provider.tsx
+var Context = createContext(null);
+function RuntimeProvider({ bootstrap, children }) {
+	const [value] = useState(() => {
+		const runtime = createRuntimeStore(bootstrap);
+		return {
+			runtime,
+			ui: createUiStore(),
+			terminals: new BrowserTerminalManager((projection) => {
+				const done = span("projectionInstallMs");
+				runtime.getState().install(projection);
+				done();
+			}, (connected) => runtime.getState().connection(connected))
+		};
+	});
+	const [query] = useState(() => new QueryClient({ defaultOptions: { queries: {
+		staleTime: 15e3,
+		retry: false
+	} } }));
+	useEffect(() => {
+		value.terminals.start();
+		return () => value.terminals.stop();
+	}, [value]);
+	return /* @__PURE__ */ jsx(Context.Provider, {
+		value,
+		children: /* @__PURE__ */ jsx(QueryClientProvider, {
+			client: query,
+			children
+		})
+	});
+}
+function useRuntime() {
+	const value = useContext(Context);
+	if (!value) throw new Error("Runtime provider is missing");
+	return value;
+}
+function useRuntimeSelector(selector) {
+	return useStore(useRuntime().runtime, selector);
+}
+//#endregion
+//#region src/components/TerminalInput.tsx
+var specialKeys = {
+	Enter: "\r",
+	Backspace: "",
+	Tab: "	",
+	Escape: "\x1B",
+	ArrowUp: "\x1B[A",
+	ArrowDown: "\x1B[B",
+	ArrowRight: "\x1B[C",
+	ArrowLeft: "\x1B[D"
+};
+function terminalKeyBytes(event) {
+	const bytes = event.ctrlKey && /^[a-z]$/i.test(event.key) ? String.fromCharCode(event.key.toUpperCase().charCodeAt(0) - 64) : specialKeys[event.key];
+	const newlineInsteadOfSubmit = event.key === "Enter" && event.shiftKey;
+	return bytes && (event.altKey || newlineInsteadOfSubmit ? "\x1B" + bytes : bytes);
+}
+var controlCharacter = (text) => /^[a-z@\[\\\]^_]$/i.test(text) ? String.fromCharCode(text.toUpperCase().charCodeAt(0) & 31) : void 0;
+function TerminalInput({ onInput, onFocusChange }) {
+	const [draft, setDraft] = useState("");
+	const composing = useRef(false);
+	const committed = useRef(null);
+	return /* @__PURE__ */ jsx("textarea", {
+		className: "terminal-input-capture",
+		value: draft,
+		"aria-label": "Terminal input",
+		rows: 1,
+		onFocus: () => onFocusChange?.(true),
+		onBlur: () => onFocusChange?.(false),
+		onCompositionStart: () => {
+			composing.current = true;
+			committed.current = null;
+		},
+		onCompositionEnd: (event) => {
+			composing.current = false;
+			const text = event.data;
+			committed.current = text;
+			if (text) onInput(text);
+			setDraft("");
+			event.currentTarget.value = "";
+		},
+		onChange: (event) => {
+			if (composing.current) {
+				setDraft(event.target.value);
+				return;
+			}
+			const text = event.target.value;
+			if (text && text !== committed.current) onInput(text);
+			committed.current = null;
+			setDraft("");
+			event.currentTarget.value = "";
+		},
+		onPaste: (event) => {
+			event.preventDefault();
+			committed.current = null;
+			const text = event.clipboardData.getData("text/plain");
+			if (text) onInput(text, true);
+		},
+		onKeyDown: (event) => {
+			if (event.defaultPrevented || event.nativeEvent.isComposing || composing.current || event.metaKey) return;
+			committed.current = null;
+			const bytes = terminalKeyBytes(event);
+			if (bytes) {
+				event.preventDefault();
+				onInput(bytes);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/components/TerminalKeyBar.tsx
+var keys = [
+	{
+		label: "Tab",
+		key: "Tab"
+	},
+	{
+		label: /* @__PURE__ */ jsx(ArrowLeft, { size: 16 }),
+		key: "ArrowLeft",
+		name: "Left"
+	},
+	{
+		label: /* @__PURE__ */ jsx(ArrowDown, { size: 16 }),
+		key: "ArrowDown",
+		name: "Down"
+	},
+	{
+		label: /* @__PURE__ */ jsx(ArrowUp, { size: 16 }),
+		key: "ArrowUp",
+		name: "Up"
+	},
+	{
+		label: /* @__PURE__ */ jsx(ArrowRight, { size: 16 }),
+		key: "ArrowRight",
+		name: "Right"
+	}
+];
+var keepKeyboardOpen = (event) => event.preventDefault();
+function TerminalKeyBar({ ctrl, onToggleCtrl, onBytes }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "terminal-key-bar",
+		role: "toolbar",
+		"aria-label": "Terminal keys",
+		children: [/* @__PURE__ */ jsx("button", {
+			type: "button",
+			tabIndex: -1,
+			"aria-pressed": ctrl,
+			className: ctrl ? "is-armed" : "",
+			onPointerDown: keepKeyboardOpen,
+			onClick: onToggleCtrl,
+			children: "Ctrl"
+		}), keys.map(({ label, key, name }) => /* @__PURE__ */ jsx("button", {
+			type: "button",
+			tabIndex: -1,
+			"aria-label": name ?? key,
+			onPointerDown: keepKeyboardOpen,
+			onClick: () => {
+				const bytes = terminalKeyBytes({
+					key,
+					ctrlKey: false,
+					altKey: false
+				});
+				if (bytes) onBytes(bytes);
+			},
+			children: label
+		}, key))]
+	});
+}
+//#endregion
+//#region src/client/visual-viewport.ts
+var COARSE_POINTER = "(pointer: coarse)";
+function trackVisualViewport() {
+	const viewport = window.visualViewport;
+	if (!viewport || !matchMedia(COARSE_POINTER).matches) return () => {};
+	const root = document.documentElement;
+	const sync = () => {
+		root.style.setProperty("--app-height", `${viewport.height}px`);
+		root.style.setProperty("--app-top", `${viewport.offsetTop}px`);
+	};
+	sync();
+	viewport.addEventListener("resize", sync);
+	viewport.addEventListener("scroll", sync);
+	return () => {
+		viewport.removeEventListener("resize", sync);
+		viewport.removeEventListener("scroll", sync);
+		root.style.removeProperty("--app-height");
+		root.style.removeProperty("--app-top");
+	};
+}
+function matchesCoarsePointer() {
+	return typeof matchMedia === "function" && matchMedia(COARSE_POINTER).matches;
+}
+//#endregion
+//#region src/client/terminal-gestures.ts
+var MAX_LINES_PER_MESSAGE = 100;
+var FALLBACK_CELL_HEIGHT = 20;
+var SCROLL_SPEED = 10;
+var flickGain = (pixels) => SCROLL_SPEED * (1 + Math.min(2, Math.abs(pixels) / 60));
+function bindTerminalGestures(host, screen, control, writable) {
+	const pointer = (event) => {
+		if (!writable() || !event.altKey || event.shiftKey) return;
+		const { element, cols, rows } = screen();
+		const rect = element?.getBoundingClientRect();
+		if (!rect?.width || !rect.height) return;
+		const column = Math.floor((event.clientX - rect.left) / rect.width * cols);
+		const row = Math.floor((event.clientY - rect.top) / rect.height * rows);
+		if (column < 0 || row < 0 || column >= cols || row >= rows) return;
+		event.preventDefault();
+		const button = event.button === 2 || event.buttons & 2 ? "right" : event.button === 1 || event.buttons & 4 ? "middle" : "left";
+		control()?.mouse(event.type === "pointerdown" ? "down" : event.type === "pointerup" ? "up" : event.buttons ? "drag" : "move", button, column, row, event.ctrlKey ? 2 : 0);
+	};
+	let pendingPixels = 0;
+	let frame = 0;
+	let pointerCell;
+	const cellUnderPointer = (event) => {
+		const { element, cols, rows } = screen();
+		const rect = element?.getBoundingClientRect();
+		if (!rect?.width || !rect.height) return void 0;
+		return {
+			column: Math.min(cols, Math.max(1, Math.floor((event.clientX - rect.left) / rect.width * cols) + 1)),
+			row: Math.min(rows, Math.max(1, Math.floor((event.clientY - rect.top) / rect.height * rows) + 1))
+		};
+	};
+	const cellHeight = () => {
+		const { element, rows } = screen();
+		const height = element?.getBoundingClientRect().height;
+		return height && rows ? height / rows : FALLBACK_CELL_HEIGHT;
+	};
+	const flushScroll = () => {
+		frame = 0;
+		const cell = cellHeight();
+		const lines = Math.trunc(pendingPixels / cell);
+		if (!lines) return;
+		pendingPixels -= lines * cell;
+		control()?.scroll(lines < 0 ? "up" : "down", Math.min(MAX_LINES_PER_MESSAGE, Math.abs(lines)), pointerCell?.column, pointerCell?.row);
+	};
+	const wheel = (event) => {
+		if (!writable() || !event.deltaY) return;
+		pointerCell = cellUnderPointer(event);
+		event.preventDefault();
+		const pixels = event.deltaMode === WheelEvent.DOM_DELTA_LINE ? event.deltaY * cellHeight() : event.deltaY;
+		if (pixels * pendingPixels < 0) pendingPixels = 0;
+		pendingPixels += pixels * flickGain(pixels);
+		frame ||= requestAnimationFrame(flushScroll);
+	};
+	for (const type of [
+		"pointerdown",
+		"pointerup",
+		"pointermove"
+	]) host.addEventListener(type, pointer);
+	host.addEventListener("wheel", wheel, { passive: false });
+	return () => {
+		for (const type of [
+			"pointerdown",
+			"pointerup",
+			"pointermove"
+		]) host.removeEventListener(type, pointer);
+		host.removeEventListener("wheel", wheel);
+		cancelAnimationFrame(frame);
+	};
+}
+//#endregion
+//#region src/components/useImageAttachments.ts
+var ONLY_IMAGES = "Only PNG, JPEG, GIF and WebP images can be attached.";
+var attachingLabel = (count) => count === 1 ? "Attaching image…" : `Attaching ${count} images…`;
+var attachedLabel = (count) => count === 1 ? "Image attached" : `${count} images attached`;
+function useImageAttachments({ machineId, active, writable, send, show }) {
+	const [dragging, setDragging] = useState(false);
+	const sendRef = useRef(send);
+	sendRef.current = send;
+	const attach = useCallback(async (files) => {
+		if (!files.length) {
+			show(ONLY_IMAGES, "error", 4e3);
+			return;
+		}
+		if (!writable.current) {
+			show("Wait until the terminal accepts input, then attach the image again.", "error", 4e3);
+			return;
+		}
+		show(attachingLabel(files.length), "info");
+		try {
+			sendRef.current(await uploadImagesAsTerminalText(machineId, files));
+			show(attachedLabel(files.length), "info", 1500);
+		} catch (error) {
+			show(error instanceof Error ? error.message : "The image could not be attached.", "error", 5e3);
+		}
+	}, [
+		machineId,
+		show,
+		writable
+	]);
+	useEffect(() => {
+		if (!active) return;
+		let depth = 0;
+		const enter = (event) => {
+			if (!carriesFiles(event.dataTransfer)) return;
+			event.preventDefault();
+			depth += 1;
+			setDragging(true);
+		};
+		const over = (event) => {
+			if (!carriesFiles(event.dataTransfer)) return;
+			event.preventDefault();
+			if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+		};
+		const leave = (event) => {
+			if (!carriesFiles(event.dataTransfer)) return;
+			depth = Math.max(0, depth - 1);
+			if (!depth) setDragging(false);
+		};
+		const drop = (event) => {
+			if (!carriesFiles(event.dataTransfer)) return;
+			event.preventDefault();
+			depth = 0;
+			setDragging(false);
+			attach(imageFilesFrom(event.dataTransfer));
+		};
+		window.addEventListener("dragenter", enter);
+		window.addEventListener("dragover", over);
+		window.addEventListener("dragleave", leave);
+		window.addEventListener("drop", drop);
+		return () => {
+			window.removeEventListener("dragenter", enter);
+			window.removeEventListener("dragover", over);
+			window.removeEventListener("dragleave", leave);
+			window.removeEventListener("drop", drop);
+			setDragging(false);
+		};
+	}, [active, attach]);
+	return {
+		dragging,
+		attach
+	};
+}
+//#endregion
+//#region src/client/terminal-links.ts
+function openLinkOnModifierClick(event, uri) {
+	if (!event.metaKey && !event.ctrlKey) return;
+	window.open(uri, "_blank", "noopener,noreferrer");
+}
+//#endregion
+//#region src/components/useTerminalNotice.ts
+function useTerminalNotice() {
+	const [notice, setNotice] = useState(null);
+	const hide = useRef(void 0);
+	const show = useCallback((text, tone, durationMs) => {
+		clearTimeout(hide.current);
+		setNotice({
+			text,
+			tone
+		});
+		if (durationMs) hide.current = setTimeout(() => setNotice(null), durationMs);
+	}, []);
+	useEffect(() => () => clearTimeout(hide.current), []);
+	return {
+		notice,
+		show
+	};
+}
+//#endregion
+//#region src/components/TerminalPane.tsx
+function themeColors() {
+	const styles = getComputedStyle(document.documentElement);
+	return {
+		background: styles.getPropertyValue("--terminal-bg").trim(),
+		foreground: styles.getPropertyValue("--terminal-ink").trim(),
+		cursor: styles.getPropertyValue("--terminal-cursor").trim(),
+		selectionBackground: styles.getPropertyValue("--terminal-selection").trim(),
+		black: "#222222",
+		red: "#df7774",
+		green: "#8ebea1",
+		yellow: "#d4b581",
+		blue: "#81aee0",
+		magenta: "#ac9dd5",
+		cyan: "#8dc6cf",
+		white: "#d5d5d5",
+		brightBlack: "#777777",
+		brightRed: "#f18f89",
+		brightGreen: "#a1d8b6",
+		brightYellow: "#eed1a2",
+		brightBlue: "#a7c7ef",
+		brightMagenta: "#c6b6e8",
+		brightCyan: "#abdee4",
+		brightWhite: "#ffffff"
+	};
+}
+var TERMINAL_FONT_FAMILY = "\"JetBrains Mono\", \"Webr Symbols\", ui-monospace, Menlo, monospace";
+var TERMINAL_FONT_SIZE = 13;
+var loadTerminalFonts = () => typeof document === "undefined" || !document.fonts ? Promise.resolve() : Promise.all([
+	document.fonts.load(`400 ${TERMINAL_FONT_SIZE}px "JetBrains Mono"`),
+	document.fonts.load(`700 ${TERMINAL_FONT_SIZE}px "JetBrains Mono"`),
+	document.fonts.load(`${TERMINAL_FONT_SIZE}px "Webr Symbols"`, "")
+]).then(() => void 0, () => void 0);
+var FOCUS_IN = "\x1B[I";
+var FOCUS_OUT = "\x1B[O";
+function TerminalPane({ pane, machineId, threadId, active, canControl, onFocus }) {
+	const host = useRef(null);
+	const section = useRef(null);
+	const term = useRef(null);
+	const control = useRef(null);
+	const { terminals } = useRuntime();
+	const [message, setMessage] = useState("Connecting…");
+	const [writable, setWritable] = useState(false);
+	const writableRef = useRef(false);
+	const [inputFocused, setInputFocused] = useState(false);
+	const [ctrl, setCtrl] = useState(false);
+	const [touch, setTouch] = useState(false);
+	useEffect(() => setTouch(matchesCoarsePointer()), []);
+	const { notice, show } = useTerminalNotice();
+	const images = useImageAttachments({
+		machineId,
+		active,
+		writable: writableRef,
+		show,
+		send: (text) => {
+			control.current?.input(text, true);
+		}
+	});
+	const showCopyResult = useRef((copied) => {});
+	showCopyResult.current = (copied) => copied ? show("Copied to clipboard", "info", 1200) : show("The browser blocked clipboard access.", "error", 4e3);
+	useEffect(() => {
+		if (!host.current) return;
+		let disposed = false;
+		let cleanup = () => {};
+		Promise.all([
+			import("@xterm/xterm"),
+			import("@xterm/addon-fit"),
+			import("@xterm/addon-web-links"),
+			loadTerminalFonts()
+		]).then(([xterm, { FitAddon }, { WebLinksAddon }]) => {
+			if (disposed || !host.current) return;
+			const terminal = new xterm.Terminal({
+				fontFamily: TERMINAL_FONT_FAMILY,
+				fontSize: TERMINAL_FONT_SIZE,
+				lineHeight: 1.2,
+				letterSpacing: 0,
+				cursorBlink: true,
+				cursorInactiveStyle: "block",
+				allowTransparency: false,
+				scrollback: 0,
+				theme: themeColors(),
+				disableStdin: true,
+				linkHandler: { activate: () => {} }
+			});
+			terminal.open(host.current);
+			terminal.attachCustomWheelEventHandler(() => false);
+			term.current = terminal;
+			const redirectFocus = () => {
+				if (writableRef.current) host.current?.parentElement?.querySelector(".terminal-input-capture")?.focus();
+			};
+			terminal.textarea?.addEventListener("focus", redirectFocus);
+			const clipboard = bindTerminalClipboard(host.current, terminal, () => writableRef.current, (copied) => showCopyResult.current(copied));
+			const links = terminal.parser.registerOscHandler(8, () => true);
+			if (!pane.terminalId) {
+				clipboard();
+				terminal.dispose();
+				return;
+			}
+			const fit = new FitAddon();
+			terminal.loadAddon(fit);
+			terminal.loadAddon(new WebLinksAddon(openLinkOnModifierClick));
+			const estimatedViewport = () => ({
+				cols: Math.floor((host.current?.clientWidth ?? 640) / 8),
+				rows: Math.floor((host.current?.clientHeight ?? 400) / 20)
+			});
+			const measuredViewport = () => {
+				try {
+					return fit.proposeDimensions();
+				} catch {
+					return;
+				}
+			};
+			const viewport = () => {
+				const { cols, rows } = measuredViewport() ?? estimatedViewport();
+				return {
+					cols: Math.max(2, Math.min(500, cols)),
+					rows: Math.max(1, Math.min(300, rows))
+				};
+			};
+			control.current = terminals.mount({
+				machineId,
+				threadId,
+				terminalId: pane.terminalId,
+				terminal,
+				mode: canControl ? "control" : "observe",
+				...viewport(),
+				onState: (message, writable) => {
+					setMessage(message);
+					setWritable(writable);
+					writableRef.current = writable;
+				}
+			});
+			const gestures = bindTerminalGestures(host.current, () => ({
+				element: terminal.element?.querySelector(".xterm-screen") ?? void 0,
+				cols: terminal.cols,
+				rows: terminal.rows
+			}), () => control.current, () => writableRef.current);
+			let timer;
+			const resize = new ResizeObserver(() => {
+				clearTimeout(timer);
+				timer = setTimeout(() => {
+					const { cols, rows } = viewport();
+					control.current?.resize(cols, rows);
+				}, 150);
+			});
+			resize.observe(host.current);
+			const claimSize = () => {
+				if (document.visibilityState !== "visible" || !document.hasFocus()) return;
+				const { cols, rows } = viewport();
+				control.current?.resize(cols, rows, true);
+			};
+			window.addEventListener("focus", claimSize);
+			document.addEventListener("visibilitychange", claimSize);
+			const colorObserver = new MutationObserver(() => {
+				terminal.options.theme = themeColors();
+			});
+			colorObserver.observe(document.documentElement, {
+				attributes: true,
+				attributeFilter: ["data-theme"]
+			});
+			cleanup = () => {
+				clearTimeout(timer);
+				control.current?.close();
+				control.current = null;
+				writableRef.current = false;
+				gestures();
+				window.removeEventListener("focus", claimSize);
+				document.removeEventListener("visibilitychange", claimSize);
+				terminal.textarea?.removeEventListener("focus", redirectFocus);
+				clipboard();
+				links.dispose();
+				resize.disconnect();
+				colorObserver.disconnect();
+				terminal.dispose();
+				term.current = null;
+			};
+		}).catch(() => setMessage("The terminal could not load."));
+		return () => {
+			disposed = true;
+			cleanup();
+		};
+	}, [
+		pane.id,
+		pane.terminalId,
+		machineId,
+		threadId,
+		terminals,
+		canControl
+	]);
+	const sendInput = (text, paste) => {
+		if (!writableRef.current) return;
+		if (!ctrl || paste) {
+			control.current?.input(text, paste);
+			return;
+		}
+		setCtrl(false);
+		control.current?.input(controlCharacter(text) ?? text);
+	};
+	const showCursorAsFocused = () => term.current?.focus();
+	const focusInput = () => {
+		if (!writable || term.current?.hasSelection()) return;
+		showCursorAsFocused();
+		host.current?.parentElement?.querySelector(".terminal-input-capture")?.focus();
+	};
+	useEffect(() => {
+		if (active) focusInput();
+	}, [active, writable]);
+	useEffect(() => {
+		if (term.current) term.current.options.cursorInactiveStyle = active ? "block" : "outline";
+	}, [active, writable]);
+	useEffect(() => {
+		if (!active || !writable) return;
+		const unfocused = (event) => event.target === document.body || event.target === document.documentElement || section.current?.contains(event.target);
+		const onKeyDown = (event) => {
+			if (event.defaultPrevented || event.metaKey || event.isComposing || !unfocused(event) || event.target.classList?.contains("terminal-input-capture")) return;
+			const bytes = terminalKeyBytes(event);
+			if (bytes) {
+				event.preventDefault();
+				event.stopPropagation();
+				control.current?.input(bytes);
+			} else if (event.key.length === 1 && !event.ctrlKey) focusInput();
+		};
+		const onPaste = (event) => {
+			const fromInput = event.target.classList?.contains("terminal-input-capture");
+			if (!unfocused(event) && !fromInput) return;
+			const pastedImages = imageFilesFrom(event.clipboardData);
+			if (pastedImages.length) {
+				event.preventDefault();
+				event.stopPropagation();
+				images.attach(pastedImages);
+				return;
+			}
+			const text = event.clipboardData?.getData("text/plain");
+			if (!text || fromInput) return;
+			event.preventDefault();
+			event.stopPropagation();
+			control.current?.input(text, true);
+		};
+		window.addEventListener("keydown", onKeyDown, true);
+		window.addEventListener("paste", onPaste, true);
+		return () => {
+			window.removeEventListener("keydown", onKeyDown, true);
+			window.removeEventListener("paste", onPaste, true);
+		};
+	}, [
+		active,
+		writable,
+		images.attach
+	]);
+	useEffect(() => {
+		const refocus = () => {
+			if (active) focusInput();
+		};
+		window.addEventListener("focus", refocus);
+		return () => window.removeEventListener("focus", refocus);
+	}, [active, writable]);
+	return /* @__PURE__ */ jsxs("section", {
+		ref: section,
+		className: `terminal-pane ${active ? "is-active" : ""}`,
+		"aria-label": `${pane.title} terminal`,
+		onPointerDownCapture: () => {
+			if (!active) onFocus();
+		},
+		onFocusCapture: () => {
+			if (!active) onFocus();
+		},
+		onClick: () => {
+			if (canControl && !writableRef.current) control.current?.control();
+			focusInput();
+		},
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "terminal-status",
+				role: "status",
+				children: message
+			}),
+			message === "Another controller owns this terminal." && /* @__PURE__ */ jsxs("div", {
+				className: "terminal-control-conflict",
+				children: ["Another Herdr client controls this terminal.", /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: (event) => {
+						event.stopPropagation();
+						confirmDialog("Replace the other Herdr client that controls this terminal? Its input stops working.", { confirmLabel: "Take over" }).then((accepted) => {
+							if (accepted) control.current?.control(true);
+						});
+					},
+					children: "Take over"
+				})]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				ref: host,
+				className: "terminal-host"
+			}),
+			images.dragging && /* @__PURE__ */ jsxs("div", {
+				className: "terminal-drop-overlay",
+				"aria-hidden": "true",
+				children: [/* @__PURE__ */ jsx(ImagePlus, {
+					size: 22,
+					strokeWidth: 1.6
+				}), /* @__PURE__ */ jsx("span", { children: "Drop image to attach" })]
+			}),
+			notice && /* @__PURE__ */ jsx("div", {
+				className: `terminal-attach-notice is-${notice.tone}`,
+				role: notice.tone === "error" ? "alert" : "status",
+				children: notice.text
+			}),
+			(canControl || writable) && /* @__PURE__ */ jsx(TerminalInput, {
+				onInput: sendInput,
+				onFocusChange: (focused) => {
+					setInputFocused(focused);
+					if (term.current?.modes.sendFocusMode) control.current?.input(focused ? FOCUS_IN : FOCUS_OUT);
+				}
+			}),
+			canControl && active && touch && inputFocused && /* @__PURE__ */ jsx(TerminalKeyBar, {
+				ctrl,
+				onToggleCtrl: () => setCtrl((armed) => !armed),
+				onBytes: (bytes) => control.current?.input(bytes)
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/AdoptTab.tsx
+function AdoptTab({ thread, tabs }) {
+	const [tabId, setTabId] = useState("");
+	const [error, setError] = useState("");
+	const [busy, setBusy] = useState(false);
+	const selected = tabs.find((tab) => tab.tabId === tabId && !tab.bound);
+	return /* @__PURE__ */ jsxs("form", {
+		className: "adoption-picker",
+		onSubmit: async (event) => {
+			event.preventDefault();
+			if (!selected || busy) return;
+			setBusy(true);
+			if (!await confirmDialog(`Bind this thread to ${selected.label} (${selected.tabId}) and its ${selected.panes.length} current terminals without sending the old prompt?`, { confirmLabel: "Bind" })) {
+				setBusy(false);
+				return;
+			}
+			setError("");
+			try {
+				if (!(await fetch(`/api/threads/${encodeURIComponent(thread.id)}/adopt`, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						machineId: thread.machineId,
+						terminalIds: selected.panes.map((pane) => pane.terminalId)
+					})
+				})).ok) throw new Error("The tab changed or is already bound; select it again after refresh.");
+			} catch (error) {
+				setError(error instanceof Error ? error.message : "Adoption failed.");
+			} finally {
+				setBusy(false);
+			}
+		},
+		children: [
+			/* @__PURE__ */ jsxs("label", { children: ["Select the current native tab to adopt ", /* @__PURE__ */ jsxs("select", {
+				"aria-label": "Native tab to adopt",
+				value: tabId,
+				onChange: (event) => setTabId(event.target.value),
+				children: [/* @__PURE__ */ jsx("option", {
+					value: "",
+					children: "Select a tab…"
+				}), tabs.map((tab) => /* @__PURE__ */ jsxs("option", {
+					value: tab.tabId,
+					disabled: tab.bound || !tab.panes.length,
+					children: [
+						tab.label,
+						" · ",
+						tab.tabId,
+						tab.bound ? " · Already bound" : ""
+					]
+				}, tab.tabId))]
+			})] }),
+			selected && /* @__PURE__ */ jsx("p", { children: selected.panes.map((pane) => `${pane.title} (${pane.terminalId})`).join(", ") }),
+			/* @__PURE__ */ jsx("button", {
+				disabled: !selected || busy,
+				children: "Adopt without restarting"
+			}),
+			error && /* @__PURE__ */ jsx("p", {
+				role: "alert",
+				children: error
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/LaunchProgress.tsx
+function LaunchProgress({ thread }) {
+	const failed = launchFailed(thread);
+	const current = launchStepIndex(thread.operation?.step ?? "validate");
+	return /* @__PURE__ */ jsxs("main", {
+		className: "launch-progress",
+		"aria-label": "Launch progress",
+		role: "status",
+		children: [
+			/* @__PURE__ */ jsx("h1", { children: failed ? "The launch stopped" : "Starting your agent" }),
+			/* @__PURE__ */ jsx("blockquote", {
+				className: "launch-prompt",
+				children: thread.prompt || thread.title
+			}),
+			/* @__PURE__ */ jsx("ol", {
+				className: "launch-steps",
+				children: launchSteps.map((step, index) => {
+					const state = index < current ? "done" : index === current ? failed ? "failed" : "active" : "waiting";
+					const Icon = state === "done" ? CircleCheck : state === "failed" ? CircleAlert : state === "active" ? LoaderCircle : Circle;
+					return /* @__PURE__ */ jsxs("li", {
+						className: `launch-step is-${state}`,
+						"aria-current": state === "active" ? "step" : void 0,
+						children: [/* @__PURE__ */ jsx(Icon, {
+							size: 16,
+							strokeWidth: 1.8,
+							"aria-hidden": "true"
+						}), step.label]
+					}, step.id);
+				})
+			}),
+			failed && /* @__PURE__ */ jsxs("div", {
+				className: "launch-failure",
+				role: "alert",
+				children: [/* @__PURE__ */ jsxs("p", { children: [
+					"Herdr stopped while ",
+					launchSteps[current].label.toLowerCase(),
+					". The worktree may already exist, so check it in Herdr before you try again."
+				] }), /* @__PURE__ */ jsx("a", {
+					className: "launch-retry",
+					href: `/new?project=${encodeURIComponent(thread.projectId)}`,
+					children: "Start a new thread"
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/components/ThreadView.tsx
+var PEEK_SIZE = "28px";
+var besidePeek = (side) => side === "right" ? {
+	left: 0,
+	top: 0,
+	width: `calc(100% - ${PEEK_SIZE})`,
+	height: "100%"
+} : {
+	left: 0,
+	top: 0,
+	width: "100%",
+	height: `calc(100% - ${PEEK_SIZE})`
+};
+function TerminalPeek({ side, onOpen }) {
+	return /* @__PURE__ */ jsx(Tooltip$1, {
+		label: "Show terminal",
+		side: side === "right" ? "left" : "top",
+		children: /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: `terminal-peek is-${side}`,
+			"aria-label": "Show terminal",
+			onClick: onOpen,
+			children: [/* @__PURE__ */ jsx(TerminalSquare, {
+				size: 14,
+				strokeWidth: 1.8,
+				"aria-hidden": "true"
+			}), /* @__PURE__ */ jsx("span", { children: "Terminal" })]
+		})
+	});
+}
+function ThreadView({ thread, layouts, tabs, connected, canControl, onFocusPane, focusedPane, onToggleTerminal }) {
+	const pane = (item, style) => /* @__PURE__ */ jsx("div", {
+		className: "native-pane-position",
+		style,
+		children: /* @__PURE__ */ jsx(TerminalPane, {
+			pane: item,
+			machineId: thread.machineId,
+			threadId: thread.id,
+			active: focusedPane === item.id,
+			canControl,
+			onFocus: () => onFocusPane(item.id)
+		})
+	}, `${item.id}:${item.terminalId}`);
+	if (connected && (isLaunching(thread) || launchFailed(thread))) return /* @__PURE__ */ jsx(LaunchProgress, { thread });
+	const visibleLayouts = layouts.filter((layout) => layout.panes.some((rect) => thread.panes.some((pane) => pane.id === rect.paneId)));
+	return /* @__PURE__ */ jsxs("main", {
+		className: "native-thread-layout",
+		"aria-label": `${thread.title} tab`,
+		children: [
+			(!connected || thread.bindingState !== "attached") && /* @__PURE__ */ jsx("p", {
+				className: "runtime-notice",
+				role: "status",
+				children: !connected ? "Disconnected; input is disabled." : thread.bindingState === "detached" ? "The saved terminal is not present; explicit adoption is required." : "Waiting for the terminal to attach…"
+			}),
+			connected && thread.bindingState === "attached" && !canControl && /* @__PURE__ */ jsx("p", {
+				className: "runtime-notice",
+				role: "status",
+				children: "Terminal input is unavailable because this Herdr version is not supported."
+			}),
+			connected && thread.bindingState === "detached" && /* @__PURE__ */ jsx(AdoptTab, {
+				thread,
+				tabs
+			}, thread.id),
+			connected && thread.bindingState === "attached" && visibleLayouts.map((layout) => {
+				const hidden = hiddenTerminalLayout(thread, layout);
+				const split = !hidden && layout.panes.filter((rect) => thread.panes.some((item) => item.id === rect.paneId)).length > 1;
+				return /* @__PURE__ */ jsx("div", {
+					className: `native-pane-layout ${split ? "is-split" : ""}`,
+					children: hidden ? [pane(hidden.agent, besidePeek(hidden.side)), /* @__PURE__ */ jsx(TerminalPeek, {
+						side: hidden.side,
+						onOpen: onToggleTerminal
+					}, "terminal-peek")] : thread.panes.map((item) => {
+						const rect = layout.panes.find((rect) => rect.paneId === item.id)?.rect;
+						if (!rect || !layout.area.width || !layout.area.height) return null;
+						return pane(item, {
+							left: `${(rect.x - layout.area.x) / layout.area.width * 100}%`,
+							top: `${(rect.y - layout.area.y) / layout.area.height * 100}%`,
+							width: `${rect.width / layout.area.width * 100}%`,
+							height: `${rect.height / layout.area.height * 100}%`
+						});
+					})
+				}, `${layout.workspaceId}:${layout.tabId}`);
+			})
+		]
+	});
+}
+//#endregion
+//#region src/client/keyboard.ts
+function appShortcutAction(event, shortcuts) {
+	if (event.repeat || event.defaultPrevented || event.isComposing) return;
+	const target = event.target;
+	if (target?.closest("[data-recording=\"true\"]")) return;
+	if (target?.closest("input, textarea, select, [contenteditable=\"true\"]") && !target.closest(".xterm, .terminal-input-capture")) return;
+	return Object.entries(shortcuts).find(([, combo]) => combo === keyCombo(event))?.[0];
+}
+//#endregion
+//#region src/client/clear-done-on-visit.ts
+function useClearDoneOnVisit(thread, paneId, enabled) {
+	const isDone = thread?.status === "done";
+	useEffect(() => {
+		if (!thread || !paneId || !isDone || !enabled) return;
+		fetch(`/api/threads/${encodeURIComponent(thread.id)}/focus`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				machineId: thread.machineId,
+				paneId
+			})
+		}).catch(() => void 0);
+	}, [
+		thread?.id,
+		thread?.machineId,
+		paneId,
+		isDone,
+		enabled
+	]);
+}
+//#endregion
+//#region src/components/App.tsx
+function App(props) {
+	return /* @__PURE__ */ jsx(CrashReport, { children: /* @__PURE__ */ jsx(RuntimeProvider, {
+		bootstrap: props.bootstrap,
+		children: /* @__PURE__ */ jsx(RuntimeApp, { ...props })
+	}) });
+}
+function RuntimeApp({ page, bootstrap, threadId, projectId }) {
+	const { ui, terminals } = useRuntime();
+	const projects = useRuntimeSelector(useShallow((state) => state.projectIds.map((id) => state.projects[id])));
+	const threads = useRuntimeSelector(useShallow((state) => state.threadIds.map((id) => state.threads[id]).filter((item) => !item.archivedAt && isListedThread(item))));
+	const archived = useRuntimeSelector(useShallow((state) => state.threadIds.map((id) => state.threads[id]).filter((item) => !!item.archivedAt)));
+	const thread = useRuntimeSelector((state) => state.threads[threadId ?? ""]);
+	const projections = useRuntimeSelector((state) => state.projections);
+	const gatewayConnected = useRuntimeSelector((state) => state.connected);
+	const machines = Object.values(projections).flatMap((projection) => {
+		const machine = projection.machine ?? bootstrap.machines.find((machine) => machine.id === projection.machineId);
+		return machine ? [{
+			...machine,
+			connected: gatewayConnected && projection.connected,
+			error: projection.error
+		}] : [];
+	});
+	const [collapsed, setCollapsed] = useState(false);
+	const [mobileOpen, setMobileOpen] = useState(false);
+	const [paletteOpen, setPaletteOpen] = useState(false);
+	useEffect(startPerf, []);
+	useEffect(trackVisualViewport, []);
+	const [mode, setMode] = useState("threads");
+	const scope = `${thread?.machineId ?? ""}:${thread?.id ?? ""}`;
+	const storedFocus = useStore(ui, (state) => state.focusedPanes[scope]);
+	const focusedPane = thread?.panes.some((pane) => pane.id === storedFocus) ? storedFocus : thread?.panes[0]?.id ?? "";
+	const setFocusedPane = useCallback((paneId) => ui.getState().focus(scope, paneId), [ui, scope]);
+	useClearDoneOnVisit(page === "thread" ? thread : void 0, focusedPane, gatewayConnected && !!machines.find((machine) => machine.id === thread?.machineId)?.writable);
+	const shownThreadId = useRef(void 0);
+	useEffect(() => {
+		if (thread) shownThreadId.current = thread.id;
+		else if (page === "thread" && shownThreadId.current === threadId) navigate("/");
+	}, [
+		thread,
+		page,
+		threadId
+	]);
+	useEffect(() => {
+		const keepFileDropsInsideTheApp = (event) => {
+			if (carriesFiles(event.dataTransfer)) event.preventDefault();
+		};
+		window.addEventListener("dragover", keepFileDropsInsideTheApp);
+		window.addEventListener("drop", keepFileDropsInsideTheApp);
+		return () => {
+			window.removeEventListener("dragover", keepFileDropsInsideTheApp);
+			window.removeEventListener("drop", keepFileDropsInsideTheApp);
+		};
+	}, []);
+	useEffect(() => {
+		const syncCollapsedFromUrl = () => setCollapsed(new URLSearchParams(window.location.search).get("sidebar") === "collapsed");
+		syncCollapsedFromUrl();
+		window.addEventListener("popstate", syncCollapsedFromUrl);
+		setMode(localStorage.getItem("webr-sidebar-mode") === "projects" ? "projects" : "threads");
+		const media = matchMedia("(prefers-color-scheme: dark)");
+		const onChange = () => {
+			if ((localStorage.getItem("webr-theme") ?? "system") === "system") applyTheme("system");
+		};
+		media.addEventListener("change", onChange);
+		return () => {
+			media.removeEventListener("change", onChange);
+			window.removeEventListener("popstate", syncCollapsedFromUrl);
+		};
+	}, []);
+	const layouts = thread ? projections[thread.machineId]?.layouts ?? [] : [];
+	const reportTerminalFailure = (error) => void alertDialog(error instanceof Error ? error.message : "Herdr could not change the terminal.");
+	const toggleTerminal = useCallback((direction) => {
+		if (!thread) return;
+		const chosen = direction ?? currentTerminalDirection(thread, layouts, window.matchMedia("(max-width: 760px)").matches);
+		toggleThreadTerminal(thread, chosen).then(({ paneId, hidden }) => setFocusedPane(hidden ? threadAgent(thread)?.id ?? paneId : paneId), reportTerminalFailure);
+	}, [
+		thread,
+		layouts,
+		setFocusedPane
+	]);
+	const focusPane = useCallback((paneId) => {
+		if (thread?.terminalHidden && threadShell(thread)?.id === paneId) toggleTerminal();
+		else setFocusedPane(paneId);
+	}, [
+		thread,
+		toggleTerminal,
+		setFocusedPane
+	]);
+	const closeTerminal = useCallback(() => {
+		if (!thread) return;
+		closeThreadTerminal(thread).then(() => {
+			const agent = threadAgent(thread);
+			if (agent) setFocusedPane(agent.id);
+		}, reportTerminalFailure);
+	}, [thread, setFocusedPane]);
+	const toggleSidebar = useCallback(() => {
+		if (window.matchMedia("(max-width: 760px)").matches) {
+			setMobileOpen((value) => !value);
+			return;
+		}
+		setCollapsed((value) => {
+			const next = !value;
+			const url = new URL(window.location.href);
+			if (next) url.searchParams.set("sidebar", "collapsed");
+			else url.searchParams.delete("sidebar");
+			window.history.replaceState(window.history.state, "", url);
+			return next;
+		});
+	}, []);
+	const changeMode = useCallback((value) => {
+		setMode(value);
+		localStorage.setItem("webr-sidebar-mode", value);
+	}, []);
+	useEffect(() => {
+		const onKey = (event) => {
+			if (event.repeat || event.isComposing) return;
+			if (event.target?.closest("[data-recording=\"true\"]")) return;
+			if (event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey && event.key.toLowerCase() === "k") {
+				event.preventDefault();
+				setPaletteOpen((value) => !value);
+				return;
+			}
+			if (paletteOpen || event.defaultPrevented) return;
+			const action = appShortcutAction(event, getShortcuts());
+			if (!action) return;
+			event.preventDefault();
+			if (action === "toggleSidebar") toggleSidebar();
+			if (action === "toggleTerminal") toggleTerminal();
+			if (action === "newThread") navigate(`/new${thread ? `?project=${encodeURIComponent(thread.projectId)}` : ""}`);
+			if ((action === "nextPane" || action === "previousPane") && thread?.panes.length) {
+				const index = thread.panes.findIndex((pane) => pane.id === focusedPane);
+				focusPane(thread.panes[(index + (action === "nextPane" ? 1 : -1) + thread.panes.length) % thread.panes.length].id);
+			}
+			if ((action === "nextThread" || action === "previousThread") && threads.length) {
+				const index = threads.findIndex((item) => item.id === thread?.id);
+				const next = action === "nextThread" ? (index + 1) % threads.length : (index - 1 + threads.length) % threads.length;
+				navigate(`/threads/${encodeURIComponent(threads[next].id)}`);
+			}
+		};
+		window.addEventListener("keydown", onKey, true);
+		return () => window.removeEventListener("keydown", onKey, true);
+	}, [
+		thread,
+		threads,
+		paletteOpen,
+		toggleSidebar,
+		toggleTerminal,
+		focusPane,
+		focusedPane,
+		setFocusedPane
+	]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: `app-shell ${page === "thread" ? "is-thread" : ""}`,
+		children: [
+			/* @__PURE__ */ jsx(Sidebar, {
+				projects,
+				threads,
+				archived,
+				machines,
+				currentId: thread?.id,
+				mode,
+				onModeChange: changeMode,
+				collapsed,
+				mobileOpen,
+				onCollapse: toggleSidebar,
+				onCloseMobile: () => setMobileOpen(false),
+				onOpenPalette: () => setPaletteOpen(true)
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "main-panel",
+				children: [
+					page === "thread" && thread && /* @__PURE__ */ jsx(ThreadView, {
+						thread,
+						layouts: projections[thread.machineId]?.layouts ?? [],
+						tabs: projections[thread.machineId]?.availableTabs ?? [],
+						connected: gatewayConnected && !!projections[thread.machineId]?.connected,
+						canControl: !!machines.find((machine) => machine.id === thread.machineId)?.writable,
+						focusedPane,
+						onFocusPane: focusPane,
+						onToggleTerminal: () => toggleTerminal()
+					}),
+					page === "new" && /* @__PURE__ */ jsx(NewThreadView, {
+						projects,
+						machines,
+						selectedProjectId: projectId,
+						onOpenSidebar: toggleSidebar
+					}),
+					page === "settings" && /* @__PURE__ */ jsx(SettingsView, { onOpenSidebar: toggleSidebar }),
+					page === "missing" && /* @__PURE__ */ jsxs("main", {
+						className: "not-found",
+						children: [/* @__PURE__ */ jsx("h1", { children: "Thread not found" }), /* @__PURE__ */ jsx("a", {
+							href: "/",
+							children: "Open a thread"
+						})]
+					})
+				]
+			}),
+			page === "thread" && /* @__PURE__ */ jsxs("div", {
+				className: "mobile-controls",
+				children: [/* @__PURE__ */ jsx("button", {
+					"aria-label": "Open sidebar",
+					onClick: toggleSidebar,
+					children: /* @__PURE__ */ jsx(PanelLeft, { size: 16 })
+				}), /* @__PURE__ */ jsx("button", {
+					"aria-label": "Open command palette",
+					onClick: () => setPaletteOpen(true),
+					children: /* @__PURE__ */ jsx(Search, { size: 16 })
+				})]
+			}),
+			false,
+			/* @__PURE__ */ jsx(PairingPrompt, {}),
+			/* @__PURE__ */ jsx(CommandPalette, {
+				open: paletteOpen,
+				onClose: () => setPaletteOpen(false),
+				projects,
+				threads,
+				thread,
+				focusedPane,
+				mode,
+				onModeChange: changeMode,
+				onToggleSidebar: toggleSidebar,
+				onFocusPane: focusPane,
+				onTerminalAction: (action) => {
+					const pane = thread?.panes.find((pane) => pane.id === focusedPane);
+					if (thread && pane?.terminalId) terminals.command(thread.machineId, thread.id, pane.terminalId, action);
+				},
+				onToggleTerminal: toggleTerminal,
+				onCloseTerminal: closeTerminal
+			})
+		]
+	});
+}
+//#endregion
+export { $$Base as n, App as t };