Synchronize signed-out auth state across logout flows

- Add shared auth-cache helper to clear and invalidate the me query
- Use the helper after logout and account deletion before redirecting home
- Switch the home route to the shared current-user hook and add coverage

apps/web/src/components/Header.test.tsx

···
+// @vitest-environment jsdom
+
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import Header from "./Header";
+
+const mockNavigate = vi.fn();
+const mockPublishSignedOutAuthState = vi.fn();
+const mockMutateAsync = vi.fn();
+const mockUseMutation = vi.fn();
+const mockUseQueryClient = vi.fn();
+
+vi.mock("@tanstack/react-query", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@tanstack/react-query")>();
+
+	return {
+		...actual,
+		useMutation: (...args: unknown[]) => mockUseMutation(...args),
+		useQueryClient: () => mockUseQueryClient(),
+	};
+});
+
+vi.mock("@tanstack/react-router", () => ({
+	Link: ({
+		children,
+		...props
+	}: {
+		children: React.ReactNode;
+		[key: string]: unknown;
+	}) => <a {...props}>{children}</a>,
+	useLocation: () => ({ pathname: "/" }),
+	useNavigate: () => mockNavigate,
+}));
+
+vi.mock("@/components/theme-provider", () => ({
+	useTheme: () => ({ seedColor: "#abcdef" }),
+}));
+
+vi.mock("@/components/ui/m3-button", () => ({
+	M3Button: ({
+		children,
+		asChild,
+		...props
+	}: {
+		children: React.ReactNode;
+		asChild?: boolean;
+		[key: string]: unknown;
+	}) => (asChild ? children : <button {...props}>{children}</button>),
+}));
+
+vi.mock("@/components/ui/popover", () => ({
+	Popover: ({ children }: { children: React.ReactNode }) => (
+		<div>{children}</div>
+	),
+	PopoverTrigger: ({ children }: { children: React.ReactNode }) => (
+		<div>{children}</div>
+	),
+	PopoverContent: ({ children }: { children: React.ReactNode }) => (
+		<div>{children}</div>
+	),
+}));
+
+vi.mock("@/lib/auth-cache", () => ({
+	publishSignedOutAuthState: (...args: unknown[]) =>
+		mockPublishSignedOutAuthState(...args),
+}));
+
+declare global {
+	var IS_REACT_ACT_ENVIRONMENT: boolean;
+}
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+describe("Header logout", () => {
+	let container: HTMLDivElement | null = null;
+	let root: Root | null = null;
+
+	afterEach(() => {
+		vi.clearAllMocks();
+
+		if (root) {
+			act(() => {
+				root.unmount();
+			});
+		}
+
+		container?.remove();
+		container = null;
+		root = null;
+		document.body.innerHTML = "";
+	});
+
+	function renderHeader(user: {
+		did: string;
+		handle: string;
+		displayName: string;
+	}) {
+		mockUseQueryClient.mockReturnValue({ name: "query-client" });
+		mockPublishSignedOutAuthState.mockResolvedValue(undefined);
+		mockUseMutation.mockImplementation(
+			(options: { onSuccess?: () => Promise<void> }) => {
+				mockMutateAsync.mockImplementation(async () => {
+					await options.onSuccess?.();
+				});
+
+				return {
+					isPending: false,
+					mutateAsync: mockMutateAsync,
+				};
+			},
+		);
+
+		container = document.createElement("div");
+		document.body.appendChild(container);
+		root = createRoot(container);
+
+		act(() => {
+			root?.render(<Header user={user} isAuthLoading={false} />);
+		});
+	}
+
+	it("publishes signed-out auth state before navigating home", async () => {
+		renderHeader({
+			did: "did:plc:alice",
+			handle: "alice",
+			displayName: "Alice",
+		});
+
+		const signOutButton = Array.from(document.querySelectorAll("button")).find(
+			(button) => button.textContent?.includes("Sign out"),
+		);
+
+		expect(signOutButton).toBeDefined();
+
+		await act(async () => {
+			signOutButton?.dispatchEvent(
+				new MouseEvent("click", { bubbles: true, cancelable: true }),
+			);
+		});
+
+		expect(mockMutateAsync).toHaveBeenCalledWith({});
+		expect(mockPublishSignedOutAuthState).toHaveBeenCalledWith({
+			name: "query-client",
+		});
+		expect(mockNavigate).toHaveBeenCalledWith({ to: "/" });
+	});
+
+	it("renders signed-out actions when no user is present", () => {
+		mockUseQueryClient.mockReturnValue({ name: "query-client" });
+		mockUseMutation.mockReturnValue({
+			isPending: false,
+			mutateAsync: mockMutateAsync,
+		});
+
+		container = document.createElement("div");
+		document.body.appendChild(container);
+		root = createRoot(container);
+
+		act(() => {
+			root?.render(<Header user={null} isAuthLoading={false} />);
+		});
+
+		expect(document.body.textContent).toContain("Sign in");
+		expect(document.body.textContent).not.toContain("Sign out");
+	});
+});

apps/web/src/components/Header.tsx

···
 	PopoverContent,
 	PopoverTrigger,
 } from "@/components/ui/popover";
+import { publishSignedOutAuthState } from "@/lib/auth-cache";
 import { cn } from "@/lib/utils";
 import {
 	type GlobalNavItem,
···
 	const logoutMutation = useMutation({
 		mutationKey: ["auth", "logout"],
 		...authControllerLogoutMutation(),
-		onSuccess: () => {
-			queryClient.clear();
+		onSuccess: async () => {
+			await publishSignedOutAuthState(queryClient);
 			navigate({ to: "/" });
 		},
 	});

apps/web/src/lib/auth-cache.test.ts

···
+// @vitest-environment jsdom
+
+import { authControllerMeQueryKey } from "@opnshelf/api";
+import { QueryClient } from "@tanstack/react-query";
+import { describe, expect, it, vi } from "vitest";
+import { publishSignedOutAuthState } from "./auth-cache";
+
+describe("publishSignedOutAuthState", () => {
+	it("publishes a signed-out auth state and invalidates the auth query", async () => {
+		const queryClient = new QueryClient();
+		const queryKey = authControllerMeQueryKey();
+		const cancelQueries = vi.spyOn(queryClient, "cancelQueries");
+		const invalidateQueries = vi.spyOn(queryClient, "invalidateQueries");
+
+		queryClient.setQueryData(queryKey, {
+			did: "did:plc:alice",
+			handle: "alice",
+		});
+
+		await publishSignedOutAuthState(queryClient);
+
+		expect(cancelQueries).toHaveBeenCalledWith({ queryKey });
+		expect(queryClient.getQueryData(queryKey)).toBeNull();
+		expect(invalidateQueries).toHaveBeenCalledWith({ queryKey });
+	});
+});

apps/web/src/lib/auth-cache.ts

···
+import { authControllerMeQueryKey } from "@opnshelf/api";
+import type { QueryClient } from "@tanstack/react-query";
+
+export async function publishSignedOutAuthState(queryClient: QueryClient) {
+	const queryKey = authControllerMeQueryKey();
+
+	await queryClient.cancelQueries({ queryKey });
+	queryClient.setQueryData(queryKey, null);
+	await queryClient.invalidateQueries({ queryKey });
+}

apps/web/src/routes/-index.test.tsx

···
+// @vitest-environment jsdom
+
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { HomePage } from "./index";
+
+const mockUseCurrentUser = vi.fn();
+
+vi.mock("@tanstack/react-router", () => ({
+	createFileRoute: () => () => ({}),
+}));
+
+vi.mock("@/hooks/useCurrentUser", () => ({
+	useCurrentUser: () => mockUseCurrentUser(),
+}));
+
+vi.mock("@/components/AuthLoadingState", () => ({
+	AuthLoadingState: () => <div>Auth loading</div>,
+}));
+
+vi.mock("@/components/home/LandingHomePage", () => ({
+	LandingHomePage: () => <div>Landing home</div>,
+}));
+
+vi.mock("@/components/home/DashboardHomePage", () => ({
+	DashboardHomePage: ({ user }: { user: { handle: string } }) => (
+		<div>Dashboard for {user.handle}</div>
+	),
+}));
+
+declare global {
+	var IS_REACT_ACT_ENVIRONMENT: boolean;
+}
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+describe("HomePage", () => {
+	let container: HTMLDivElement | null = null;
+	let root: Root | null = null;
+
+	afterEach(() => {
+		vi.clearAllMocks();
+
+		if (root) {
+			act(() => {
+				root.unmount();
+			});
+		}
+
+		container?.remove();
+		container = null;
+		root = null;
+		document.body.innerHTML = "";
+	});
+
+	function renderHomePage() {
+		container = document.createElement("div");
+		document.body.appendChild(container);
+		root = createRoot(container);
+
+		act(() => {
+			root?.render(<HomePage />);
+		});
+	}
+
+	it("uses the shared current-user hook while auth is loading", () => {
+		mockUseCurrentUser.mockReturnValue({
+			data: undefined,
+			isLoading: true,
+		});
+
+		renderHomePage();
+
+		expect(mockUseCurrentUser).toHaveBeenCalledTimes(1);
+		expect(document.body.textContent).toContain("Auth loading");
+	});
+
+	it("renders the landing page when there is no current user", () => {
+		mockUseCurrentUser.mockReturnValue({
+			data: null,
+			isLoading: false,
+		});
+
+		renderHomePage();
+
+		expect(mockUseCurrentUser).toHaveBeenCalledTimes(1);
+		expect(document.body.textContent).toContain("Landing home");
+		expect(document.body.textContent).not.toContain("Dashboard for");
+	});
+
+	it("renders the dashboard when the current user exists", () => {
+		mockUseCurrentUser.mockReturnValue({
+			data: {
+				did: "did:plc:alice",
+				handle: "alice",
+			},
+			isLoading: false,
+		});
+
+		renderHomePage();
+
+		expect(document.body.textContent).toContain("Dashboard for alice");
+		expect(document.body.textContent).not.toContain("Landing home");
+	});
+});

apps/web/src/routes/index.tsx

···
-import { authControllerMeOptions } from "@opnshelf/api";
-import { useQuery } from "@tanstack/react-query";
 import { createFileRoute } from "@tanstack/react-router";
 import { AuthLoadingState } from "@/components/AuthLoadingState";
 import { DashboardHomePage } from "@/components/home/DashboardHomePage";
 import { LandingHomePage } from "@/components/home/LandingHomePage";
+import { useCurrentUser } from "@/hooks/useCurrentUser";
 
 export const Route = createFileRoute("/")({
 	head: () => ({
···
 	component: HomePage,
 });
 
-function HomePage() {
-	const { data: user, isLoading: isUserLoading } = useQuery({
-		...authControllerMeOptions(),
-		staleTime: 5 * 60 * 1000,
-		retry: false,
-	});
+export function HomePage() {
+	const { data: user, isLoading: isUserLoading } = useCurrentUser();
 
 	if (isUserLoading) {
 		return <AuthLoadingState className="max-w-6xl py-16" />;

apps/web/src/routes/profile.$handle.settings.tsx

···
 } from "@/components/ui/select";
 import { Skeleton } from "@/components/ui/skeleton";
 import { Switch } from "@/components/ui/switch";
+import { publishSignedOutAuthState } from "@/lib/auth-cache";
 import {
 	AVATAR_UPLOAD_HELP_TEXT,
 	getAvatarUploadErrorMessage,
···
 	const deleteAccountMutation = useMutation({
 		mutationKey: ["users", "account", "delete"],
 		...usersControllerDeleteMyAccountMutation(),
-		onSuccess: () => {
+		onSuccess: async () => {
 			if (user?.did) {
 				clearDismissedTraktImportJobIds(user.did);
 			}
···
 			posthog.reset();
 			setShowDeleteDialog(false);
 			toast.success("Account deleted");
-			queryClient.clear();
+			await publishSignedOutAuthState(queryClient);
 			router.navigate({ to: "/" });
 		},
 		onError: (error) => {