@tangle-network/ui 11.10.0 → 11.11.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @tangle-network/ui
 
+## 11.11.0
+
+### Minor Changes
+
+- dc84d1c: Update every dependency to its latest release and build with tsdown on TypeScript 7.
+  `@tangle-network/ui` now accepts `@nanostores/react` 2 as a peer, moves to lucide-react 1 and marked 18, and drops the unused `react-pdf` and `@radix-ui/react-toast` dependencies.
+  Export paths are unchanged; internal chunk file names differ.
+
 ## 11.10.0
 
 ### Minor Changes

package/dist/active-sessions-store-Gt1R0rFG.js

@@ -0,0 +1,262 @@
+import { useMemo } from "react";
+import { useStore } from "@nanostores/react";
+import { atom } from "nanostores";
+//#region src/stores/active-sessions-store.ts
+const INITIAL_STATE = {
+	sessions: {},
+	lastUpdatedAt: 0
+};
+const STATUS_PRIORITY = {
+	running: 0,
+	error: 1,
+	"attention-needed": 2,
+	idle: 3
+};
+const DEFAULT_RECORD = {
+	status: "idle",
+	isRunning: false,
+	isForeground: false,
+	needsAttention: false,
+	connectionState: "disconnected",
+	reconnectState: "idle",
+	transportMode: null,
+	lastError: null,
+	lastEventAt: null
+};
+const activeSessionsAtom = atom(INITIAL_STATE);
+let foregroundSessionId = null;
+function createRecord(options, now) {
+	return {
+		sessionId: options.sessionId,
+		projectId: options.projectId ?? null,
+		projectLabel: options.projectLabel,
+		title: options.title,
+		href: options.href,
+		registeredAt: now,
+		lastActivityAt: now,
+		metadata: options.metadata,
+		...DEFAULT_RECORD,
+		isForeground: options.sessionId === foregroundSessionId
+	};
+}
+function resolveStatus(session) {
+	if (session.isRunning) return "running";
+	if (session.lastError || session.reconnectState === "failed") return "error";
+	if (session.needsAttention) return "attention-needed";
+	return "idle";
+}
+function normalizeSession(session) {
+	return {
+		...session,
+		status: resolveStatus(session)
+	};
+}
+function updateSession(sessionId, updater) {
+	const current = activeSessionsAtom.get();
+	const existing = current.sessions[sessionId];
+	if (!existing) return;
+	const now = Date.now();
+	activeSessionsAtom.set({
+		sessions: {
+			...current.sessions,
+			[sessionId]: normalizeSession(updater(existing, now))
+		},
+		lastUpdatedAt: now
+	});
+}
+function registerActiveSession(options) {
+	const now = Date.now();
+	const current = activeSessionsAtom.get();
+	const existing = current.sessions[options.sessionId];
+	activeSessionsAtom.set({
+		sessions: {
+			...current.sessions,
+			[options.sessionId]: normalizeSession(existing ? {
+				...existing,
+				projectId: existing.projectId ?? options.projectId ?? null,
+				projectLabel: options.projectLabel ?? existing.projectLabel,
+				title: options.title ?? existing.title,
+				href: options.href ?? existing.href,
+				metadata: options.metadata ?? existing.metadata,
+				lastActivityAt: now,
+				isForeground: options.sessionId === foregroundSessionId || existing.isForeground
+			} : createRecord(options, now))
+		},
+		lastUpdatedAt: now
+	});
+}
+function unregisterActiveSession(sessionId) {
+	const current = activeSessionsAtom.get();
+	if (!current.sessions[sessionId]) return;
+	const { [sessionId]: _removed, ...remaining } = current.sessions;
+	if (foregroundSessionId === sessionId) foregroundSessionId = null;
+	activeSessionsAtom.set({
+		sessions: remaining,
+		lastUpdatedAt: Date.now()
+	});
+}
+function setForegroundActiveSession(sessionId) {
+	foregroundSessionId = sessionId;
+	const current = activeSessionsAtom.get();
+	const now = Date.now();
+	let changed = false;
+	const sessions = Object.fromEntries(Object.entries(current.sessions).map(([id, session]) => {
+		const isForeground = id === sessionId;
+		if (session.isForeground !== isForeground) changed = true;
+		return [id, {
+			...session,
+			isForeground,
+			lastActivityAt: isForeground ? now : session.lastActivityAt
+		}];
+	}));
+	if (!changed) return;
+	activeSessionsAtom.set({
+		sessions,
+		lastUpdatedAt: now
+	});
+}
+function updateActiveSessionMeta(sessionId, meta) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		...meta,
+		lastActivityAt: now
+	}));
+}
+function setActiveSessionConnection(sessionId, options) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		connectionState: options.connectionState,
+		reconnectState: options.reconnectState ?? session.reconnectState,
+		transportMode: options.transportMode ?? session.transportMode,
+		lastError: options.lastError === void 0 ? session.lastError : options.lastError,
+		lastEventAt: options.lastEventAt ?? session.lastEventAt,
+		lastActivityAt: now
+	}));
+}
+function setActiveSessionRunning(sessionId, isRunning, options) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		isRunning,
+		needsAttention: isRunning ? false : session.needsAttention,
+		lastError: isRunning ? null : session.lastError,
+		lastEventAt: options?.lastEventAt ?? session.lastEventAt,
+		lastActivityAt: now
+	}));
+}
+function setActiveSessionAttention(sessionId, needsAttention, options) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		needsAttention,
+		isRunning: needsAttention ? false : session.isRunning,
+		lastEventAt: options?.lastEventAt ?? session.lastEventAt,
+		lastActivityAt: now
+	}));
+}
+function setActiveSessionError(sessionId, error) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		isRunning: false,
+		needsAttention: false,
+		lastError: error,
+		reconnectState: error ? "failed" : "idle",
+		connectionState: error ? "error" : session.connectionState,
+		lastEventAt: now,
+		lastActivityAt: now
+	}));
+}
+function bumpActiveSessionActivity(sessionId, options) {
+	updateSession(sessionId, (session, now) => ({
+		...session,
+		lastEventAt: options?.lastEventAt ?? session.lastEventAt ?? now,
+		lastActivityAt: now
+	}));
+}
+function resetActiveSessions() {
+	foregroundSessionId = null;
+	activeSessionsAtom.set(INITIAL_STATE);
+}
+function getAllActiveSessions(state) {
+	return Object.values(state.sessions);
+}
+function getActiveSession(state, sessionId) {
+	return state.sessions[sessionId] ?? null;
+}
+function getSessionsForProject(state, projectId) {
+	return Object.values(state.sessions).filter((session) => session.projectId === projectId);
+}
+function getSessionsForNavbar(state, projectId) {
+	return [...projectId == null ? Object.values(state.sessions) : getSessionsForProject(state, projectId)].sort((left, right) => {
+		if (left.isForeground !== right.isForeground) return Number(right.isForeground) - Number(left.isForeground);
+		const statusDiff = STATUS_PRIORITY[left.status] - STATUS_PRIORITY[right.status];
+		if (statusDiff !== 0) return statusDiff;
+		return right.lastActivityAt - left.lastActivityAt;
+	});
+}
+function getSessionsByActivity(state) {
+	return [...Object.values(state.sessions)].sort((left, right) => right.lastActivityAt - left.lastActivityAt);
+}
+function getTotalRunningSessionCount(state) {
+	return Object.values(state.sessions).filter((session) => session.isRunning).length;
+}
+function hasBackgroundRunningSessions(state) {
+	return Object.values(state.sessions).some((session) => session.isRunning && !session.isForeground);
+}
+function getAllProjectActivity(state) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const session of Object.values(state.sessions)) {
+		if (session.projectId == null) continue;
+		const existing = grouped.get(session.projectId);
+		if (existing) {
+			existing.activeSessionCount += 1;
+			existing.lastActivityAt = Math.max(existing.lastActivityAt, session.lastActivityAt);
+			if (session.isRunning) existing.runningSessionIds.push(session.sessionId);
+			if (!existing.projectLabel && session.projectLabel) existing.projectLabel = session.projectLabel;
+			continue;
+		}
+		grouped.set(session.projectId, {
+			projectId: session.projectId,
+			projectLabel: session.projectLabel,
+			activeSessionCount: 1,
+			runningSessionIds: session.isRunning ? [session.sessionId] : [],
+			lastActivityAt: session.lastActivityAt
+		});
+	}
+	return [...grouped.values()].sort((left, right) => right.lastActivityAt - left.lastActivityAt);
+}
+function useActiveSessionsState() {
+	return useStore(activeSessionsAtom);
+}
+function useActiveSessions() {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => getAllActiveSessions(state), [state]);
+}
+function useActiveSession(sessionId) {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => sessionId ? getActiveSession(state, sessionId) : null, [sessionId, state]);
+}
+function useProjectSessions(projectId) {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => projectId == null ? [] : getSessionsForProject(state, projectId), [projectId, state]);
+}
+function useNavbarSessions(projectId) {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => getSessionsForNavbar(state, projectId), [projectId, state]);
+}
+function useSessionsByActivity() {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => getSessionsByActivity(state), [state]);
+}
+function useProjectActivity() {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => getAllProjectActivity(state), [state]);
+}
+function useTotalRunningSessions() {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => getTotalRunningSessionCount(state), [state]);
+}
+function useHasBackgroundRunningSessions() {
+	const state = useStore(activeSessionsAtom);
+	return useMemo(() => hasBackgroundRunningSessions(state), [state]);
+}
+//#endregion
+export { useHasBackgroundRunningSessions as C, useSessionsByActivity as D, useProjectSessions as E, useTotalRunningSessions as O, useActiveSessionsState as S, useProjectActivity as T, setForegroundActiveSession as _, getAllProjectActivity as a, useActiveSession as b, getSessionsForProject as c, registerActiveSession as d, resetActiveSessions as f, setActiveSessionRunning as g, setActiveSessionError as h, getAllActiveSessions as i, getTotalRunningSessionCount as l, setActiveSessionConnection as m, bumpActiveSessionActivity as n, getSessionsByActivity as o, setActiveSessionAttention as p, getActiveSession as r, getSessionsForNavbar as s, activeSessionsAtom as t, hasBackgroundRunningSessions as u, unregisterActiveSession as v, useNavbarSessions as w, useActiveSessions as x, updateActiveSessionMeta as y };

package/dist/{active-sessions-store-CeOmXgv5.d.ts → active-sessions-store-nl70ZnMC.d.ts}

@@ -1,59 +1,58 @@
-import * as nanostores from 'nanostores';
-
+//#region src/stores/active-sessions-store.d.ts
 type SessionProjectKey = string | number;
 type ActiveSessionStatus = "idle" | "running" | "attention-needed" | "error";
 type ActiveSessionReconnectState = "idle" | "reconnecting" | "failed";
 type ActiveSessionConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "error";
 type ActiveSessionTransportMode = "websocket" | "sse" | "polling" | "custom";
 interface ActiveSessionRecord {
-    sessionId: string;
-    projectId: SessionProjectKey | null;
-    projectLabel?: string;
-    title?: string;
-    href?: string;
-    registeredAt: number;
-    lastActivityAt: number;
-    lastEventAt: number | null;
-    status: ActiveSessionStatus;
-    isRunning: boolean;
-    isForeground: boolean;
-    needsAttention: boolean;
-    connectionState: ActiveSessionConnectionState;
-    reconnectState: ActiveSessionReconnectState;
-    transportMode: ActiveSessionTransportMode | null;
-    lastError: string | null;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  projectId: SessionProjectKey | null;
+  projectLabel?: string;
+  title?: string;
+  href?: string;
+  registeredAt: number;
+  lastActivityAt: number;
+  lastEventAt: number | null;
+  status: ActiveSessionStatus;
+  isRunning: boolean;
+  isForeground: boolean;
+  needsAttention: boolean;
+  connectionState: ActiveSessionConnectionState;
+  reconnectState: ActiveSessionReconnectState;
+  transportMode: ActiveSessionTransportMode | null;
+  lastError: string | null;
+  metadata?: Record<string, unknown>;
 }
 interface ActiveSessionsState {
-    sessions: Record<string, ActiveSessionRecord>;
-    lastUpdatedAt: number;
+  sessions: Record<string, ActiveSessionRecord>;
+  lastUpdatedAt: number;
 }
 interface RegisterActiveSessionOptions {
-    sessionId: string;
-    projectId?: SessionProjectKey | null;
-    projectLabel?: string;
-    title?: string;
-    href?: string;
-    metadata?: Record<string, unknown>;
+  sessionId: string;
+  projectId?: SessionProjectKey | null;
+  projectLabel?: string;
+  title?: string;
+  href?: string;
+  metadata?: Record<string, unknown>;
 }
 interface ActiveSessionConnectionOptions {
-    connectionState: ActiveSessionConnectionState;
-    reconnectState?: ActiveSessionReconnectState;
-    transportMode?: ActiveSessionTransportMode | null;
-    lastError?: string | null;
-    lastEventAt?: number | null;
+  connectionState: ActiveSessionConnectionState;
+  reconnectState?: ActiveSessionReconnectState;
+  transportMode?: ActiveSessionTransportMode | null;
+  lastError?: string | null;
+  lastEventAt?: number | null;
 }
 interface ActiveSessionActivityOptions {
-    lastEventAt?: number | null;
+  lastEventAt?: number | null;
 }
 interface ActiveProjectActivity {
-    projectId: SessionProjectKey;
-    projectLabel?: string;
-    activeSessionCount: number;
-    runningSessionIds: string[];
-    lastActivityAt: number;
+  projectId: SessionProjectKey;
+  projectLabel?: string;
+  activeSessionCount: number;
+  runningSessionIds: string[];
+  lastActivityAt: number;
 }
-declare const activeSessionsAtom: nanostores.PreinitializedWritableAtom<ActiveSessionsState> & object;
+declare const activeSessionsAtom: import("nanostores").PreinitializedWritableAtom<ActiveSessionsState> & object;
 declare function registerActiveSession(options: RegisterActiveSessionOptions): void;
 declare function unregisterActiveSession(sessionId: string): void;
 declare function setForegroundActiveSession(sessionId: string | null): void;
@@ -81,5 +80,5 @@ declare function useSessionsByActivity(): ActiveSessionRecord[];
 declare function useProjectActivity(): ActiveProjectActivity[];
 declare function useTotalRunningSessions(): number;
 declare function useHasBackgroundRunningSessions(): boolean;
-
-export { type ActiveProjectActivity as A, updateActiveSessionMeta as B, useActiveSession as C, useActiveSessions as D, useActiveSessionsState as E, useHasBackgroundRunningSessions as F, useNavbarSessions as G, useProjectActivity as H, useProjectSessions as I, useSessionsByActivity as J, useTotalRunningSessions as K, type RegisterActiveSessionOptions as R, type SessionProjectKey as S, type ActiveSessionActivityOptions as a, type ActiveSessionConnectionOptions as b, type ActiveSessionConnectionState as c, type ActiveSessionReconnectState as d, type ActiveSessionRecord as e, type ActiveSessionStatus as f, type ActiveSessionTransportMode as g, type ActiveSessionsState as h, activeSessionsAtom as i, bumpActiveSessionActivity as j, getActiveSession as k, getAllActiveSessions as l, getAllProjectActivity as m, getSessionsByActivity as n, getSessionsForNavbar as o, getSessionsForProject as p, getTotalRunningSessionCount as q, hasBackgroundRunningSessions as r, registerActiveSession as s, resetActiveSessions as t, setActiveSessionAttention as u, setActiveSessionConnection as v, setActiveSessionError as w, setActiveSessionRunning as x, setForegroundActiveSession as y, unregisterActiveSession as z };
+//#endregion
+export { updateActiveSessionMeta as A, resetActiveSessions as C, setActiveSessionRunning as D, setActiveSessionError as E, useNavbarSessions as F, useProjectActivity as I, useProjectSessions as L, useActiveSessions as M, useActiveSessionsState as N, setForegroundActiveSession as O, useHasBackgroundRunningSessions as P, useSessionsByActivity as R, registerActiveSession as S, setActiveSessionConnection as T, getSessionsByActivity as _, ActiveSessionReconnectState as a, getTotalRunningSessionCount as b, ActiveSessionTransportMode as c, SessionProjectKey as d, activeSessionsAtom as f, getAllProjectActivity as g, getAllActiveSessions as h, ActiveSessionConnectionState as i, useActiveSession as j, unregisterActiveSession as k, ActiveSessionsState as l, getActiveSession as m, ActiveSessionActivityOptions as n, ActiveSessionRecord as o, bumpActiveSessionActivity as p, ActiveSessionConnectionOptions as r, ActiveSessionStatus as s, ActiveProjectActivity as t, RegisterActiveSessionOptions as u, getSessionsForNavbar as v, setActiveSessionAttention as w, hasBackgroundRunningSessions as x, getSessionsForProject as y, useTotalRunningSessions as z };

package/dist/artifact-pane-BL_DFWNl.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+//#region src/primitives/artifact-pane.d.ts
+interface ArtifactPaneProps {
+  eyebrow?: ReactNode;
+  title: ReactNode;
+  subtitle?: ReactNode;
+  meta?: ReactNode;
+  headerActions?: ReactNode;
+  tabs?: ReactNode;
+  toolbar?: ReactNode;
+  footer?: ReactNode;
+  emptyState?: ReactNode;
+  children?: ReactNode;
+  className?: string;
+  contentClassName?: string;
+  /** Extra classes for the header band (e.g. to align its surface with the host chrome). */
+  headerClassName?: string;
+  /**
+   * Suppress the eyebrow/title/subtitle/meta block. Use when the host already
+   * shows the artifact's identity elsewhere (e.g. a surrounding path row), so the
+   * pane keeps only its tabs, toolbar, and header actions. The whole header row
+   * collapses when nothing else would render in it.
+   */
+  hideTitleBlock?: boolean;
+}
+/**
+ * ArtifactPane — shared frame for files, previews, documents, inspectors, and
+ * other artifact-like surfaces inside sandbox applications.
+ */
+declare function ArtifactPane({ eyebrow, title, subtitle, meta, headerActions, tabs, toolbar, footer, emptyState, children, className, contentClassName, headerClassName, hideTitleBlock }: ArtifactPaneProps): import("react").JSX.Element;
+//#endregion
+export { ArtifactPaneProps as n, ArtifactPane as t };

package/dist/artifact-pane-DMXT9a8U.js

@@ -0,0 +1,70 @@
+import { t as cn } from "./utils-C_uf36nf.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/primitives/artifact-pane.tsx
+/**
+* ArtifactPane — shared frame for files, previews, documents, inspectors, and
+* other artifact-like surfaces inside sandbox applications.
+*/
+function ArtifactPane({ eyebrow, title, subtitle, meta, headerActions, tabs, toolbar, footer, emptyState, children, className, contentClassName, headerClassName, hideTitleBlock = false }) {
+	const hasContent = children !== void 0 && children !== null;
+	const showTitleRow = !hideTitleBlock || Boolean(headerActions);
+	const hasHeader = showTitleRow || Boolean(tabs) || Boolean(toolbar);
+	const toolbarNeedsDivider = showTitleRow || Boolean(tabs);
+	return /* @__PURE__ */ jsxs("section", {
+		className: cn("flex h-full min-h-0 flex-col overflow-hidden bg-background text-foreground", className),
+		children: [
+			hasHeader && /* @__PURE__ */ jsxs("header", {
+				className: cn("border-b border-border bg-muted/10", headerClassName),
+				children: [
+					showTitleRow && /* @__PURE__ */ jsxs("div", {
+						className: "flex items-start justify-between gap-3 px-3 py-2",
+						children: [/* @__PURE__ */ jsx("div", {
+							className: "min-w-0 flex-1",
+							children: !hideTitleBlock && /* @__PURE__ */ jsxs(Fragment, { children: [
+								eyebrow && /* @__PURE__ */ jsx("div", {
+									className: "mb-1 inline-flex max-w-full items-center px-1 py-0.5 text-[10px] font-bold uppercase tracking-wider text-muted-foreground",
+									children: eyebrow
+								}),
+								/* @__PURE__ */ jsx("div", {
+									className: "min-w-0 text-[13px] font-medium text-foreground",
+									children: title
+								}),
+								(subtitle || meta) && /* @__PURE__ */ jsxs("div", {
+									className: "mt-1 flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1 text-xs leading-relaxed text-muted-foreground",
+									children: [subtitle && /* @__PURE__ */ jsx("span", {
+										className: "truncate",
+										children: subtitle
+									}), meta && /* @__PURE__ */ jsx("span", {
+										className: "flex items-center gap-2",
+										children: meta
+									})]
+								})
+							] })
+						}), headerActions && /* @__PURE__ */ jsx("div", {
+							className: "flex shrink-0 items-center gap-1.5",
+							children: headerActions
+						})]
+					}),
+					tabs,
+					toolbar && /* @__PURE__ */ jsx("div", {
+						className: cn("px-3 py-2", toolbarNeedsDivider && "border-t border-border"),
+						children: toolbar
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: cn("min-h-0 flex-1 overflow-auto", contentClassName),
+				children: hasContent ? children : emptyState ? /* @__PURE__ */ jsx("div", {
+					className: "flex h-full items-center justify-center p-6",
+					children: emptyState
+				}) : null
+			}),
+			footer && /* @__PURE__ */ jsx("footer", {
+				className: "shrink-0 border-t border-border bg-card px-3 py-2",
+				children: footer
+			})
+		]
+	});
+}
+//#endregion
+export { ArtifactPane as t };

package/dist/auth-DixfCMCk.js

@@ -0,0 +1,154 @@
+import { i as focusRing } from "./focus-Cw02pNSr.js";
+import { t as cn } from "./utils-C_uf36nf.js";
+import { t as Button } from "./button-uhNnwdsD.js";
+import { _ as AvatarFallback, a as DropdownMenuItem, g as Avatar, h as DropdownMenuTrigger, o as DropdownMenuLabel, r as DropdownMenuContent, t as DropdownMenu, u as DropdownMenuSeparator, v as AvatarImage } from "./dropdown-menu-BpcLa5vF.js";
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Terminal } from "lucide-react";
+//#region src/auth/auth.tsx
+function GitHubIcon({ className }) {
+	return /* @__PURE__ */ jsx("svg", {
+		className,
+		viewBox: "0 0 24 24",
+		fill: "currentColor",
+		"aria-hidden": "true",
+		children: /* @__PURE__ */ jsx("path", {
+			fillRule: "evenodd",
+			clipRule: "evenodd",
+			d: "M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z"
+		})
+	});
+}
+function GitHubLoginButton({ authUrl = "/auth/github", variant = "default", className, children, ...props }) {
+	return /* @__PURE__ */ jsxs(Button, {
+		variant,
+		className: cn("gap-2", className),
+		onClick: () => {
+			window.location.href = authUrl;
+		},
+		...props,
+		children: [/* @__PURE__ */ jsx(GitHubIcon, { className: "h-5 w-5" }), children ?? "Sign in with GitHub"]
+	});
+}
+function UserMenu({ user, logoutUrl = "/auth/logout", links = [], variant = "sandbox", onLogout }) {
+	const initials = user.name ? user.name.split(" ").map((n) => n[0]).join("").toUpperCase().slice(0, 2) : user.email.slice(0, 2).toUpperCase();
+	const avatarGradient = { sandbox: "bg-[image:var(--accent-gradient-strong)]" }[variant];
+	const handleLogout = () => {
+		if (onLogout) onLogout();
+		window.location.href = logoutUrl;
+	};
+	return /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+		asChild: true,
+		children: /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: cn("flex items-center gap-2 rounded-lg p-1.5 transition-colors hover:bg-accent", focusRing),
+			children: [/* @__PURE__ */ jsxs(Avatar, {
+				className: "h-8 w-8",
+				children: [/* @__PURE__ */ jsx(AvatarImage, {
+					src: void 0,
+					alt: user.name ?? user.email
+				}), /* @__PURE__ */ jsx(AvatarFallback, {
+					className: cn("text-white text-xs", avatarGradient),
+					children: initials
+				})]
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "hidden text-left md:block",
+				children: [/* @__PURE__ */ jsx("p", {
+					className: "font-medium text-sm",
+					children: user.name ?? user.email
+				}), user.tier && /* @__PURE__ */ jsxs("p", {
+					className: "text-muted-foreground text-xs capitalize",
+					children: [user.tier, " Plan"]
+				})]
+			})]
+		})
+	}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+		align: "end",
+		className: "w-56",
+		children: [
+			/* @__PURE__ */ jsx(DropdownMenuLabel, {
+				className: "font-normal",
+				children: /* @__PURE__ */ jsxs("div", {
+					className: "flex flex-col space-y-1",
+					children: [/* @__PURE__ */ jsx("p", {
+						className: "font-medium text-sm",
+						children: user.name ?? "Account"
+					}), /* @__PURE__ */ jsx("p", {
+						className: "text-muted-foreground text-xs",
+						children: user.email
+					})]
+				})
+			}),
+			/* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+			links.map((link) => /* @__PURE__ */ jsx(DropdownMenuItem, {
+				asChild: true,
+				children: /* @__PURE__ */ jsxs("a", {
+					href: link.href,
+					className: "flex items-center gap-2",
+					children: [link.icon, link.label]
+				})
+			}, link.href)),
+			links.length > 0 && /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+			/* @__PURE__ */ jsx(DropdownMenuItem, {
+				onClick: handleLogout,
+				className: "text-[var(--surface-danger-text)] focus:text-[var(--surface-danger-text)]",
+				children: "Sign out"
+			})
+		]
+	})] });
+}
+function AuthHeader({ user, loading = false, variant = "sandbox", apiBaseUrl = "", menuLinks, className }) {
+	if (loading) return /* @__PURE__ */ jsxs("div", {
+		className: cn("flex items-center gap-2", className),
+		children: [/* @__PURE__ */ jsx("div", { className: "h-8 w-8 animate-pulse rounded-full bg-muted" }), /* @__PURE__ */ jsx("div", {
+			className: "hidden md:block",
+			children: /* @__PURE__ */ jsx("div", { className: "h-4 w-20 animate-pulse rounded bg-muted" })
+		})]
+	});
+	if (!user) return /* @__PURE__ */ jsx("div", {
+		className: cn("flex items-center gap-2", className),
+		children: /* @__PURE__ */ jsx(GitHubLoginButton, {
+			authUrl: `${apiBaseUrl}/auth/github`,
+			variant,
+			size: "sm"
+		})
+	});
+	return /* @__PURE__ */ jsx(UserMenu, {
+		user,
+		variant,
+		logoutUrl: `${apiBaseUrl}/auth/logout`,
+		links: menuLinks
+	});
+}
+//#endregion
+//#region src/auth/login-layout.tsx
+function LoginLayout({ title = "Welcome Back", subtitle = "Sign in to your workspace.", brandIcon, children, className }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("relative flex min-h-screen items-center justify-center bg-background overflow-hidden antialiased font-sans flex-col", className),
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "z-10 w-full max-w-md px-6 animate-in flex flex-col items-center",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "mb-10 text-center flex flex-col items-center",
+				children: [
+					/* @__PURE__ */ jsx("div", {
+						className: "inline-flex h-14 w-14 mb-4 items-center justify-center rounded-lg bg-muted border border-border",
+						children: brandIcon || /* @__PURE__ */ jsx(Terminal, { className: "h-7 w-7 text-foreground" })
+					}),
+					/* @__PURE__ */ jsx("h1", {
+						className: "text-2xl font-bold tracking-tight text-foreground font-display",
+						children: title
+					}),
+					/* @__PURE__ */ jsx("p", {
+						className: "mt-2 text-sm text-muted-foreground",
+						children: subtitle
+					})
+				]
+			}), /* @__PURE__ */ jsx("div", {
+				className: "w-full bg-card p-8 border border-border rounded-lg",
+				children
+			})]
+		})
+	});
+}
+//#endregion
+export { UserMenu as i, AuthHeader as n, GitHubLoginButton as r, LoginLayout as t };