@wular/coder 0.4.2 → 0.4.4

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/frame/loading-card.9648c7782502babc.js

@@ -0,0 +1,64 @@
+import { iDown, iSearch } from "../ui/icons.e17bdd0b5504787f.js";
+import { Card, Loading } from "../ui/card.e6876039e375b849.js";
+import { Icon } from "../ui/icon.93605083edf7efe3.js";
+import { Toolbar } from "../ui/toolbar.32503820243ede06.js";
+import { jsx as _jsx, jsxs as _jsxs } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+export const BLANK = "\xA0";
+/** `Loading` inside the box its data fills, titled as that box. */
+export function LoadingCard({ title, label, h }) {
+	return /* @__PURE__ */ _jsx(Card, {
+		title,
+		children: /* @__PURE__ */ _jsx(Loading, {
+			label,
+			h
+		})
+	});
+}
+/** A list's toolbar while the list loads: the same title and controls, inert until the list is live. */
+export function LoadingToolbar({ head, search, selects = [], more, action }) {
+	return /* @__PURE__ */ _jsxs(Toolbar, {
+		head,
+		action: action ? /* @__PURE__ */ _jsxs("button", {
+			type: "button",
+			class: "btn",
+			disabled: true,
+			children: [/* @__PURE__ */ _jsx(Icon, { d: action.icon }), action.label]
+		}) : undefined,
+		children: [
+			/* @__PURE__ */ _jsxs("label", {
+				class: "search",
+				"aria-hidden": "true",
+				children: [/* @__PURE__ */ _jsx(Icon, { d: iSearch }), /* @__PURE__ */ _jsx("input", {
+					type: "search",
+					placeholder: search,
+					disabled: true,
+					tabIndex: -1
+				})]
+			}),
+			selects.map((label) => /* @__PURE__ */ _jsx("span", {
+				class: "select",
+				"aria-hidden": "true",
+				children: /* @__PURE__ */ _jsxs("button", {
+					type: "button",
+					disabled: true,
+					tabIndex: -1,
+					children: [/* @__PURE__ */ _jsx("span", {
+						class: "grow",
+						children: label
+					}), /* @__PURE__ */ _jsx(Icon, { d: iDown })]
+				})
+			}, label)),
+			more ? /* @__PURE__ */ _jsx("span", {
+				class: "menu filter-more",
+				"aria-hidden": "true",
+				children: /* @__PURE__ */ _jsx("button", {
+					type: "button",
+					class: "field-btn",
+					disabled: true,
+					tabIndex: -1,
+					children: "Filter"
+				})
+			}) : null
+		]
+	});
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/frame/page-head.857951b5dc1ad827.js

@@ -0,0 +1,65 @@
+import "./page-head.53db3a3d313c0473.css.pnext-asset.js";
+import { iLeft } from "../ui/icons.e17bdd0b5504787f.js";
+import { Link } from "../../../../../../../node_modules/@wular/pnext/src/api/link.tsx";
+import { HEADS } from "./heads.5407f7793f985b16.js";
+import { Icon } from "../ui/icon.93605083edf7efe3.js";
+import { Sentinel } from "../ui/sentinel.50afec82b0fd53a1.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+export function Page({ narrow, children }) {
+	return /* @__PURE__ */ _jsx("div", {
+		class: narrow ? "page narrow" : "page",
+		children
+	});
+}
+/** A same-origin `/dash` path from a `back` search param, named for its agent or section, or nothing. */
+function backTo(back) {
+	if (!back?.startsWith("/")) return;
+	const url = new URL(back, "http://dash");
+	if (url.origin !== "http://dash" || !/^\/dash(\/|$)/.test(url.pathname)) return;
+	const [, , section, slug] = url.pathname.split("/");
+	let label = HEADS[section]?.title ?? "Back";
+	if (section === "agents" && slug) try {
+		label = decodeURIComponent(slug);
+	} catch {}
+	return {
+		to: {
+			href: url.pathname,
+			search: url.searchParams
+		},
+		label
+	};
+}
+/** Back to the logical parent, wherever the visitor came from; a `back` search param wins. */
+export function Back({ label, back, ...to }) {
+	const param = backTo(back);
+	const name = param?.label ?? label;
+	return /* @__PURE__ */ _jsxs(Link, {
+		class: "back",
+		"aria-label": name,
+		...param?.to ?? to,
+		children: [/* @__PURE__ */ _jsx(Icon, { d: iLeft }), /* @__PURE__ */ _jsx("span", { children: name })]
+	});
+}
+/** The page title row with its meta and actions, and one muted lead line; it sticks under the top bar and turns compact there. */
+export function PageHead({ title, lead, actions, meta, back }) {
+	return /* @__PURE__ */ _jsxs(_Fragment, { children: [/* @__PURE__ */ _jsx(Sentinel, {}), /* @__PURE__ */ _jsxs("header", {
+		class: "head",
+		children: [/* @__PURE__ */ _jsxs("div", { children: [
+			back,
+			/* @__PURE__ */ _jsxs("div", {
+				class: "title-row",
+				children: [/* @__PURE__ */ _jsx("h1", { children: title }), meta ? /* @__PURE__ */ _jsx("div", {
+					class: "meta",
+					children: meta
+				}) : null]
+			}),
+			lead ? /* @__PURE__ */ _jsx("p", {
+				class: "lead",
+				children: lead
+			}) : null
+		] }), actions ? /* @__PURE__ */ _jsx("div", {
+			class: "actions",
+			children: actions
+		}) : null]
+	})] });
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/frame/stream.4c04416dab6ffc52.js

@@ -0,0 +1,39 @@
+import { Suspense } from "../../../../../../../node_modules/preact/compat/dist/compat.mjs";
+import { signedOut } from "../../api/load.bdbf17006af803d1.js";
+import { Card } from "../ui/card.e6876039e375b849.js";
+import { reasonText } from "../../utils/format.ba382c381ea40e77.js";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+/** A section that waits for `load`, under the route's loading frame; a failure stays inside it. */
+export async function Settle({ load }) {
+	try {
+		return await load();
+	} catch (error) {
+		return /* @__PURE__ */ _jsx(SectionFailure, { error });
+	}
+}
+/** A section that streams in behind its loading box; `load` runs when it renders, and a failure stays inside. */
+export function Stream({ fallback, load }) {
+	return /* @__PURE__ */ _jsx(Suspense, {
+		fallback,
+		children: /* @__PURE__ */ _jsx(Settle, { load })
+	});
+}
+function SectionFailure({ error }) {
+	return /* @__PURE__ */ _jsx(Card, {
+		tone: "danger",
+		title: "Could not load this",
+		children: /* @__PURE__ */ _jsx("p", {
+			class: "body prose",
+			children: signedOut(error) ? /* @__PURE__ */ _jsxs(_Fragment, { children: [
+				"Your session ended.",
+				" ",
+				/* @__PURE__ */ _jsx("a", {
+					class: "link",
+					href: "/login",
+					children: "Sign in again"
+				}),
+				"."
+			] }) : reasonText(error)
+		})
+	});
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/frame/task-toasts.b14bb1f66ed75e75.js

@@ -0,0 +1,324 @@
+"use client";
+import "./@/comps/ui/toast.8d599c6821860a1c.css.pnext-asset.js";
+import { useEffect, useRef, useState } from "../../../../../../../node_modules/preact/hooks/dist/hooks.mjs";
+import { serverEvents } from "../../../../client/index.2feb1c162fab6033.js";
+import { client } from "../../utils/client.f37a313f4811ddb8.js";
+import { Link } from "../../../../../../../node_modules/@wular/pnext/src/api/link.tsx";
+import { usePathname, useRouter } from "../../../../../../../node_modules/@wular/pnext/src/api/client-navigation.ts";
+import { Status, STATUS_LABEL } from "../../app/dash/tasks/list/status.d78e769ff1411932.js";
+import { jsx as _jsx, jsxs as _jsxs } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+const WATCHED = "coder:watched";
+export const NOTIFY = "coder:notify";
+const TOAST = "coder:toast";
+const DONE = new Set([
+	"completed",
+	"failed",
+	"cancelled"
+]);
+const SHOWN = new Set([...DONE, "waiting"]);
+const KEEP = 20;
+const MAX = 3;
+const TTL = 8e3;
+// The Web Lock that picks the one tab holding the events stream, and the channel it shares them on.
+const EVENTS = "coder:events";
+const TASK = "coder:task";
+const REPLAY = "coder:task-replay";
+const RESET = "coder:task-reset";
+const RESYNC = "coder:task-resync";
+// A write that commits past the server's look-back still reaches shown pages within this, through a fresh read.
+const RESYNC_MS = 6e4;
+// Latest events a tab keeps, so a page that mounts later starts from them.
+const LATEST = 200;
+const read = () => {
+	try {
+		return JSON.parse(localStorage.getItem(WATCHED) ?? "{}") ?? {};
+	} catch {
+		return {};
+	}
+};
+const save = (all) => {
+	const kept = Object.entries(all).sort(([, a], [, b]) => b.at - a.at).slice(0, KEEP);
+	localStorage.setItem(WATCHED, JSON.stringify(Object.fromEntries(kept)));
+	dispatchEvent(new Event(WATCHED));
+};
+/** A toast for an action whose page has no room for its outcome. */
+export const showToast = (title, line, err) => dispatchEvent(new CustomEvent(TOAST, { detail: {
+	title,
+	line,
+	err
+} }));
+export const toastError = (title, line) => showToast(title, line, true);
+/** Remembers a task this browser started or opened, so its finish shows a toast on any page. */
+export function watchTask(id, status, title) {
+	const all = read();
+	const entry = all[id];
+	if (!entry && DONE.has(status)) return;
+	if (entry?.status === status && (!title || entry.title === title)) return;
+	all[id] = {
+		title: title || entry?.title || id,
+		status,
+		at: entry?.at ?? Date.now()
+	};
+	save(all);
+}
+const openTask = (path) => /^\/dash\/tasks\/([^/]+)$/.exec(path)?.[1];
+function lineOf(live) {
+	const text = (value) => typeof value === "string" ? value.trim().split("\n")[0] : "";
+	const approval = live.approval ?? {};
+	const result = typeof live.result === "object" ? live.result?.output : live.result;
+	if (live.status === "waiting") return text(approval.summary) || text(approval.reason) || text(approval.kind) || "It is waiting for your approval.";
+	if (live.status === "completed") return text(result) || "It finished.";
+	return text(live.error) || (live.status === "failed" ? "It failed." : "It was stopped.");
+}
+/** Hears every task change from this browser's one events stream; `reset` when some may have been missed, `resync` once a minute to read again. */
+export function useTaskEvents(on, reset, resync) {
+	const handler = useRef({
+		on,
+		reset,
+		resync
+	});
+	handler.current = {
+		on,
+		reset,
+		resync
+	};
+	useEffect(() => {
+		const listener = (event) => handler.current.on(event.detail);
+		const again = () => handler.current.reset?.();
+		const read = () => handler.current.resync?.();
+		addEventListener(TASK, listener);
+		addEventListener(RESET, again);
+		addEventListener(RESYNC, read);
+		dispatchEvent(new CustomEvent(REPLAY, { detail: (event) => handler.current.on(event) }));
+		return () => {
+			removeEventListener(TASK, listener);
+			removeEventListener(RESET, again);
+			removeEventListener(RESYNC, read);
+		};
+	}, []);
+}
+/** One events stream per browser: the tab holding the lock reads it, shares it on a channel, and a tab that takes over resumes from the last event id. */
+function useEventsStream(ids, leading) {
+	const asked = useRef(ids);
+	asked.current = ids;
+	const current = useRef();
+	const key = [...ids].sort().join(",");
+	useEffect(() => {
+		const latest = new Map();
+		const deliver = (event) => {
+			latest.delete(event.id);
+			latest.set(event.id, event);
+			if (latest.size > LATEST) latest.delete(latest.keys().next().value);
+			dispatchEvent(new CustomEvent(TASK, { detail: event }));
+		};
+		const replay = (event) => {
+			for (const each of latest.values()) event.detail(each);
+		};
+		addEventListener(REPLAY, replay);
+		const channel = typeof BroadcastChannel !== "undefined" && navigator.locks ? new BroadcastChannel(EVENTS) : undefined;
+		const abort = new AbortController();
+		let last;
+		let wake = () => {};
+		let soon;
+		const receive = (message) => {
+			last = message.id ?? last;
+			if (message.event) deliver(message.event);
+			if (message.resync) dispatchEvent(new Event(RESYNC));
+			if (!message.reset) return;
+			latest.clear();
+			dispatchEvent(new Event(RESET));
+		};
+		channel?.addEventListener("message", ({ data }) => {
+			if (!data.hello) return receive(data);
+			// A tab that just loaded, maybe into another workspace: the next stream resumes for it too.
+			soon ??= setTimeout(() => {
+				soon = undefined;
+				current.current?.abort.abort();
+				wake();
+			}, 300);
+		});
+		channel?.postMessage({ hello: true });
+		const lead = async () => {
+			leading.current = true;
+			const resync = setInterval(() => {
+				channel?.postMessage({ resync: true });
+				receive({ resync: true });
+			}, RESYNC_MS);
+			try {
+				await follow();
+			} finally {
+				clearInterval(resync);
+			}
+		};
+		const follow = async () => {
+			while (!abort.signal.aborted) {
+				const once = new AbortController();
+				const stop = () => once.abort();
+				abort.signal.addEventListener("abort", stop);
+				const ids = asked.current;
+				current.current = {
+					key: [...ids].sort().join(","),
+					abort: once
+				};
+				let wait = 1e3;
+				try {
+					const response = await client.tasks.events(ids, last, once.signal);
+					// A server without the events stream: nothing to follow.
+					if (response.status === 404) return void (leading.current = false);
+					// Signed out: a tab that signs in again wakes the next try.
+					if (!response.ok || !response.body) wait = [401, 403].includes(response.status) ? 6e4 : 5e3;
+					else for await (const { event, data, id } of serverEvents(response.body)) {
+						// A stream replaced by the next one says nothing more.
+						if (once.signal.aborted) break;
+						const message = {
+							...id ? { id } : {},
+							...event === "task" ? { event: JSON.parse(data) } : {},
+							...event === "reset" ? { reset: true } : {}
+						};
+						channel?.postMessage(message);
+						receive(message);
+					}
+				} catch {}
+				abort.signal.removeEventListener("abort", stop);
+				// A new task set opens the next stream at once.
+				if (once.signal.aborted) continue;
+				await new Promise((done) => {
+					const timer = setTimeout(done, wait);
+					wake = () => {
+						clearTimeout(timer);
+						done();
+					};
+				});
+				wake = () => {};
+			}
+		};
+		if (channel) void navigator.locks.request(EVENTS, { signal: abort.signal }, lead).catch(() => {});
+		else void lead();
+		return () => {
+			abort.abort();
+			wake();
+			clearTimeout(soon);
+			channel?.close();
+			removeEventListener(REPLAY, replay);
+		};
+	}, []);
+	useEffect(() => {
+		if (current.current && current.current.key !== key) current.current.abort.abort();
+	}, [key]);
+}
+function Item({ toast, dismiss }) {
+	useEffect(() => {
+		const timer = setTimeout(() => dismiss(toast.key), TTL);
+		return () => clearTimeout(timer);
+	}, []);
+	return /* @__PURE__ */ _jsxs("div", {
+		class: toast.err ? "toast err" : "toast",
+		onClick: () => dismiss(toast.key),
+		children: [/* @__PURE__ */ _jsxs("p", {
+			class: "toast-head",
+			children: [toast.id ? /* @__PURE__ */ _jsx(Link, {
+				class: "cover",
+				href: "/dash/tasks/[id]",
+				params: { id: toast.id },
+				children: toast.title
+			}) : /* @__PURE__ */ _jsx("span", {
+				class: "cover",
+				children: toast.title
+			}), toast.status ? /* @__PURE__ */ _jsx(Status, { status: toast.status }) : null]
+		}), /* @__PURE__ */ _jsx("p", {
+			class: "toast-line",
+			children: toast.line
+		})]
+	});
+}
+/** Toasts at the bottom right when a watched task finishes or needs approval, except on its own page. */
+export function TaskToasts() {
+	const path = usePathname();
+	const nav = useRouter();
+	const [watched, setWatched] = useState({});
+	const [toasts, setToasts] = useState([]);
+	const open = useRef(openTask(path));
+	open.current = openTask(path);
+	// Each tab's own last status per task, so every tab toasts a change once.
+	const known = useRef({});
+	const leading = useRef(false);
+	useEffect(() => {
+		const sync = () => {
+			const all = read();
+			for (const [id, entry] of Object.entries(all)) known.current[id] ??= entry.status;
+			setWatched(all);
+		};
+		sync();
+		addEventListener(WATCHED, sync);
+		addEventListener("storage", sync);
+		return () => {
+			removeEventListener(WATCHED, sync);
+			removeEventListener("storage", sync);
+		};
+	}, []);
+	useEffect(() => {
+		const onToast = (event) => {
+			const detail = event.detail;
+			setToasts((list) => [{
+				key: `${TOAST}:${Date.now()}`,
+				...detail
+			}, ...list].slice(0, MAX));
+		};
+		addEventListener(TOAST, onToast);
+		return () => removeEventListener(TOAST, onToast);
+	}, []);
+	useEffect(() => {
+		if (!toasts.length) return;
+		const onKey = (event) => event.key === "Escape" && setToasts([]);
+		addEventListener("keydown", onKey);
+		return () => removeEventListener("keydown", onKey);
+	}, [toasts.length]);
+	const dismiss = (key) => setToasts((list) => list.filter((toast) => toast.key !== key));
+	useTaskEvents((event) => {
+		const all = read();
+		const seen = all[event.id];
+		if (!seen) return;
+		if (event.deleted) {
+			delete all[event.id];
+			return save(all);
+		}
+		const before = known.current[event.id] ?? seen.status;
+		known.current[event.id] = event.status;
+		if (before !== event.status) onStatus(event.id, {
+			...event,
+			result: event.result ?? undefined,
+			error: event.error ?? undefined
+		}, seen);
+	});
+	const onStatus = (id, live, seen) => {
+		watchTask(id, live.status);
+		if (!SHOWN.has(live.status) || open.current === id) return;
+		const toast = {
+			key: `${id}:${Date.now()}`,
+			id,
+			title: seen.title,
+			status: live.status,
+			line: lineOf(live)
+		};
+		setToasts((list) => [toast, ...list].slice(0, MAX));
+		if (!leading.current || localStorage.getItem(NOTIFY) !== "1" || typeof Notification === "undefined" || Notification.permission !== "granted") return;
+		const notice = new Notification(`${toast.title} (${STATUS_LABEL[toast.status]})`, {
+			body: toast.line,
+			tag: id
+		});
+		notice.onclick = () => {
+			focus();
+			nav.push("/dash/tasks/[id]", { params: { id } });
+		};
+	};
+	useEventsStream(Object.entries(watched).filter(([, entry]) => !DONE.has(entry.status)).map(([id]) => id), leading);
+	return /* @__PURE__ */ _jsx("section", {
+		class: "toasts",
+		"aria-label": "Task updates",
+		"aria-live": "polite",
+		children: toasts.map((toast) => /* @__PURE__ */ _jsx(Item, {
+			toast,
+			dismiss
+		}, toast.key))
+	});
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/frame/theme-choices.60d3a5adbd49989f.js

@@ -0,0 +1,49 @@
+"use client";
+import { useState } from "../../../../../../../node_modules/preact/hooks/dist/hooks.mjs";
+import { iCheck, iMonitor, iMoon, iSun } from "../ui/icons.e17bdd0b5504787f.js";
+import { Icon } from "../ui/icon.93605083edf7efe3.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+const YEAR = 60 * 60 * 24 * 365;
+const THEMES = [
+	[
+		"light",
+		"Light",
+		iSun
+	],
+	[
+		"dark",
+		"Dark",
+		iMoon
+	],
+	[
+		"system",
+		"System",
+		iMonitor
+	]
+];
+/** The theme menu's choices; a pick applies at once and is kept in a cookie. */
+export function ThemeChoices({ theme: initial }) {
+	const [theme, setTheme] = useState(initial);
+	const pick = (value) => {
+		const root = document.documentElement;
+		if (value === "system") delete root.dataset.theme;
+		else root.dataset.theme = value;
+		document.cookie = `theme=${value}; path=/; max-age=${YEAR}; samesite=lax`;
+		setTheme(value);
+	};
+	return /* @__PURE__ */ _jsx(_Fragment, { children: THEMES.map(([value, label, icon]) => /* @__PURE__ */ _jsxs("button", {
+		type: "button",
+		class: "pop-item",
+		role: "menuitemradio",
+		"aria-checked": theme === value,
+		onClick: () => pick(value),
+		children: [
+			/* @__PURE__ */ _jsx(Icon, { d: icon }),
+			/* @__PURE__ */ _jsx("span", {
+				class: "grow",
+				children: label
+			}),
+			/* @__PURE__ */ _jsx(Icon, { d: iCheck })
+		]
+	}, value)) });
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/nav/current-link.87758179b507850c.js

@@ -0,0 +1,34 @@
+"use client";
+import { Link } from "../../../../../../../node_modules/@wular/pnext/src/api/link.tsx";
+import { useLayoutEffect, useRef } from "../../../../../../../node_modules/preact/hooks/dist/hooks.mjs";
+import { useLinkStatus, usePathname } from "../../../../../../../node_modules/@wular/pnext/src/api/client-navigation.ts";
+import { pathOf } from "./to.248665fde7daaf07.js";
+import { jsx as _jsx, jsxs as _jsxs } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+/** A link marked current when the address is its path, or under `within`. */
+export function CurrentLink({ within, children, onClick, ...link }) {
+	const at = usePathname();
+	const current = at === pathOf(link) || within !== undefined && (at === within || at.startsWith(`${within}/`));
+	const anchor = useRef(null);
+	return /* @__PURE__ */ _jsxs(Link, {
+		...link,
+		"aria-current": current ? "page" : undefined,
+		onClick: (event) => {
+			anchor.current = event.currentTarget;
+			onClick?.(event);
+		},
+		children: [children, /* @__PURE__ */ _jsx(PendingCurrent, {
+			anchor,
+			current
+		})]
+	});
+}
+// Link status belongs to a child of Link's context. A pending link marks itself, and CSS moves the underline there until the address catches up.
+function PendingCurrent({ anchor, current }) {
+	const { pending } = useLinkStatus();
+	useLayoutEffect(() => {
+		if (!anchor.current) return;
+		if (pending && !current) anchor.current.setAttribute("data-pending", "");
+		else anchor.current.removeAttribute("data-pending");
+	}, [pending, current]);
+	return null;
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/nav/side-toggle.581456c353d76d67.js

@@ -0,0 +1,36 @@
+"use client";
+import { useEffect, useState } from "../../../../../../../node_modules/preact/hooks/dist/hooks.mjs";
+import { iLeft, iRight } from "../ui/icons.e17bdd0b5504787f.js";
+import { Icon } from "../ui/icon.93605083edf7efe3.js";
+import { jsx as _jsx } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+const COOKIE = "side";
+/** Collapses the sidebar to its icons; a click is saved in a cookie so the next page renders that way at once. */
+export function SideToggle({ collapsed: initial }) {
+	const [collapsed, setCollapsed] = useState(initial);
+	// Without a saved choice the layout script collapses mid-width screens, so the label follows the class.
+	useEffect(() => {
+		const app = document.querySelector(".app");
+		if (!app) return;
+		const sync = () => setCollapsed(app.classList.contains("side-min"));
+		sync();
+		const watch = new MutationObserver(sync);
+		watch.observe(app, {
+			attributes: true,
+			attributeFilter: ["class"]
+		});
+		return () => watch.disconnect();
+	}, []);
+	const toggle = () => {
+		const next = !collapsed;
+		document.querySelector(".app")?.classList.toggle("side-min", next);
+		document.cookie = `${COOKIE}=${next ? "min" : "max"}; path=/; max-age=31536000; samesite=lax`;
+	};
+	return /* @__PURE__ */ _jsx("button", {
+		type: "button",
+		class: "icon-btn side-toggle",
+		"aria-label": collapsed ? "Expand sidebar" : "Collapse sidebar",
+		"data-tip": collapsed ? "Expand sidebar" : "Collapse sidebar",
+		onClick: toggle,
+		children: /* @__PURE__ */ _jsx(Icon, { d: collapsed ? iRight : iLeft })
+	});
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/nav/to.248665fde7daaf07.js

@@ -0,0 +1,11 @@
+/** The path a target resolves to, to compare with the address. */
+export const pathOf = (to) => {
+	const params = to.params ?? {};
+	return to.href.replace(/\[([^\]]+)\]/g, (_, key) => encodeURIComponent(String(params[key] ?? "")));
+};
+/** A query with some keys set on top of another. */
+export function withSearch(base, set) {
+	const search = new URLSearchParams(base instanceof URLSearchParams ? base : base);
+	for (const [key, value] of Object.entries(set)) search.set(key, value);
+	return search;
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/comps/ui/badge.e52db98d78836f9a.js

@@ -0,0 +1,31 @@
+import "./badge.d21391f2f8573db8.css.pnext-asset.js";
+import { jsx as _jsx } from "../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+export function Badge({ tone, title, children }) {
+	return /* @__PURE__ */ _jsx("span", {
+		class: tone ? `badge ${tone}` : "badge",
+		title,
+		children
+	});
+}
+export function Chips({ values }) {
+	const shown = values.filter((value) => Boolean(value));
+	if (!shown.length) return /* @__PURE__ */ _jsx("span", {
+		class: "muted",
+		children: "None"
+	});
+	return /* @__PURE__ */ _jsx("span", {
+		class: "chips",
+		children: shown.map((value) => /* @__PURE__ */ _jsx("span", {
+			class: "chip",
+			children: value
+		}, value))
+	});
+}
+/** A record's id: secondary, never a page's or row's label; the line it sits on clips it when space runs out. */
+export function Id({ value, title }) {
+	return /* @__PURE__ */ _jsx("span", {
+		class: "id",
+		title: title ?? value,
+		children: value
+	});
+}