bye bye weird providers

src/components/UniversalPostRenderer.tsx

···
 import { useNavigate } from "@tanstack/react-router";
-import { useAtom } from 'jotai';
+import { useAtom } from "jotai";
 import * as React from "react";
 import { type SVGProps } from "react";
 
···
   // >(null);
   //const router = useRouter();
 
-  const parsed = React.useMemo(() => parseAtUri(atUri), [atUri]);
-  const did = parsed?.did;
+  //const parsed = React.useMemo(() => parseAtUri(atUri), [atUri]);
+  const parsed = new AtUri(atUri);
+  const did = parsed?.host;
   const rkey = parsed?.rkey;
   // /*mass comment*/ console.log("did", did);
   // /*mass comment*/ console.log("rkey", rkey);
···
   // };
   if (!postQuery?.value) {
     // deleted post more often than a non-resolvable post
-    return (<></>)
+    return <></>;
   }
 
   return (
···
   );
 }
 
+function getAvatarUrl(opProfile: any, did: string) {
+  const link = opProfile?.value?.avatar?.ref?.["$link"];
+  if (!link) return null;
+  return `https://cdn.bsky.app/img/avatar/plain/${did}/${link}@jpeg`;
+}
+
 export function UniversalPostRendererRawRecordShim({
   postRecord,
   profileRecord,
···
   const navigate = useNavigate();
 
   //const { get, set } = usePersistentStore();
-  function getAvatarUrl(opProfile: any) {
-    const link = opProfile?.value?.avatar?.ref?.["$link"];
-    if (!link) return null;
-    return `https://cdn.bsky.app/img/avatar/plain/${resolved?.did}/${link}@jpeg`;
-  }
-
   // const [hydratedEmbed, setHydratedEmbed] = useState<any>(undefined);
 
   // useEffect(() => {
···
     error: embedError,
   } = useHydratedEmbed(postRecord?.value?.embed, resolved?.did);
 
-  const parsedaturi = parseAtUri(aturi);
+  const parsedaturi = new AtUri(aturi); //parseAtUri(aturi);
 
   const fakepost = React.useMemo<AppBskyFeedDefs.PostView>(
     () => ({
···
         did: resolved?.did || "",
         handle: resolved?.handle || "",
         displayName: profileRecord?.value?.displayName || "",
-        avatar: getAvatarUrl(profileRecord) || "",
+        avatar: getAvatarUrl(profileRecord, resolved?.did) || "",
         viewer: undefined,
         labels: profileRecord?.labels || undefined,
         verification: undefined,
···
     }),
     [
       aturi,
-      postRecord,
+      postRecord?.cid,
+      postRecord?.value,
+      postRecord?.labels,
+      resolved?.did,
+      resolved?.handle,
       profileRecord,
       hydratedEmbed,
       repliesCount,
       repostsCount,
       likesCount,
-      resolved,
     ]
   );
 
···
   );
   const feedviewpostreplyhandle = replyhookvalue?.data?.handle;
 
-
-  const aturirepostbydid = repostedby ? new AtUri(repostedby).host : undefined
+  const aturirepostbydid = repostedby ? new AtUri(repostedby).host : undefined;
   const repostedbyhookvalue = useQueryIdentity(
     repostedby ? aturirepostbydid : undefined
   );
···
           parsedaturi &&
           navigate({
             to: "/profile/$did/post/$rkey",
-            params: { did: parsedaturi.did, rkey: parsedaturi.rkey },
+            params: { did: parsedaturi.host, rkey: parsedaturi.rkey },
           })
         }
         // onProfileClick={() => parsedaturi && navigate({to: "/profile/$did",
···
           if (parsedaturi) {
             navigate({
               to: "/profile/$did",
-              params: { did: parsedaturi.did },
+              params: { did: parsedaturi.host },
             });
           }
         }}
···
   );
 }
 
-export function parseAtUri(
-  atUri: string
-): { did: string; collection: string; rkey: string } | null {
-  const PREFIX = "at://";
-  if (!atUri.startsWith(PREFIX)) {
-    return null;
-  }
+// export function parseAtUri(
+//   atUri: string
+// ): { did: string; collection: string; rkey: string } | null {
+//   const PREFIX = "at://";
+//   if (!atUri.startsWith(PREFIX)) {
+//     return null;
+//   }
 
-  const parts = atUri.slice(PREFIX.length).split("/");
+//   const parts = atUri.slice(PREFIX.length).split("/");
 
-  if (parts.length !== 3) {
-    return null;
-  }
+//   if (parts.length !== 3) {
+//     return null;
+//   }
 
-  const [did, collection, rkey] = parts;
+//   const [did, collection, rkey] = parts;
 
-  if (!did || !collection || !rkey) {
-    return null;
-  }
+//   if (!did || !collection || !rkey) {
+//     return null;
+//   }
 
-  return { did, collection, rkey };
-}
+//   return { did, collection, rkey };
+// }
 
 export function MdiCommentOutline(props: SVGProps<SVGSVGElement>) {
   return (
···
     post.viewer?.repost ? true : false
   );
   const [hasLiked, setHasLiked] = useState<boolean>(
-    (post.uri in likedPosts) || post.viewer?.like ? true : false
+    post.uri in likedPosts || post.viewer?.like ? true : false
   );
   const { agent } = useAuth();
   const [likeUri, setLikeUri] = useState<string | undefined>(post.viewer?.like);
···
       setHasLiked(true);
       newLikedPosts[post.uri] = uri;
     }
-    setLikedPosts(newLikedPosts)
+    setLikedPosts(newLikedPosts);
   };
 
   const repostOrUnrepostPost = async () => {
···
     }
   };
 
-  const isRepost = repostedby ? repostedby : extraOptionalItemInfo
-    ? AppBskyFeedDefs.isReasonRepost(extraOptionalItemInfo.reason)
-      ? extraOptionalItemInfo.reason?.by.displayName
-      : undefined
-    : undefined;
+  const isRepost = repostedby
+    ? repostedby
+    : extraOptionalItemInfo
+      ? AppBskyFeedDefs.isReasonRepost(extraOptionalItemInfo.reason)
+        ? extraOptionalItemInfo.reason?.by.displayName
+        : undefined
+      : undefined;
   const isReply = extraOptionalItemInfo
     ? extraOptionalItemInfo.reply
     : undefined;
···
       {!isQuote && (
         <div
           style={{
-            opacity: topReplyLine || (isReply /*&& (true || expanded)*/) ? 0.5 : 0,
+            opacity:
+              topReplyLine || isReply /*&& (true || expanded)*/ ? 0.5 : 0,
             position: "absolute",
             top: 0,
             left: 36, // why 36 ???
···
             {renderTextWithFacets({
               text: (post.record as { text?: string }).text ?? "",
               facets: (post.record.facets as Facet[]) ?? [],
-              navigate: navigate
+              navigate: navigate,
             })}
             {}
           </div>
···
             />
           ) : null}
           {post.embed && depth > 0 && (
+            /*  pretty bad hack imo. its trying to sync up with how the embed shim doesnt
+                hydrate embeds this deep but the connection here is implicit
+                todo: idk make this a real part of the embed shim so its not implicit */
             <>
               <div className="border-gray-300 dark:border-gray-600 p-3 rounded-xl border italic text-gray-400 text-[14px]">
                 (there is an embed here thats too deep to render)
···
             salt={salt}
             onPostClick={(e) => {
               e.stopPropagation();
-              const parsed = parseAtUri(post.uri);
+              const parsed = new AtUri(post.uri); //parseAtUri(post.uri);
               if (parsed) {
                 navigate({
                   to: "/profile/$did/post/$rkey",
-                  params: { did: parsed.did, rkey: parsed.rkey },
+                  params: { did: parsed.host, rkey: parsed.rkey },
                 });
               }
             }}
···
             salt={salt}
             onPostClick={(e) => {
               e.stopPropagation();
-              const parsed = parseAtUri(post.uri);
+              const parsed = new AtUri(post.uri); //parseAtUri(post.uri);
               if (parsed) {
                 navigate({
                   to: "/profile/$did/post/$rkey",
-                  params: { did: parsed.did, rkey: parsed.rkey },
+                  params: { did: parsed.host, rkey: parsed.rkey },
                 });
               }
             }}
···
     for (let i = 0; i < bytes.length; i++) {
       map[byteIndex++] = charIndex;
     }
-    charIndex+=char.length;
+    charIndex += char.length;
   }
 
   return map;
···
             navigate({
               to: "/profile/$did",
               // @ts-expect-error i didnt bother with the correct types here sorry. bsky api types are cursed
-              params: { did: feature.did},
+              params: { did: feature.did },
             });
           }}
         >

src/providers/PassAuthProvider.tsx

···
-import React, { createContext, useState, useEffect, useContext } from "react";
-import { AtpAgent, type AtpSessionData } from "@atproto/api";
-
-interface AuthContextValue {
-  agent: AtpAgent | null;
-  loginStatus: boolean;
-  login: (user: string, password: string, service?: string) => Promise<void>;
-  logout: () => Promise<void>;
-  loading: boolean;
-  authed: boolean | undefined;
-}
-
-const AuthContext = createContext<AuthContextValue>({} as AuthContextValue);
-
-export const AuthProvider = ({ children }: { children: React.ReactNode }) => {
-  const [agent, setAgent] = useState<AtpAgent | null>(null);
-  const [loginStatus, setLoginStatus] = useState(false);
-  const [loading, setLoading] = useState(true);
-  const [increment, setIncrement] = useState(0);
-  const [authed, setAuthed] = useState<boolean | undefined>(undefined);
-
-  useEffect(() => {
-    const initialize = async () => {
-      try {
-        const service = localStorage.getItem("service");
-        // const user = await AsyncStorage.getItem('user');
-        // const password = await AsyncStorage.getItem('password');
-        const session = localStorage.getItem("sess");
-
-        if (service && session) {
-          // /*mass comment*/ console.log("Auto-login service is:", service);
-          const apiAgent = new AtpAgent({ service });
-          try {
-            if (!apiAgent) {
-              // /*mass comment*/ console.log("Agent is null or undefined");
-              return;
-            }
-            let sess: AtpSessionData = JSON.parse(session);
-            // /*mass comment*/ console.log("resuming session is:", sess);
-            const { data } = await apiAgent.resumeSession(sess);
-            // /*mass comment*/ console.log("!!!8!!! agent resume session");
-            setAgent(apiAgent);
-            setLoginStatus(true);
-            setLoading(false);
-            setAuthed(true);
-          } catch (e) {
-            // /*mass comment*/ console.log("Failed to resume session" + e);
-            setLoginStatus(true);
-            localStorage.removeItem("sess");
-            localStorage.removeItem("service");
-            const apiAgent = new AtpAgent({ service: "https://api.bsky.app" });
-            setAgent(apiAgent);
-            setLoginStatus(true);
-            setLoading(false);
-            setAuthed(false);
-            return;
-          }
-        } else {
-          const apiAgent = new AtpAgent({ service: "https://api.bsky.app" });
-          setAgent(apiAgent);
-          setLoginStatus(true);
-          setLoading(false);
-          setAuthed(false);
-        }
-      } catch (e) {
-        // /*mass comment*/ console.log("Failed to auto-login:", e);
-      } finally {
-        setLoading(false);
-      }
-    };
-
-    initialize();
-  }, [increment]);
-
-  const login = async (
-    user: string,
-    password: string,
-    service: string = "https://bsky.social",
-  ) => {
-    try {
-      let sessionthing;
-      const apiAgent = new AtpAgent({
-        service: service,
-        persistSession: (evt, sess) => {
-          sessionthing = sess;
-        },
-      });
-      await apiAgent.login({ identifier: user, password });
-      // /*mass comment*/ console.log("!!!8!!! agent logged on");
-
-      localStorage.setItem("service", service);
-      // await AsyncStorage.setItem('user', user);
-      // await AsyncStorage.setItem('password', password);
-      if (sessionthing) {
-        localStorage.setItem("sess", JSON.stringify(sessionthing));
-      } else {
-        localStorage.setItem("sess", "{}");
-      }
-
-      setAgent(apiAgent);
-      setLoginStatus(true);
-      setAuthed(true);
-    } catch (e) {
-      console.error("Login failed:", e);
-    }
-  };
-
-  const logout = async () => {
-    if (!agent) {
-      console.error("Agent is null or undefined");
-      return;
-    }
-    setLoading(true);
-    try {
-      // check if its even in async storage before removing
-      if (localStorage.getItem("service") && localStorage.getItem("sess")) {
-        localStorage.removeItem("service");
-        localStorage.removeItem("sess");
-      }
-      await agent.logout();
-      // /*mass comment*/ console.log("!!!8!!! agent logout");
-      setLoginStatus(false);
-      setAuthed(undefined);
-      await agent.com.atproto.server.deleteSession();
-      // /*mass comment*/ console.log("!!!8!!! agent deltesession");
-      //setAgent(null);
-      setIncrement(increment + 1);
-    } catch (e) {
-      console.error("Logout failed:", e);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  // why the hell are we doing this
-  /*if (loading) {
-    return <div><span>Laoding...ae</span></div>;
-  }*/
-
-  return (
-    <AuthContext.Provider
-      value={{ agent, loginStatus, login, logout, loading, authed }}
-    >
-      {children}
-    </AuthContext.Provider>
-  );
-};
-
-export const useAuth = () => useContext(AuthContext);

src/providers/PersistentStoreProvider.tsx

···
-import React, { createContext, useContext, useCallback } from "react";
-import { get as idbGet, set as idbSet, del as idbDel } from "idb-keyval";
-
-type PersistentValue = {
-  value: string;
-  time: number;
-};
-
-type PersistentStoreContextType = {
-  get: (key: string) => Promise<PersistentValue | null>;
-  set: (key: string, value: string) => Promise<void>;
-  remove: (key: string) => Promise<void>;
-};
-
-const PersistentStoreContext = createContext<PersistentStoreContextType | null>(
-  null,
-);
-
-export const PersistentStoreProvider: React.FC<{
-  children: React.ReactNode;
-}> = ({ children }) => {
-  const get = useCallback(
-    async (key: string): Promise<PersistentValue | null> => {
-      if (typeof window === "undefined") return null;
-      const raw = await idbGet(key);
-      if (!raw) return null;
-      try {
-        return JSON.parse(raw) as PersistentValue;
-      } catch {
-        return null;
-      }
-    },
-    [],
-  );
-
-  const set = useCallback(async (key: string, value: string) => {
-    if (typeof window === "undefined") return;
-    const entry: PersistentValue = { value, time: Date.now() };
-    await idbSet(key, JSON.stringify(entry));
-  }, []);
-
-  const remove = useCallback(async (key: string) => {
-    if (typeof window === "undefined") return;
-    await idbDel(key);
-  }, []);
-
-  return (
-    <PersistentStoreContext.Provider value={{ get, set, remove }}>
-      {children}
-    </PersistentStoreContext.Provider>
-  );
-};
-
-export const usePersistentStore = (): PersistentStoreContextType => {
-  const context = useContext(PersistentStoreContext);
-  if (!context)
-    throw new Error(
-      "usePersistentStore must be used within a PersistentStoreProvider",
-    );
-  return context;
-};

src/routes/__root.tsx

···
 // dont forget to run this
 // npx @tanstack/router-cli generate
 
-import { useState, type SVGProps } from "react";
+import type { QueryClient } from "@tanstack/react-query";
 import {
-  HeadContent,
+  createRootRouteWithContext,
   Link,
   Outlet,
   Scripts,
-  createRootRoute,
-  createRootRouteWithContext,
   useLocation,
   useNavigate,
 } from "@tanstack/react-router";
 import { TanStackRouterDevtools } from "@tanstack/react-router-devtools";
+import { type SVGProps,useState } from "react";
 import * as React from "react";
+
 import { DefaultCatchBoundary } from "~/components/DefaultCatchBoundary";
 import Login from "~/components/Login";
 import { NotFound } from "~/components/NotFound";
-import appCss from "~/styles/app.css?url";
+import { UnifiedAuthProvider, useAuth } from "~/providers/UnifiedAuthProvider";
 import { seo } from "~/utils/seo";
-import { UnifiedAuthProvider, useAuth } from "~/providers/UnifiedAuthProvider";
-import { PersistentStoreProvider } from "~/providers/PersistentStoreProvider";
-import type Agent from "@atproto/api";
-import type { QueryClient } from "@tanstack/react-query";
 
 export const Route = createRootRouteWithContext<{
   queryClient: QueryClient;
···
 function RootComponent() {
   return (
     <UnifiedAuthProvider>
-      <PersistentStoreProvider>
-        <RootDocument>
-          <Outlet />
-        </RootDocument>
-      </PersistentStoreProvider>
+      <RootDocument>
+        <Outlet />
+      </RootDocument>
     </UnifiedAuthProvider>
   );
 }

src/routes/index.tsx

···
 import { createFileRoute } from "@tanstack/react-router";
-import {
-  CACHE_TIMEOUT,
-  //cachedGetRecord,
-  //cachedResolveIdentity,
-  UniversalPostRendererATURILoader,
-} from "~/components/UniversalPostRenderer";
+import { useAtom } from "jotai";
 import * as React from "react";
+import { useEffect, useLayoutEffect } from "react";
+
+import { InfiniteCustomFeed } from "~/components/InfiniteCustomFeed";
 import { useAuth } from "~/providers/UnifiedAuthProvider";
+import {
+  agentAtom,
+  authedAtom,
+  feedScrollPositionsAtom,
+  selectedFeedUriAtom,
+  store,
+} from "~/utils/atoms";
 //import { usePersistentStore } from "~/providers/PersistentStoreProvider";
 import {
-  useQueryIdentity,
-  useQueryPost,
-  useQueryFeedSkeleton,
-  useQueryPreferences,
-  useQueryArbitrary,
-  constructInfiniteFeedSkeletonQuery,
   constructArbitraryQuery,
   constructIdentityQuery,
+  constructInfiniteFeedSkeletonQuery,
   constructPostQuery,
+  useQueryArbitrary,
+  useQueryIdentity,
+  useQueryPreferences,
 } from "~/utils/useQuery";
-import { InfiniteCustomFeed } from "~/components/InfiniteCustomFeed";
-import { useAtom, useSetAtom } from "jotai";
-import {
-  selectedFeedUriAtom,
-  store,
-  agentAtom,
-  authedAtom,
-  feedScrollPositionsAtom,
-} from "~/utils/atoms";
-import { useEffect, useLayoutEffect } from "react";
 
 export const Route = createFileRoute("/")({
   loader: async ({ context }) => {
···
   }, [status, agent, authed]);
   useEffect(() => {
     if (agent) {
-      // is it just me or is the type really weird here it should be Agent not AtpAgent
+      // 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);
···
     setRestoringScrollPosition(true);
     const savedPosition = scrollPositions[selectedFeed ?? "null"] ?? 0;
 
-    let raf = requestAnimationFrame(() => {
+    const raf = requestAnimationFrame(() => {
       // setRestoringScrollPosition(true);
       // raf = requestAnimationFrame(() => {
       //   window.scrollTo({ top: savedPosition, behavior: "instant" });
···
           Select a feed to get started.
         </div>
       )}
-      {false && restoringScrollPosition && (
+      {/* {false && restoringScrollPosition && (
         <div className="fixed top-1/2 left-1/2 right-1/2">
           restoringScrollPosition
         </div>
-      )}
+      )} */}
     </div>
   );
 }
+// not even used lmaooo
 
-export async function cachedResolveDIDWEBDOC({
-  didweb,
-  cacheTimeout = CACHE_TIMEOUT,
-  get,
-  set,
-}: {
-  didweb: string;
-  cacheTimeout?: number;
-  get: (key: string) => any;
-  set: (key: string, value: string) => void;
-}): Promise<any> {
-  const isDidInput = didweb.startsWith("did:web:");
-  const cacheKey = `didwebdoc:${didweb}`;
-  const now = Date.now();
-  const cached = get(cacheKey);
-  if (
-    cached &&
-    cached.value &&
-    cached.time &&
-    now - cached.time < cacheTimeout
-  ) {
-    try {
-      return JSON.parse(cached.value);
-    } catch {}
-  }
-  const url = `https://free-fly-24.deno.dev/resolve-did-web?did=${encodeURIComponent(
-    didweb
-  )}`;
-  const res = await fetch(url);
-  if (!res.ok) throw new Error("Failed to resolve didwebdoc");
-  const data = await res.json();
-  set(cacheKey, JSON.stringify(data));
-  if (!isDidInput && data.did) {
-    set(`didwebdoc:${data.did}`, JSON.stringify(data));
-  }
-  return data;
-}
+// export async function cachedResolveDIDWEBDOC({
+//   didweb,
+//   cacheTimeout = CACHE_TIMEOUT,
+//   get,
+//   set,
+// }: {
+//   didweb: string;
+//   cacheTimeout?: number;
+//   get: (key: string) => any;
+//   set: (key: string, value: string) => void;
+// }): Promise<any> {
+//   const isDidInput = didweb.startsWith("did:web:");
+//   const cacheKey = `didwebdoc:${didweb}`;
+//   const now = Date.now();
+//   const cached = get(cacheKey);
+//   if (
+//     cached &&
+//     cached.value &&
+//     cached.time &&
+//     now - cached.time < cacheTimeout
+//   ) {
+//     try {
+//       return JSON.parse(cached.value);
+//     } catch (_e) {/* whatever*/ }
+//   }
+//   const url = `https://free-fly-24.deno.dev/resolve-did-web?did=${encodeURIComponent(
+//     didweb
+//   )}`;
+//   const res = await fetch(url);
+//   if (!res.ok) throw new Error("Failed to resolve didwebdoc");
+//   const data = await res.json();
+//   set(cacheKey, JSON.stringify(data));
+//   if (!isDidInput && data.did) {
+//     set(`didwebdoc:${data.did}`, JSON.stringify(data));
+//   }
+//   return data;
+// }
 
 // export async function cachedGetPrefs({
 //   did,

src/routes/notifications.tsx

···
 import { createFileRoute } from "@tanstack/react-router";
-import React, { useEffect, useState, useRef } from "react";
-import { useAuth } from "~/providers/PassAuthProvider";
-import { usePersistentStore } from "~/providers/PersistentStoreProvider";
+import React, { useEffect, useRef,useState } from "react";
+
+import { useAuth } from "~/providers/UnifiedAuthProvider";
 
 const HANDLE_DID_CACHE_TIMEOUT = 60 * 60 * 1000; // 1 hour
 
···
 
 function NotificationsComponent() {
   // /*mass comment*/ console.log("NotificationsComponent render");
-  const { agent, authed, loading: authLoading } = useAuth();
-  const { get, set } = usePersistentStore();
+  const { agent, status } = useAuth();
+  const authed = !!agent?.did;
+  const authLoading = status === "loading";
   const [did, setDid] = useState<string | null>(null);
   const [resolving, setResolving] = useState(false);
   const [error, setError] = useState<string | null>(null);
···
     setResolving(true);
     const cacheKey = `handleDid:${value}`;
     const now = Date.now();
-    const cached = await get(cacheKey);
-    if (
-      cached &&
-      cached.value &&
-      cached.time &&
-      now - cached.time < HANDLE_DID_CACHE_TIMEOUT
-    ) {
-      try {
-        const data = JSON.parse(cached.value);
-        setDid(data.did);
-        setResolving(false);
-        return;
-      } catch {}
-    }
+    const cached = undefined // await get(cacheKey);
+    // if (
+    //   cached &&
+    //   cached.value &&
+    //   cached.time &&
+    //   now - cached.time < HANDLE_DID_CACHE_TIMEOUT
+    // ) {
+    //   try {
+    //     const data = JSON.parse(cached.value);
+    //     setDid(data.did);
+    //     setResolving(false);
+    //     return;
+    //   } catch {}
+    // }
     try {
       const url = `https://free-fly-24.deno.dev/?handle=${encodeURIComponent(value)}`;
       const res = await fetch(url);
       if (!res.ok) throw new Error("Failed to resolve handle");
       const data = await res.json();
-      set(cacheKey, JSON.stringify(data));
+      //set(cacheKey, JSON.stringify(data));
       setDid(data.did);
     } catch (e: any) {
       setError("Failed to resolve handle: " + (e?.message || e));
···
         } catch (e: any) {
           return { error: e?.message || String(e) };
         }
-      }),
+      })
     )
       .then((results) => {
         if (!ignore) setResponses(results);

src/utils/oauthClient.ts

···
-// src/helpers/oauthClient.ts
 import { BrowserOAuthClient, type ClientMetadata } from '@atproto/oauth-client-browser';
 
-// This is your app's PDS for resolving handles if not provided.
-// You might need to host your own or use a public one.
+// i tried making this https://pds-nd.whey.party but cors is annoying as fuck
 const handleResolverPDS = 'https://bsky.social'; 
 
-// This assumes your client-metadata.json is in the /public folder
-// and will be served at the root of your domain.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore this should be fine ? the vite plugin should generate this before errors
 import clientMetadata from '../../public/client-metadata.json' with { type: 'json' };
 
 export const oauthClient = new BrowserOAuthClient({

src/utils/useHydrated.ts

···
   AppBskyFeedPost,
   AtUri,
 } from "@atproto/api";
-import { useEffect, useMemo,useState } from "react";
+import { useMemo } from "react";
 
 import { useQueryIdentity,useQueryPost, useQueryProfile } from "./useQuery";
 
···
   postAuthorDid: string | undefined,
 ) {
   const recordInfo = useMemo(() => {
-    if (
-      AppBskyEmbedRecordWithMedia.isMain(embed)
-    ) {
+    if (AppBskyEmbedRecordWithMedia.isMain(embed)) {
       const recordUri = embed.record.record.uri;
       const quotedAuthorDid = new AtUri(recordUri).hostname;
       return { recordUri, quotedAuthorDid, isRecordType: true };
-    } else 
-    if (
-      AppBskyEmbedRecord.isMain(embed)
-    ) {
+    } else if (AppBskyEmbedRecord.isMain(embed)) {
       const recordUri = embed.record.uri;
       const quotedAuthorDid = new AtUri(recordUri).hostname;
       return { recordUri, quotedAuthorDid, isRecordType: true };
···
       isRecordType: false,
     };
   }, [embed]);
-  const { isRecordType, recordUri, quotedAuthorDid } = recordInfo;
 
+  const { isRecordType, recordUri, quotedAuthorDid } = recordInfo;
 
   const usequerypostresults = useQueryPost(recordUri);
-  // const {
-  //   data: quotedPost,
-  //   isLoading: isLoadingPost,
-  //   error: postError,
-  // } = usequerypostresults
 
-  const profileUri = quotedAuthorDid ? `at://${quotedAuthorDid}/app.bsky.actor.profile/self` : undefined;
+  const profileUri = quotedAuthorDid
+    ? `at://${quotedAuthorDid}/app.bsky.actor.profile/self`
+    : undefined;
 
   const {
     data: quotedProfile,
···
   } = useQueryProfile(profileUri);
 
   const queryidentityresult = useQueryIdentity(quotedAuthorDid);
-  // const {
-  //   data: quotedIdentity,
-  //   isLoading: isLoadingIdentity,
-  //   error: identityError,
-  // } = queryidentityresult
 
-  const [hydratedEmbed, setHydratedEmbed] = useState<
-    HydratedEmbedView | undefined
-  >(undefined);
-
-  useEffect(() => {
-    if (!embed || !postAuthorDid) {
-      setHydratedEmbed(undefined);
-      return;
-    }
+  const hydratedEmbed: HydratedEmbedView | undefined = (() => {
+    if (!embed || !postAuthorDid) return undefined;
 
     if (isRecordType && (!usequerypostresults?.data || !quotedProfile || !queryidentityresult?.data)) {
-      setHydratedEmbed(undefined);
-      return;
+      return undefined;
     }
 
     try {
-      let result: HydratedEmbedView | undefined;
-
       if (AppBskyEmbedImages.isMain(embed)) {
-        result = hydrateEmbedImages(embed, postAuthorDid);
+        return hydrateEmbedImages(embed, postAuthorDid);
       } else if (AppBskyEmbedExternal.isMain(embed)) {
-        result = hydrateEmbedExternal(embed, postAuthorDid);
+        return hydrateEmbedExternal(embed, postAuthorDid);
       } else if (AppBskyEmbedVideo.isMain(embed)) {
-        result = hydrateEmbedVideo(embed, postAuthorDid);
+        return hydrateEmbedVideo(embed, postAuthorDid);
       } else if (AppBskyEmbedRecord.isMain(embed)) {
-        result = hydrateEmbedRecord(
+        return hydrateEmbedRecord(
           embed,
           usequerypostresults?.data,
           quotedProfile,
···
         }
 
         if (hydratedMedia) {
-          result = hydrateEmbedRecordWithMedia(
+          return hydrateEmbedRecordWithMedia(
             embed,
             hydratedMedia,
             usequerypostresults?.data,
···
           );
         }
       }
-      setHydratedEmbed(result);
     } catch (e) {
       console.error("Error hydrating embed", e);
-      setHydratedEmbed(undefined);
+      return undefined;
     }
-  }, [
-    embed,
-    postAuthorDid,
-    isRecordType,
-    usequerypostresults?.data,
-    quotedProfile,
-    queryidentityresult?.data,
-  ]);
+  })();
 
   const isLoading = isRecordType
     ? usequerypostresults?.isLoading || isLoadingProfile || queryidentityresult?.isLoading
     : false;
+
   const error = usequerypostresults?.error || profileError || queryidentityresult?.error;
 
   return { data: hydratedEmbed, isLoading, error };