faster initial loading

src/providers/UnifiedAuthProvider.tsx

···
-// src/providers/UnifiedAuthProvider.tsx
-// Import both Agent and the (soon to be deprecated) AtpAgent
 import { Agent, AtpAgent, type AtpSessionData } from "@atproto/api";
 import {
   type OAuthSession,
···
   TokenRefreshError,
   TokenRevokedError,
 } from "@atproto/oauth-client-browser";
+import { useAtom } from "jotai";
 import React, {
   createContext,
   use,
···
   useState,
 } from "react";
 
-import { oauthClient } from "../utils/oauthClient"; // Adjust path if needed
+import { quickAuthAtom } from "~/utils/atoms";
+
+import { oauthClient } from "../utils/oauthClient";
 
-// Define the unified status and authentication method
 type AuthStatus = "loading" | "signedIn" | "signedOut";
 type AuthMethod = "password" | "oauth" | null;
 
 interface AuthContextValue {
-  agent: Agent | null; // The agent is typed as the base class `Agent`
+  agent: Agent | null;
   status: AuthStatus;
   authMethod: AuthMethod;
   loginWithPassword: (
···
 }: {
   children: React.ReactNode;
 }) => {
-  // The state is typed as the base class `Agent`, which accepts both `Agent` and `AtpAgent` instances.
   const [agent, setAgent] = useState<Agent | null>(null);
   const [status, setStatus] = useState<AuthStatus>("loading");
   const [authMethod, setAuthMethod] = useState<AuthMethod>(null);
   const [oauthSession, setOauthSession] = useState<OAuthSession | null>(null);
+  const [quickAuth, setQuickAuth] = useAtom(quickAuthAtom);
 
-  // Unified Initialization Logic
   const initialize = useCallback(async () => {
-    // --- 1. Try OAuth initialization first ---
     try {
       const oauthResult = await oauthClient.init();
       if (oauthResult) {
         // /*mass comment*/ console.log("OAuth session restored.");
-        const apiAgent = new Agent(oauthResult.session); // Standard Agent
+        const apiAgent = new Agent(oauthResult.session);
         setAgent(apiAgent);
         setOauthSession(oauthResult.session);
         setAuthMethod("oauth");
         setStatus("signedIn");
-        return; // Success
+        setQuickAuth(apiAgent?.did || null);
+        return;
       }
     } catch (e) {
       console.error("OAuth init failed, checking password session.", e);
+      if (!quickAuth) {
+        // quickAuth restoration. if last used method is oauth we immediately call for oauth redo
+        // (and set a persistent atom somewhere to not retry again if it failed)
+      }
     }
 
-    // --- 2. If no OAuth, try password-based session using AtpAgent ---
     try {
       const service = localStorage.getItem("service");
       const sessionString = localStorage.getItem("sess");
 
       if (service && sessionString) {
         // /*mass comment*/ console.log("Resuming password-based session using AtpAgent...");
-        // Use the original, working AtpAgent logic
         const apiAgent = new AtpAgent({ service });
         const session: AtpSessionData = JSON.parse(sessionString);
         await apiAgent.resumeSession(session);
 
         // /*mass comment*/ console.log("Password-based session resumed successfully.");
-        setAgent(apiAgent); // This works because AtpAgent is a subclass of Agent
+        setAgent(apiAgent);
         setAuthMethod("password");
         setStatus("signedIn");
-        return; // Success
+        setQuickAuth(apiAgent?.did || null);
+        return;
       }
     } catch (e) {
       console.error("Failed to resume password-based session.", e);
···
       localStorage.removeItem("service");
     }
 
-    // --- 3. If neither worked, user is signed out ---
     // /*mass comment*/ console.log("No active session found.");
     setStatus("signedOut");
     setAgent(null);
     setAuthMethod(null);
-  }, []);
+    // do we want to null it here?
+    setQuickAuth(null);
+  }, [quickAuth, setQuickAuth]);
 
   useEffect(() => {
     const handleOAuthSessionDeleted = (
···
       setOauthSession(null);
       setAuthMethod(null);
       setStatus("signedOut");
+      setQuickAuth(null);
     };
 
     oauthClient.addEventListener("deleted", handleOAuthSessionDeleted as EventListener);
···
     return () => {
       oauthClient.removeEventListener("deleted", handleOAuthSessionDeleted as EventListener);
     };
-  }, [initialize]);
+  }, [initialize, setQuickAuth]);
 
-  // --- Login Methods ---
   const loginWithPassword = async (
     user: string,
     password: string,
···
     setStatus("loading");
     try {
       let sessionData: AtpSessionData | undefined;
-      // Use the AtpAgent for its simple login and session persistence
       const apiAgent = new AtpAgent({
         service,
         persistSession: (_evt, sess) => {
···
       if (sessionData) {
         localStorage.setItem("service", service);
         localStorage.setItem("sess", JSON.stringify(sessionData));
-        setAgent(apiAgent); // Store the AtpAgent instance in our state
+        setAgent(apiAgent);
         setAuthMethod("password");
         setStatus("signedIn");
+        setQuickAuth(apiAgent?.did || null);
         // /*mass comment*/ console.log("Successfully logged in with password.");
       } else {
         throw new Error("Session data not persisted after login.");
···
     } catch (e) {
       console.error("Password login failed:", e);
       setStatus("signedOut");
+      setQuickAuth(null);
       throw e;
     }
   };
···
     }
   }, [status]);
 
-  // --- Unified Logout ---
   const logout = useCallback(async () => {
     if (status !== "signedIn" || !agent) return;
     setStatus("loading");
···
       } else if (authMethod === "password") {
         localStorage.removeItem("service");
         localStorage.removeItem("sess");
-        // AtpAgent has its own logout methods
         await (agent as AtpAgent).com.atproto.server.deleteSession();
         // /*mass comment*/ console.log("Password-based session deleted.");
       }
···
       setAuthMethod(null);
       setOauthSession(null);
       setStatus("signedOut");
+      setQuickAuth(null);
     }
-  }, [status, authMethod, agent, oauthSession]);
+  }, [status, agent, authMethod, oauthSession, setQuickAuth]);
 
   return (
     <AuthContext

src/routes/index.tsx

···
 import { createFileRoute } from "@tanstack/react-router";
 import { useAtom } from "jotai";
 import * as React from "react";
-import { useEffect, useLayoutEffect } from "react";
+import { useLayoutEffect, useState } from "react";
 
 import { Header } from "~/components/Header";
 import { InfiniteCustomFeed } from "~/components/InfiniteCustomFeed";
 import { useAuth } from "~/providers/UnifiedAuthProvider";
 import {
-  agentAtom,
-  authedAtom,
   feedScrollPositionsAtom,
   isAtTopAtom,
+  quickAuthAtom,
   selectedFeedUriAtom,
-  store,
 } from "~/utils/atoms";
 //import { usePersistentStore } from "~/providers/PersistentStoreProvider";
 import {
···
   } = useAuth();
   const authed = !!agent?.did;
 
-  useEffect(() => {
-    if (agent?.did) {
-      store.set(authedAtom, true);
-    } else {
-      store.set(authedAtom, false);
-    }
-  }, [status, agent, authed]);
-  useEffect(() => {
-    if (agent) {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore is it just me or is the type really weird here it should be Agent not AtpAgent
-      store.set(agentAtom, agent);
-    } else {
-      store.set(agentAtom, null);
-    }
-  }, [status, agent, authed]);
+  // i dont remember why this is even here
+  // useEffect(() => {
+  //   if (agent?.did) {
+  //     store.set(authedAtom, true);
+  //   } else {
+  //     store.set(authedAtom, false);
+  //   }
+  // }, [status, agent, authed]);
+  // useEffect(() => {
+  //   if (agent) {
+  //     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  //     // @ts-ignore is it just me or is the type really weird here it should be Agent not AtpAgent
+  //     store.set(agentAtom, agent);
+  //   } else {
+  //     store.set(agentAtom, null);
+  //   }
+  // }, [status, agent, authed]);
 
   //const { get, set } = usePersistentStore();
   // const [feed, setFeed] = React.useState<any[]>([]);
···
 
   // const savedFeeds = savedFeedsPref?.items || [];
 
-  const identityresultmaybe = useQueryIdentity(agent?.did);
+  const [quickAuth, setQuickAuth] = useAtom(quickAuthAtom);
+  const isAuthRestoring = quickAuth ? status === "loading" : false;
+
+  const identityresultmaybe = useQueryIdentity(!isAuthRestoring ? agent?.did : undefined);
   const identity = identityresultmaybe?.data;
 
   const prefsresultmaybe = useQueryPreferences({
-    agent: agent ?? undefined,
-    pdsUrl: identity?.pds,
+    agent: !isAuthRestoring ? (agent ?? undefined) : undefined,
+    pdsUrl: !isAuthRestoring ? (identity?.pds) : undefined,
   });
   const prefs = prefsresultmaybe?.data;
 
···
     return savedFeedsPref?.items || [];
   }, [prefs]);
 
-  const [persistentSelectedFeed, setPersistentSelectedFeed] =
-    useAtom(selectedFeedUriAtom); // React.useState<string | null>(null);
-  const [unauthedSelectedFeed, setUnauthedSelectedFeed] = React.useState(
-    persistentSelectedFeed
-  ); // React.useState<string | null>(null);
+  const [persistentSelectedFeed, setPersistentSelectedFeed] = useAtom(selectedFeedUriAtom);
+  const [unauthedSelectedFeed, setUnauthedSelectedFeed] = useState(persistentSelectedFeed);
   const selectedFeed = agent?.did
     ? persistentSelectedFeed
     : unauthedSelectedFeed;
···
   }, [scrollPositions]);
 
   useLayoutEffect(() => {
+    if (isAuthRestoring) return;
     const savedPosition = scrollPositions[selectedFeed ?? "null"] ?? 0;
 
     window.scrollTo({ top: savedPosition, behavior: "instant" });
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [selectedFeed]);
+  }, [selectedFeed, isAuthRestoring]);
 
   useLayoutEffect(() => {
-    if (!selectedFeed) return;
+    if (!selectedFeed || isAuthRestoring) return;
 
     const handleScroll = () => {
       scrollPositionsRef.current = {
···
 
       setScrollPositions(scrollPositionsRef.current);
     };
-  }, [selectedFeed, setScrollPositions]);
+  }, [isAuthRestoring, selectedFeed, setScrollPositions]);
 
-  const feedGengetrecordquery = useQueryArbitrary(selectedFeed ?? undefined);
-  const feedServiceDid = (feedGengetrecordquery?.data?.value as any)?.did;
+  const feedGengetrecordquery = useQueryArbitrary(!isAuthRestoring ? selectedFeed ?? undefined : undefined);
+  const feedServiceDid = !isAuthRestoring ? (feedGengetrecordquery?.data?.value as any)?.did as string | undefined : undefined;
 
   // const {
   //   data: feedData,
···
 
   // const feed = feedData?.feed || [];
 
-  const isReadyForAuthedFeed =
-    authed && agent && identity?.pds && feedServiceDid;
-  const isReadyForUnauthedFeed = !authed && selectedFeed;
+  const isReadyForAuthedFeed = !isAuthRestoring && authed && agent && identity?.pds && feedServiceDid;
+  const isReadyForUnauthedFeed = !isAuthRestoring && !authed && selectedFeed;
 
 
   const [isAtTop] = useAtom(isAtTopAtom);
···
     <div
       className={`relative flex flex-col divide-y divide-gray-200 dark:divide-gray-800 ${hidden && "hidden"}`}
     >
-      {savedFeeds.length > 0 ? (
+      {!isAuthRestoring && savedFeeds.length > 0 ? (
         <div className={`flex items-center px-4 py-2 h-[52px] sticky top-0 bg-[var(--header-bg-light)] dark:bg-[var(--header-bg-dark)] ${!isAtTop && "shadow-sm"} sm:shadow-none sm:bg-white sm:dark:bg-gray-950 z-10 border-0 sm:border-b border-gray-200 dark:border-gray-700 overflow-x-auto overflow-y-hidden scroll-thin`}>
           {savedFeeds.map((item: any, idx: number) => {
             const label = item.value.split("/").pop() || item.value;
···
         />
       ))} */}
 
-      {authed && (!identity?.pds || !feedServiceDid) && (
+      {isAuthRestoring || authed && (!identity?.pds || !feedServiceDid) && (
         <div className="p-4 text-center text-gray-500">
           Preparing your feed...
         </div>
       )}
 
-      {isReadyForAuthedFeed || isReadyForUnauthedFeed ? (
+      {!isAuthRestoring && (isReadyForAuthedFeed || isReadyForUnauthedFeed) ? (
         <InfiniteCustomFeed
           key={selectedFeed!}
           feedUri={selectedFeed!}
···
         />
       ) : (
         <div className="p-4 text-center text-gray-500">
-          Select a feed to get started.
+          Loading.......
         </div>
       )}
       {/* {false && restoringScrollPosition && (

src/utils/atoms.ts

···
-import type Agent from "@atproto/api";
 import { atom, createStore, useAtomValue } from "jotai";
 import { atomWithStorage } from "jotai/utils";
 import { useEffect } from "react";
 
 export const store = createStore();
+
+export const quickAuthAtom = atomWithStorage<string | null>(
+  "quickAuth",
+  null
+);
 
 export const selectedFeedUriAtom = atomWithStorage<string | null>(
   "selectedFeedUri",
···
   | { kind: "quote"; subject: string };
 export const composerAtom = atom<ComposerState>({ kind: "closed" });
 
-export const agentAtom = atom<Agent | null>(null);
-export const authedAtom = atom<boolean>(false);
+//export const agentAtom = atom<Agent | null>(null);
+//export const authedAtom = atom<boolean>(false);
 
 export function useAtomCssVar(atom: typeof hueAtom, cssVar: string) {
   const value = useAtomValue(atom);