chore: auto-fix Biome formatting and configure lint rules

Run biome check --write --unsafe to fix tabs, import ordering, and
non-null assertions across entire codebase. Disable a11y rules not
applicable to this single-user app. Exclude auto-generated routeTree.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/client/hooks/useCandidates.ts

@@ -1,61 +1,61 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiPost, apiPut, apiDelete } from "../lib/api";
 import type { CreateCandidate, UpdateCandidate } from "../../shared/types";
+import { apiDelete, apiPost, apiPut } from "../lib/api";
 
 interface CandidateResponse {
-  id: number;
-  threadId: number;
-  name: string;
-  weightGrams: number | null;
-  priceCents: number | null;
-  categoryId: number;
-  notes: string | null;
-  productUrl: string | null;
-  imageFilename: string | null;
-  createdAt: string;
-  updatedAt: string;
+	id: number;
+	threadId: number;
+	name: string;
+	weightGrams: number | null;
+	priceCents: number | null;
+	categoryId: number;
+	notes: string | null;
+	productUrl: string | null;
+	imageFilename: string | null;
+	createdAt: string;
+	updatedAt: string;
 }
 
 export function useCreateCandidate(threadId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: CreateCandidate & { imageFilename?: string }) =>
-      apiPost<CandidateResponse>(`/api/threads/${threadId}/candidates`, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: CreateCandidate & { imageFilename?: string }) =>
+			apiPost<CandidateResponse>(`/api/threads/${threadId}/candidates`, data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }
 
 export function useUpdateCandidate(threadId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({
-      candidateId,
-      ...data
-    }: UpdateCandidate & { candidateId: number; imageFilename?: string }) =>
-      apiPut<CandidateResponse>(
-        `/api/threads/${threadId}/candidates/${candidateId}`,
-        data,
-      ),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({
+			candidateId,
+			...data
+		}: UpdateCandidate & { candidateId: number; imageFilename?: string }) =>
+			apiPut<CandidateResponse>(
+				`/api/threads/${threadId}/candidates/${candidateId}`,
+				data,
+			),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }
 
 export function useDeleteCandidate(threadId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (candidateId: number) =>
-      apiDelete<{ success: boolean }>(
-        `/api/threads/${threadId}/candidates/${candidateId}`,
-      ),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (candidateId: number) =>
+			apiDelete<{ success: boolean }>(
+				`/api/threads/${threadId}/candidates/${candidateId}`,
+			),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads", threadId] });
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }

src/client/hooks/useCategories.ts

@@ -1,53 +1,53 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiGet, apiPost, apiPut, apiDelete } from "../lib/api";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { Category, CreateCategory } from "../../shared/types";
+import { apiDelete, apiGet, apiPost, apiPut } from "../lib/api";
 
 export function useCategories() {
-  return useQuery({
-    queryKey: ["categories"],
-    queryFn: () => apiGet<Category[]>("/api/categories"),
-  });
+	return useQuery({
+		queryKey: ["categories"],
+		queryFn: () => apiGet<Category[]>("/api/categories"),
+	});
 }
 
 export function useCreateCategory() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: CreateCategory) =>
-      apiPost<Category>("/api/categories", data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["categories"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: CreateCategory) =>
+			apiPost<Category>("/api/categories", data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["categories"] });
+		},
+	});
 }
 
 export function useUpdateCategory() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({
-      id,
-      ...data
-    }: {
-      id: number;
-      name?: string;
-      icon?: string;
-    }) => apiPut<Category>(`/api/categories/${id}`, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["categories"] });
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({
+			id,
+			...data
+		}: {
+			id: number;
+			name?: string;
+			icon?: string;
+		}) => apiPut<Category>(`/api/categories/${id}`, data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["categories"] });
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+		},
+	});
 }
 
 export function useDeleteCategory() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (id: number) =>
-      apiDelete<{ success: boolean }>(`/api/categories/${id}`),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["categories"] });
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (id: number) =>
+			apiDelete<{ success: boolean }>(`/api/categories/${id}`),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["categories"] });
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+		},
+	});
 }

src/client/hooks/useItems.ts

@@ -1,71 +1,71 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiGet, apiPost, apiPut, apiDelete } from "../lib/api";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { CreateItem } from "../../shared/types";
+import { apiDelete, apiGet, apiPost, apiPut } from "../lib/api";
 
 interface ItemWithCategory {
-  id: number;
-  name: string;
-  weightGrams: number | null;
-  priceCents: number | null;
-  categoryId: number;
-  notes: string | null;
-  productUrl: string | null;
-  imageFilename: string | null;
-  createdAt: string;
-  updatedAt: string;
-  categoryName: string;
-  categoryIcon: string;
+	id: number;
+	name: string;
+	weightGrams: number | null;
+	priceCents: number | null;
+	categoryId: number;
+	notes: string | null;
+	productUrl: string | null;
+	imageFilename: string | null;
+	createdAt: string;
+	updatedAt: string;
+	categoryName: string;
+	categoryIcon: string;
 }
 
 export function useItems() {
-  return useQuery({
-    queryKey: ["items"],
-    queryFn: () => apiGet<ItemWithCategory[]>("/api/items"),
-  });
+	return useQuery({
+		queryKey: ["items"],
+		queryFn: () => apiGet<ItemWithCategory[]>("/api/items"),
+	});
 }
 
 export function useItem(id: number | null) {
-  return useQuery({
-    queryKey: ["items", id],
-    queryFn: () => apiGet<ItemWithCategory>(`/api/items/${id}`),
-    enabled: id != null,
-  });
+	return useQuery({
+		queryKey: ["items", id],
+		queryFn: () => apiGet<ItemWithCategory>(`/api/items/${id}`),
+		enabled: id != null,
+	});
 }
 
 export function useCreateItem() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: CreateItem) =>
-      apiPost<ItemWithCategory>("/api/items", data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: CreateItem) =>
+			apiPost<ItemWithCategory>("/api/items", data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+		},
+	});
 }
 
 export function useUpdateItem() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ id, ...data }: { id: number } & Partial<CreateItem>) =>
-      apiPut<ItemWithCategory>(`/api/items/${id}`, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({ id, ...data }: { id: number } & Partial<CreateItem>) =>
+			apiPut<ItemWithCategory>(`/api/items/${id}`, data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }
 
 export function useDeleteItem() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (id: number) =>
-      apiDelete<{ success: boolean }>(`/api/items/${id}`),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (id: number) =>
+			apiDelete<{ success: boolean }>(`/api/items/${id}`),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }

src/client/hooks/useSettings.ts

@@ -1,37 +1,37 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { apiGet, apiPut } from "../lib/api";
 
 interface Setting {
-  key: string;
-  value: string;
+	key: string;
+	value: string;
 }
 
 export function useSetting(key: string) {
-  return useQuery({
-    queryKey: ["settings", key],
-    queryFn: async () => {
-      try {
-        const result = await apiGet<Setting>(`/api/settings/${key}`);
-        return result.value;
-      } catch (err: any) {
-        if (err?.status === 404) return null;
-        throw err;
-      }
-    },
-  });
+	return useQuery({
+		queryKey: ["settings", key],
+		queryFn: async () => {
+			try {
+				const result = await apiGet<Setting>(`/api/settings/${key}`);
+				return result.value;
+			} catch (err: any) {
+				if (err?.status === 404) return null;
+				throw err;
+			}
+		},
+	});
 }
 
 export function useUpdateSetting() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ key, value }: { key: string; value: string }) =>
-      apiPut<Setting>(`/api/settings/${key}`, { value }),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["settings", variables.key] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({ key, value }: { key: string; value: string }) =>
+			apiPut<Setting>(`/api/settings/${key}`, { value }),
+		onSuccess: (_data, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["settings", variables.key] });
+		},
+	});
 }
 
 export function useOnboardingComplete() {
-  return useSetting("onboardingComplete");
+	return useSetting("onboardingComplete");
 }

src/client/hooks/useSetups.ts

@@ -1,107 +1,107 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiGet, apiPost, apiPut, apiDelete } from "../lib/api";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { apiDelete, apiGet, apiPost, apiPut } from "../lib/api";
 
 interface SetupListItem {
-  id: number;
-  name: string;
-  createdAt: string;
-  updatedAt: string;
-  itemCount: number;
-  totalWeight: number;
-  totalCost: number;
+	id: number;
+	name: string;
+	createdAt: string;
+	updatedAt: string;
+	itemCount: number;
+	totalWeight: number;
+	totalCost: number;
 }
 
 interface SetupItemWithCategory {
-  id: number;
-  name: string;
-  weightGrams: number | null;
-  priceCents: number | null;
-  categoryId: number;
-  notes: string | null;
-  productUrl: string | null;
-  imageFilename: string | null;
-  createdAt: string;
-  updatedAt: string;
-  categoryName: string;
-  categoryIcon: string;
+	id: number;
+	name: string;
+	weightGrams: number | null;
+	priceCents: number | null;
+	categoryId: number;
+	notes: string | null;
+	productUrl: string | null;
+	imageFilename: string | null;
+	createdAt: string;
+	updatedAt: string;
+	categoryName: string;
+	categoryIcon: string;
 }
 
 interface SetupWithItems {
-  id: number;
-  name: string;
-  createdAt: string;
-  updatedAt: string;
-  items: SetupItemWithCategory[];
+	id: number;
+	name: string;
+	createdAt: string;
+	updatedAt: string;
+	items: SetupItemWithCategory[];
 }
 
-export type { SetupListItem, SetupWithItems, SetupItemWithCategory };
+export type { SetupItemWithCategory, SetupListItem, SetupWithItems };
 
 export function useSetups() {
-  return useQuery({
-    queryKey: ["setups"],
-    queryFn: () => apiGet<SetupListItem[]>("/api/setups"),
-  });
+	return useQuery({
+		queryKey: ["setups"],
+		queryFn: () => apiGet<SetupListItem[]>("/api/setups"),
+	});
 }
 
 export function useSetup(setupId: number | null) {
-  return useQuery({
-    queryKey: ["setups", setupId],
-    queryFn: () => apiGet<SetupWithItems>(`/api/setups/${setupId}`),
-    enabled: setupId != null,
-  });
+	return useQuery({
+		queryKey: ["setups", setupId],
+		queryFn: () => apiGet<SetupWithItems>(`/api/setups/${setupId}`),
+		enabled: setupId != null,
+	});
 }
 
 export function useCreateSetup() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: { name: string }) =>
-      apiPost<SetupListItem>("/api/setups", data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: { name: string }) =>
+			apiPost<SetupListItem>("/api/setups", data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }
 
 export function useUpdateSetup(setupId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: { name?: string }) =>
-      apiPut<SetupListItem>(`/api/setups/${setupId}`, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: { name?: string }) =>
+			apiPut<SetupListItem>(`/api/setups/${setupId}`, data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }
 
 export function useDeleteSetup() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (id: number) =>
-      apiDelete<{ success: boolean }>(`/api/setups/${id}`),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (id: number) =>
+			apiDelete<{ success: boolean }>(`/api/setups/${id}`),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }
 
 export function useSyncSetupItems(setupId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (itemIds: number[]) =>
-      apiPut<{ success: boolean }>(`/api/setups/${setupId}/items`, { itemIds }),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (itemIds: number[]) =>
+			apiPut<{ success: boolean }>(`/api/setups/${setupId}/items`, { itemIds }),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }
 
 export function useRemoveSetupItem(setupId: number) {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (itemId: number) =>
-      apiDelete<{ success: boolean }>(`/api/setups/${setupId}/items/${itemId}`),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["setups"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (itemId: number) =>
+			apiDelete<{ success: boolean }>(`/api/setups/${setupId}/items/${itemId}`),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["setups"] });
+		},
+	});
 }

src/client/hooks/useThreads.ts

@@ -1,116 +1,116 @@
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiGet, apiPost, apiPut, apiDelete } from "../lib/api";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { apiDelete, apiGet, apiPost, apiPut } from "../lib/api";
 
 interface ThreadListItem {
-  id: number;
-  name: string;
-  status: "active" | "resolved";
-  resolvedCandidateId: number | null;
-  categoryId: number;
-  categoryName: string;
-  categoryIcon: string;
-  createdAt: string;
-  updatedAt: string;
-  candidateCount: number;
-  minPriceCents: number | null;
-  maxPriceCents: number | null;
+	id: number;
+	name: string;
+	status: "active" | "resolved";
+	resolvedCandidateId: number | null;
+	categoryId: number;
+	categoryName: string;
+	categoryIcon: string;
+	createdAt: string;
+	updatedAt: string;
+	candidateCount: number;
+	minPriceCents: number | null;
+	maxPriceCents: number | null;
 }
 
 interface CandidateWithCategory {
-  id: number;
-  threadId: number;
-  name: string;
-  weightGrams: number | null;
-  priceCents: number | null;
-  categoryId: number;
-  notes: string | null;
-  productUrl: string | null;
-  imageFilename: string | null;
-  createdAt: string;
-  updatedAt: string;
-  categoryName: string;
-  categoryIcon: string;
+	id: number;
+	threadId: number;
+	name: string;
+	weightGrams: number | null;
+	priceCents: number | null;
+	categoryId: number;
+	notes: string | null;
+	productUrl: string | null;
+	imageFilename: string | null;
+	createdAt: string;
+	updatedAt: string;
+	categoryName: string;
+	categoryIcon: string;
 }
 
 interface ThreadWithCandidates {
-  id: number;
-  name: string;
-  status: "active" | "resolved";
-  resolvedCandidateId: number | null;
-  createdAt: string;
-  updatedAt: string;
-  candidates: CandidateWithCategory[];
+	id: number;
+	name: string;
+	status: "active" | "resolved";
+	resolvedCandidateId: number | null;
+	createdAt: string;
+	updatedAt: string;
+	candidates: CandidateWithCategory[];
 }
 
 export function useThreads(includeResolved = false) {
-  return useQuery({
-    queryKey: ["threads", { includeResolved }],
-    queryFn: () =>
-      apiGet<ThreadListItem[]>(
-        `/api/threads${includeResolved ? "?includeResolved=true" : ""}`,
-      ),
-  });
+	return useQuery({
+		queryKey: ["threads", { includeResolved }],
+		queryFn: () =>
+			apiGet<ThreadListItem[]>(
+				`/api/threads${includeResolved ? "?includeResolved=true" : ""}`,
+			),
+	});
 }
 
 export function useThread(threadId: number | null) {
-  return useQuery({
-    queryKey: ["threads", threadId],
-    queryFn: () => apiGet<ThreadWithCandidates>(`/api/threads/${threadId}`),
-    enabled: threadId != null,
-  });
+	return useQuery({
+		queryKey: ["threads", threadId],
+		queryFn: () => apiGet<ThreadWithCandidates>(`/api/threads/${threadId}`),
+		enabled: threadId != null,
+	});
 }
 
 export function useCreateThread() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: { name: string; categoryId: number }) =>
-      apiPost<ThreadListItem>("/api/threads", data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (data: { name: string; categoryId: number }) =>
+			apiPost<ThreadListItem>("/api/threads", data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }
 
 export function useUpdateThread() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({ id, ...data }: { id: number; name?: string }) =>
-      apiPut<ThreadListItem>(`/api/threads/${id}`, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({ id, ...data }: { id: number; name?: string }) =>
+			apiPut<ThreadListItem>(`/api/threads/${id}`, data),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }
 
 export function useDeleteThread() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (id: number) =>
-      apiDelete<{ success: boolean }>(`/api/threads/${id}`),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (id: number) =>
+			apiDelete<{ success: boolean }>(`/api/threads/${id}`),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+		},
+	});
 }
 
 export function useResolveThread() {
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: ({
-      threadId,
-      candidateId,
-    }: {
-      threadId: number;
-      candidateId: number;
-    }) =>
-      apiPost<{ success: boolean; item: unknown }>(
-        `/api/threads/${threadId}/resolve`,
-        { candidateId },
-      ),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["threads"] });
-      queryClient.invalidateQueries({ queryKey: ["items"] });
-      queryClient.invalidateQueries({ queryKey: ["totals"] });
-    },
-  });
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: ({
+			threadId,
+			candidateId,
+		}: {
+			threadId: number;
+			candidateId: number;
+		}) =>
+			apiPost<{ success: boolean; item: unknown }>(
+				`/api/threads/${threadId}/resolve`,
+				{ candidateId },
+			),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["threads"] });
+			queryClient.invalidateQueries({ queryKey: ["items"] });
+			queryClient.invalidateQueries({ queryKey: ["totals"] });
+		},
+	});
 }

src/client/hooks/useTotals.ts

@@ -2,30 +2,30 @@ import { useQuery } from "@tanstack/react-query";
 import { apiGet } from "../lib/api";
 
 interface CategoryTotals {
-  categoryId: number;
-  categoryName: string;
-  categoryIcon: string;
-  totalWeight: number;
-  totalCost: number;
-  itemCount: number;
+	categoryId: number;
+	categoryName: string;
+	categoryIcon: string;
+	totalWeight: number;
+	totalCost: number;
+	itemCount: number;
 }
 
 interface GlobalTotals {
-  totalWeight: number;
-  totalCost: number;
-  itemCount: number;
+	totalWeight: number;
+	totalCost: number;
+	itemCount: number;
 }
 
 interface TotalsResponse {
-  categories: CategoryTotals[];
-  global: GlobalTotals;
+	categories: CategoryTotals[];
+	global: GlobalTotals;
 }
 
 export type { CategoryTotals, GlobalTotals, TotalsResponse };
 
 export function useTotals() {
-  return useQuery({
-    queryKey: ["totals"],
-    queryFn: () => apiGet<TotalsResponse>("/api/totals"),
-  });
+	return useQuery({
+		queryKey: ["totals"],
+		queryFn: () => apiGet<TotalsResponse>("/api/totals"),
+	});
 }