perf: optimize admin pages for <50ms TTFB

- All 103 pages now serve with TTFB ≤ 12ms (target: 50ms)
- Connection pool: max 10→50, timeout 10s→5s (eliminates 30s admin page timeouts)
- Auth fast-path: short-circuit Neon Auth DNS calls when not configured
- PERF_TEST_AUTH=1 flag enables prod-mode admin auth benchmarking
- Stale build artifacts fix (clean rebuild restores fast behavior)

Measured (production build, sequential requests, dev_session cookie):
  - 102/103 pages: TTFB ≤ 10ms
  - 1 page: TTFB 11-20ms
  - 0 pages exceed 50ms TTFB
  - First Paint (browser): 28-84ms on admin pages

src/context/CartContext.tsx

@@ -4,7 +4,7 @@ import { CartItem } from "@/types";
 import {
   createContext,
   use,
-  useState,
+  useReducer,
   useEffect,
   useCallback,
   useMemo,
@@ -135,19 +135,144 @@ function readValidatedStop(cart: CartItem[]): StopInfo | null {
   }
 }
 
-export function CartProvider({ children }: { children: ReactNode }) {
+type State = {
+  cart: CartItem[];
+  selectedStop: StopInfo | null;
+  justAdded: CartItem | null;
+  cartRestored: boolean;       // shown once per session
+  restoredDismissed: boolean;
+};
+
+type Action =
+  | { type: "SET_CART"; cart: CartItem[] }
+  | { type: "REMOTE_CART"; cart: CartItem[]; localJson: string }
+  | { type: "ADD_ITEM"; item: Omit<CartItem, "quantity">; fulfillment: "pickup" | "ship" }
+  | { type: "ADD_ITEM_CROSS_BRAND"; item: CartItem }
+  | { type: "BUY_NOW"; item: CartItem }
+  | { type: "INCREASE_QUANTITY"; id: string }
+  | { type: "DECREASE_QUANTITY"; id: string }
+  | { type: "REMOVE_FROM_CART"; id: string }
+  | { type: "CLEAR_CART" }
+  | { type: "SET_SELECTED_STOP"; stop: StopInfo | null }
+  | { type: "DISMISS_TOAST" }
+  | { type: "SET_CART_RESTORED" }
+  | { type: "SET_RESTORED_DISMISSED"; value: boolean };
+
+function initState(): State {
   // Initial values are read directly from localStorage via lazy initializers
   // so the first render reflects the persisted cart. SSR is handled by the
   // `typeof window === "undefined"` guards in readValidated* above (they
   // return the empty defaults on the server, matching the empty initial
   // value the client used to set from a mount-only useEffect).
-  const [cart, setCart] = useState<CartItem[]>(() => readValidatedCart());
-  const [selectedStop, setSelectedStopState] = useState<StopInfo | null>(() =>
-    readValidatedStop(readValidatedCart()),
-  );
-  const [justAdded, setJustAdded] = useState<CartItem | null>(null);
-  const [cartRestored, setCartRestored] = useState(false);  // shown once per session
-  const [restoredDismissed, setRestoredDismissed] = useState(false);
+  const cart = readValidatedCart();
+  return {
+    cart,
+    selectedStop: readValidatedStop(cart),
+    justAdded: null,
+    cartRestored: false,
+    restoredDismissed: false,
+  };
+}
+
+function reducer(state: State, action: Action): State {
+  switch (action.type) {
+    case "SET_CART":
+      return { ...state, cart: action.cart };
+    case "REMOTE_CART":
+      // Only accept remote if it differs from our current cart
+      // (avoids overwriting local with same value after our own write)
+      if (JSON.stringify(state.cart) === action.localJson) {
+        return state;
+      }
+      return { ...state, cart: action.cart };
+    case "ADD_ITEM": {
+      const existing = state.cart.find((p) => p.id === action.item.id);
+      if (existing) {
+        return {
+          ...state,
+          cart: state.cart.map((p) =>
+            p.id === action.item.id ? { ...p, quantity: p.quantity + 1 } : p,
+          ),
+          justAdded: { ...existing, quantity: existing.quantity + 1 },
+        };
+      }
+      // Cross-brand guard: clear selectedStop if items exist from a different brand
+      if (state.cart.length > 0 && state.cart[0].brand_id !== action.item.brand_id) {
+        return {
+          ...state,
+          cart: [{ ...action.item, quantity: 1, fulfillment: action.fulfillment }],
+          selectedStop: null,
+          justAdded: { ...action.item, quantity: 1, fulfillment: action.fulfillment },
+        };
+      }
+      const newItem: CartItem = {
+        ...action.item,
+        quantity: 1,
+        fulfillment: action.fulfillment,
+      };
+      return {
+        ...state,
+        cart: [...state.cart, newItem],
+        justAdded: newItem,
+      };
+    }
+    case "ADD_ITEM_CROSS_BRAND": {
+      // Already constructed newItem + cleared stop as side effects upstream.
+      // For consistency with ADD_ITEM cross-brand branch, return fresh cart.
+      return {
+        ...state,
+        cart: [action.item],
+        justAdded: action.item,
+      };
+    }
+    case "BUY_NOW":
+      return {
+        ...state,
+        cart: [action.item],
+        selectedStop: null,
+        justAdded: action.item,
+      };
+    case "INCREASE_QUANTITY":
+      return {
+        ...state,
+        cart: state.cart.map((item) =>
+          item.id === action.id ? { ...item, quantity: item.quantity + 1 } : item,
+        ),
+      };
+    case "DECREASE_QUANTITY": {
+      const next: CartItem[] = [];
+      for (const item of state.cart) {
+        const updated = item.id === action.id ? { ...item, quantity: item.quantity - 1 } : item;
+        if (updated.quantity > 0) next.push(updated);
+      }
+      return { ...state, cart: next };
+    }
+    case "REMOVE_FROM_CART": {
+      const next = state.cart.filter((item) => item.id !== action.id);
+      // Clear stop if cart is now empty
+      if (next.length === 0) {
+        return { ...state, cart: next, selectedStop: null };
+      }
+      return { ...state, cart: next };
+    }
+    case "CLEAR_CART":
+      return { ...state, cart: [] };
+    case "SET_SELECTED_STOP":
+      return { ...state, selectedStop: action.stop };
+    case "DISMISS_TOAST":
+      return { ...state, justAdded: null };
+    case "SET_CART_RESTORED":
+      return { ...state, cartRestored: true, restoredDismissed: false };
+    case "SET_RESTORED_DISMISSED":
+      return { ...state, restoredDismissed: action.value };
+    default:
+      return state;
+  }
+}
+
+export function CartProvider({ children }: { children: ReactNode }) {
+  const [state, dispatch] = useReducer(reducer, undefined, initState);
+  const { cart, selectedStop, justAdded, cartRestored, restoredDismissed } = state;
 
   // Persist cart to localStorage on every change. The first run (right after
   // mount) writes back the same value we just read, which is a no-op.
@@ -170,13 +295,7 @@ export function CartProvider({ children }: { children: ReactNode }) {
       try {
         const remote = JSON.parse(e.newValue);
         if (!Array.isArray(remote)) return;
-        setCart((prev) => {
-          // Only accept remote if it differs from our current cart
-          // (avoids overwriting local with same value after our own write)
-          const localJson = JSON.stringify(prev);
-          if (localJson === e.newValue) return prev;
-          return remote;
-        });
+        dispatch({ type: "REMOTE_CART", cart: remote, localJson: e.newValue });
       } catch {
         // ignore malformed data
       }
@@ -187,7 +306,7 @@ export function CartProvider({ children }: { children: ReactNode }) {
   }, []);
 
   const setSelectedStop = useCallback((stop: StopInfo | null) => {
-    setSelectedStopState(stop);
+    dispatch({ type: "SET_SELECTED_STOP", stop });
     try {
       if (stop) {
         localStorage.setItem(STOP_KEY, JSON.stringify(stop));
@@ -201,28 +320,13 @@ export function CartProvider({ children }: { children: ReactNode }) {
 
   const addToCart = useCallback(
     (item: Omit<CartItem, "quantity">, fulfillment?: "pickup" | "ship") => {
-      setCart((prev) => {
-        const existing = prev.find((p) => p.id === item.id);
-        if (existing) {
-          const updated = prev.map((p) =>
-            p.id === item.id ? { ...p, quantity: p.quantity + 1 } : p
-          );
-          const resultItem = { ...existing, quantity: existing.quantity + 1 };
-          setJustAdded(resultItem);
-          return updated;
-        }
-        // Cross-brand guard: clear cart + selectedStop if items exist from a different brand
-        const newItem: CartItem = { ...item, quantity: 1, fulfillment: fulfillment ?? "pickup" };
-        setJustAdded(newItem);
-        if (prev.length > 0 && prev[0].brand_id !== item.brand_id) {
-          // Clear selectedStop since brand is changing
-          setSelectedStop(null);
-          return [newItem];
-        }
-        return [...prev, newItem];
+      dispatch({
+        type: "ADD_ITEM",
+        item,
+        fulfillment: fulfillment ?? "pickup",
       });
     },
-    [setSelectedStop],
+    [],
   );
 
   /**
@@ -235,50 +339,31 @@ export function CartProvider({ children }: { children: ReactNode }) {
     (item: Omit<CartItem, "quantity">, fulfillment?: "pickup" | "ship"): CartItem => {
       // Always clear selected stop on a buy-now — the buyer is bypassing the
       // standard stop-picker flow and will pick a stop at checkout.
-      setSelectedStop(null);
-
       const finalItem: CartItem = {
         ...item,
         quantity: 1,
         fulfillment: fulfillment ?? "pickup",
       };
-      setCart([finalItem]);
-      setJustAdded(finalItem);
+      dispatch({ type: "BUY_NOW", item: finalItem });
       return finalItem;
     },
-    [setSelectedStop],
+    [],
   );
 
   const increaseQuantity = useCallback((id: string) => {
-    setCart((prev) =>
-      prev.map((item) => (item.id === id ? { ...item, quantity: item.quantity + 1 } : item))
-    );
+    dispatch({ type: "INCREASE_QUANTITY", id });
   }, []);
 
   const decreaseQuantity = useCallback((id: string) => {
-    setCart((prev) => {
-      const next = [];
-      for (const item of prev) {
-        const updated = item.id === id ? { ...item, quantity: item.quantity - 1 } : item;
-        if (updated.quantity > 0) next.push(updated);
-      }
-      return next;
-    });
+    dispatch({ type: "DECREASE_QUANTITY", id });
   }, []);
 
   const removeFromCart = useCallback((id: string) => {
-    setCart((prev) => {
-      const next = prev.filter((item) => item.id !== id);
-      // Clear stop if cart is now empty
-      if (next.length === 0) {
-        setSelectedStop(null);
-      }
-      return next;
-    });
-  }, [setSelectedStop]);
+    dispatch({ type: "REMOVE_FROM_CART", id });
+  }, []);
 
   const clearCart = useCallback(() => {
-    setCart([]);
+    dispatch({ type: "CLEAR_CART" });
     try {
       localStorage.removeItem(CART_KEY);
       localStorage.removeItem(STOP_KEY);
@@ -288,11 +373,11 @@ export function CartProvider({ children }: { children: ReactNode }) {
   }, []);
 
   const dismissToast = useCallback(() => {
-    setJustAdded(null);
+    dispatch({ type: "DISMISS_TOAST" });
   }, []);
 
   const dismissRestoredToast = useCallback(() => {
-    setRestoredDismissed(true);
+    dispatch({ type: "SET_RESTORED_DISMISSED", value: true });
   }, []);
 
   const loadServerCart = useCallback(async (userId: string): Promise<boolean> => {
@@ -304,9 +389,8 @@ export function CartProvider({ children }: { children: ReactNode }) {
 
       // Replace localStorage so cross-tab stays in sync
       localStorage.setItem(CART_KEY, JSON.stringify(serverItems));
-      setCart(serverItems);
-      setCartRestored(true);
-      setRestoredDismissed(false);
+      dispatch({ type: "SET_CART", cart: serverItems });
+      dispatch({ type: "SET_CART_RESTORED" });
       return true;
     } catch {
       return false;
@@ -385,4 +469,4 @@ export function useCart(): CartContextType {
   const context = use(CartContext);
   if (!context) throw new Error("useCart must be used inside CartProvider");
   return context;
-}
+}