lycansubscribe

src/components/Import.tsx

···
 import { AtUri } from "@atproto/api";
 import { useNavigate, type UseNavigateResult } from "@tanstack/react-router";
+import { useAtom } from "jotai";
 import { useState } from "react";
 
+import { useAuth } from "~/providers/UnifiedAuthProvider";
+import { lycanURLAtom } from "~/utils/atoms";
+import { useQueryLycanStatus } from "~/utils/useQuery";
+
 /**
  * Basically the best equivalent to Search that i can do
  */
-export function Import() {
-  const [textInput, setTextInput] = useState<string | undefined>();
+export function Import({optionaltextstring}: {optionaltextstring?: string}) {
+  const [textInput, setTextInput] = useState<string | undefined>(optionaltextstring);
   const navigate = useNavigate();
 
+  const { status } = useAuth();
+  const [lycandomain] = useAtom(lycanURLAtom);
+  const lycanExists = lycandomain !== "";
+  const { data: lycanstatusdata } = useQueryLycanStatus();
+  const lycanIndexed = lycanstatusdata?.status === "finished" || false;
+  const authed = status === "signedIn";
+
+  const lycanReady = lycanExists && lycanIndexed && authed;
+
   const handleEnter = () => {
     if (!textInput) return;
     handleImport({
       text: textInput,
       navigate,
+      lycanReady: lycanReady,
     });
   };
 
+  const placeholder = lycanReady ? "Search..." : "Import...";
+
   return (
     <div className="w-full relative">
       <IconMaterialSymbolsSearch className="w-5 h-5 absolute left-4 top-1/2 -translate-y-1/2 text-gray-400 dark:text-gray-500" />
 
       <input
         type="text"
-        placeholder="Import..."
+        placeholder={placeholder}
         value={textInput}
         onChange={(e) => setTextInput(e.target.value)}
         onKeyDown={(e) => {
···
 function handleImport({
   text,
   navigate,
+  lycanReady,
 }: {
   text: string;
   navigate: UseNavigateResult<string>;
+  lycanReady?: boolean;
 }) {
   const trimmed = text.trim();
   // parse text
···
   // } catch {
   //   // continue
   // }
-}
+
+  if (lycanReady) {
+    navigate({ to: "/search", search: { q: text} })
+  }
+}

src/components/UniversalPostRenderer.tsx

···
 
 import defaultpfp from "~/../public/favicon.png";
 import { useAuth } from "~/providers/UnifiedAuthProvider";
+import { renderSnack } from "~/routes/__root";
 import {
   FeedItemRenderAturiLoader,
   FollowButton,
···
     ? tags
         .map((tag) => {
           const encoded = encodeURIComponent(tag);
-          return `<a href="https://${undfediwafrnHost}/search/${encoded}" target="_blank">#${tag.replaceAll(' ','-')}</a>`;
+          return `<a href="https://${undfediwafrnHost}/search/${encoded}" target="_blank">#${tag.replaceAll(" ", "-")}</a>`;
         })
         .join("<br>")
     : "";
···
                               "/post/" +
                               post.uri.split("/").pop()
                           );
+                          renderSnack({
+                            title: "Copied to clipboard!",
+                          });
                         } catch (_e) {
                           // idk
+                          renderSnack({
+                            title: "Failed to copy link",
+                          });
                         }
                       }}
                       style={{
···
                     >
                       <MdiShareVariant />
                     </HitSlopButton>
-                    <span style={btnstyle}>
-                      <MdiMoreHoriz />
-                    </span>
+                    <HitSlopButton
+                      onClick={() => {
+                        renderSnack({
+                          title: "Not implemented yet...",
+                        });
+                      }}
+                    >
+                      <span style={btnstyle}>
+                        <MdiMoreHoriz />
+                      </span>
+                    </HitSlopButton>
                   </div>
                 </div>
               )}

src/routes/search.tsx

···
-import { createFileRoute } from "@tanstack/react-router";
+import type { Agent } from "@atproto/api";
+import { useQueryClient } from "@tanstack/react-query";
+import { createFileRoute, useSearch } from "@tanstack/react-router";
+import { useAtom } from "jotai";
+import { useMemo } from "react";
 
 import { Header } from "~/components/Header";
 import { Import } from "~/components/Import";
+import {
+  ReusableTabRoute,
+  useReusableTabScrollRestore,
+} from "~/components/ReusableTabRoute";
+import { UniversalPostRendererATURILoader } from "~/components/UniversalPostRenderer";
+import { useAuth } from "~/providers/UnifiedAuthProvider";
+import { lycanURLAtom } from "~/utils/atoms";
+import {
+  constructLycanRequestIndexQuery,
+  useInfiniteQueryLycanSearch,
+  useQueryIdentity,
+  useQueryLycanStatus,
+} from "~/utils/useQuery";
+
+import { renderSnack } from "./__root";
 
 export const Route = createFileRoute("/search")({
   component: Search,
 });
 
 export function Search() {
+  const queryClient = useQueryClient();
+  const { agent, status } = useAuth();
+  const { data: identity } = useQueryIdentity(agent?.did);
+  const [lycandomain] = useAtom(lycanURLAtom);
+  const lycanExists = lycandomain !== "";
+  const { data: lycanstatusdata } = useQueryLycanStatus();
+  const lycanIndexed = lycanstatusdata?.status === "finished" || false;
+  const authed = status === "signedIn";
+
+  const lycanReady = lycanExists && lycanIndexed && authed;
+
+  const { q }: { q: string } = useSearch({ from: "/search" });
+
+  //const lycanIndexed = useQuery();
+
+  const maintext = !lycanExists
+    ? "Sorry we dont have search. But instead, you can load some of these types of content into Red Dwarf:"
+    : authed
+      ? lycanReady
+        ? "Lycan Search is enabled and ready! Type to search posts you've interacted with in the past. You can also load some of these types of content into Red Dwarf:"
+        : "Sorry, while Lycan Search is enabled, you are not indexed. Index below please. You can load some of these types of content into Red Dwarf:"
+      : "Sorry, while Lycan Search is enabled, you are unauthed. Please log in to use Lycan. You can load some of these types of content into Red Dwarf:";
+
+  async function index(opts: {
+    agent?: Agent;
+    isAuthed: boolean;
+    pdsUrl?: string;
+    feedServiceDid?: string;
+  }) {
+    renderSnack({
+      title: "Registering account...",
+    });
+    try {
+      const response = await queryClient.fetchQuery(
+        constructLycanRequestIndexQuery(opts)
+      );
+      if (
+        response?.message !== "Import has already started" ||
+        response?.message !== "Import has already started"
+      ) {
+        renderSnack({
+          title: "Registration failed!",
+          description: "Unknown server error (2)",
+        });
+      } else {
+        renderSnack({
+          title: "Succesfully sent registration request!",
+          description: "Please wait for the server to index your account",
+        });
+      }
+    } catch {
+      renderSnack({
+        title: "Registration failed!",
+        description: "Unknown server error (1)",
+      });
+    }
+  }
+
   return (
     <>
       <Header
···
         }}
       />
       <div className=" flex flex-col items-center mt-4 mx-4 gap-4">
-        <Import />
+        <Import optionaltextstring={q} />
         <div className="flex flex-col">
-          <p className="text-gray-600 dark:text-gray-400">
-            Sorry we dont have search. But instead, you can load some of these
-            types of content into Red Dwarf:
-          </p>
+          <p className="text-gray-600 dark:text-gray-400">{maintext}</p>
           <ul className="list-disc list-inside mt-2 text-gray-600 dark:text-gray-400">
             <li>
-              Bluesky URLs from supported clients (like{" "}
+              Bluesky URLs (from supported clients) (like{" "}
               <code className="text-sm">bsky.app</code> or{" "}
               <code className="text-sm">deer.social</code>).
             </li>
···
               ).
             </li>
             <li>
-              Plain handles (like{" "}
+              User Handles (like{" "}
               <code className="text-sm">@username.bsky.social</code>).
             </li>
             <li>
-              Direct DIDs (Decentralized Identifiers, starting with{" "}
+              DIDs (Decentralized Identifiers, starting with{" "}
               <code className="text-sm">did:</code>).
             </li>
           </ul>
···
             Simply paste one of these into the import field above and press
             Enter to load the content.
           </p>
+
+          {lycanExists && authed && !lycanReady ? (
+            <div className="mt-4 mx-auto">
+              <button
+                onClick={() =>
+                  index({
+                    agent: agent || undefined,
+                    isAuthed: status === "signedIn",
+                    pdsUrl: identity?.pds,
+                    feedServiceDid: "did:web:" + lycandomain,
+                  })
+                }
+                className="px-6 py-2 h-12 rounded-full bg-gray-100 dark:bg-gray-800 
+                             text-gray-700 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700 transition"
+              >
+                Index my Account
+              </button>
+            </div>
+          ) : (
+            <></>
+          )}
         </div>
       </div>
+      {q ? <SearchTabs query={q} /> : <></>}
     </>
   );
 }
+
+function SearchTabs({ query }: { query: string }) {
+  return (
+    <div>
+      <ReusableTabRoute
+        route={`search` + query}
+        tabs={{
+          Likes: <LycanTab query={query} type={"likes"} key={"likes"} />,
+          Reposts: <LycanTab query={query} type={"reposts"} key={"reposts"} />,
+          Quotes: <LycanTab query={query} type={"quotes"} key={"quotes"} />,
+          Pins: <LycanTab query={query} type={"pins"} key={"pins"} />,
+        }}
+      />
+    </div>
+  );
+}
+
+function LycanTab({
+  query,
+  type,
+}: {
+  query: string;
+  type: "likes" | "pins" | "reposts" | "quotes";
+}) {
+  useReusableTabScrollRestore("search" + query);
+
+  const {
+    data: postsData,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+    isLoading: arePostsLoading,
+  } = useInfiniteQueryLycanSearch({ query: query, type: type });
+
+  const posts = useMemo(
+    () =>
+      postsData?.pages.flatMap((page) => {
+        if (page) {
+          return page.posts;
+        } else {
+          return [];
+        }
+      }) ?? [],
+    [postsData]
+  );
+
+  return (
+    <>
+      {/* <div className="text-gray-500 dark:text-gray-400 text-lg font-semibold my-3 mx-4">
+        Posts
+      </div> */}
+      <div>
+        {posts.map((post) => (
+          <UniversalPostRendererATURILoader
+            key={post}
+            atUri={post}
+            feedviewpost={true}
+          />
+        ))}
+      </div>
+
+      {/* Loading and "Load More" states */}
+      {arePostsLoading && posts.length === 0 && (
+        <div className="p-4 text-center text-gray-500">Loading posts...</div>
+      )}
+      {isFetchingNextPage && (
+        <div className="p-4 text-center text-gray-500">Loading more...</div>
+      )}
+      {hasNextPage && !isFetchingNextPage && (
+        <button
+          onClick={() => fetchNextPage()}
+          className="w-[calc(100%-2rem)] mx-4 my-4 px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-800 dark:text-gray-200 rounded-lg hover:bg-gray-200 dark:hover:bg-gray-700 font-semibold"
+        >
+          Load More Posts
+        </button>
+      )}
+      {posts.length === 0 && !arePostsLoading && (
+        <div className="p-4 text-center text-gray-500">No posts found.</div>
+      )}
+    </>
+  );
+
+  return <></>;
+}

src/routes/settings.tsx

···
   defaultconstellationURL,
   defaulthue,
   defaultImgCDN,
+  defaultLycanURL,
   defaultslingshotURL,
   defaultVideoCDN,
   enableBitesAtom,
···
   enableWafrnTextAtom,
   hueAtom,
   imgCDNAtom,
+  lycanURLAtom,
   slingshotURLAtom,
   videoCDNAtom,
 } from "~/utils/atoms";
···
         title={"Video CDN"}
         description={"Customize the Slingshot instance to be used by Red Dwarf"}
         init={defaultVideoCDN}
+      />
+      <TextInputSetting
+        atom={lycanURLAtom}
+        title={"Lycan Search"}
+        description={"Enable text search across posts you've interacted with"}
+        init={defaultLycanURL}
       />
 
       <SettingHeading title="Experimental" />

src/utils/atoms.ts

···
   defaultVideoCDN
 );
 
+export const defaultLycanURL = "";
+export const lycanURLAtom = atomWithStorage<string>(
+  "lycanURL",
+  defaultLycanURL
+);
+
 export const defaulthue = 28;
 export const hueAtom = atomWithStorage<number>("hue", defaulthue);
 

src/utils/useQuery.ts

···
   queryOptions,
   useInfiniteQuery,
   useQuery,
-  type UseQueryResult} from "@tanstack/react-query";
+  type UseQueryResult,
+} from "@tanstack/react-query";
 import { useAtom } from "jotai";
 
-import { constellationURLAtom, slingshotURLAtom } from "./atoms";
+import { useAuth } from "~/providers/UnifiedAuthProvider";
+
+import { constellationURLAtom, lycanURLAtom, slingshotURLAtom } from "./atoms";
 
-export function constructIdentityQuery(didorhandle?: string, slingshoturl?: string) {
+export function constructIdentityQuery(
+  didorhandle?: string,
+  slingshoturl?: string
+) {
   return queryOptions({
     queryKey: ["identity", didorhandle],
     queryFn: async () => {
-      if (!didorhandle) return undefined as undefined
+      if (!didorhandle) return undefined as undefined;
       const res = await fetch(
         `https://${slingshoturl}/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=${encodeURIComponent(didorhandle)}`
       );
···
       }
     },
     staleTime: /*0,//*/ 5 * 60 * 1000, // 5 minutes
-    gcTime: /*0//*/5 * 60 * 1000,
+    gcTime: /*0//*/ 5 * 60 * 1000,
   });
 }
 export function useQueryIdentity(didorhandle: string): UseQueryResult<
···
   },
   Error
 >;
-export function useQueryIdentity(): UseQueryResult<
-      undefined,
-      Error
-    >
-export function useQueryIdentity(didorhandle?: string):
-  UseQueryResult<
-      {
-        did: string;
-        handle: string;
-        pds: string;
-        signing_key: string;
-      } | undefined,
-      Error
-    >
+export function useQueryIdentity(): UseQueryResult<undefined, Error>;
+export function useQueryIdentity(didorhandle?: string): UseQueryResult<
+  | {
+      did: string;
+      handle: string;
+      pds: string;
+      signing_key: string;
+    }
+  | undefined,
+  Error
+>;
 export function useQueryIdentity(didorhandle?: string) {
-  const [slingshoturl] = useAtom(slingshotURLAtom)
+  const [slingshoturl] = useAtom(slingshotURLAtom);
   return useQuery(constructIdentityQuery(didorhandle, slingshoturl));
 }
 
···
   return queryOptions({
     queryKey: ["post", uri],
     queryFn: async () => {
-      if (!uri) return undefined as undefined
+      if (!uri) return undefined as undefined;
       const res = await fetch(
         `https://${slingshoturl}/xrpc/com.bad-example.repo.getUriRecord?at_uri=${encodeURIComponent(uri)}`
       );
···
         return undefined;
       }
       if (res.status === 400) return undefined;
-      if (data?.error === "InvalidRequest" && data.message?.includes("Could not find repo")) {
+      if (
+        data?.error === "InvalidRequest" &&
+        data.message?.includes("Could not find repo")
+      ) {
         return undefined; // cache “not found”
       }
       try {
         if (!res.ok) throw new Error("Failed to fetch post");
-        return (data) as {
+        return data as {
           uri: string;
           cid: string;
           value: any;
···
       return failureCount < 2;
     },
     staleTime: /*0,//*/ 5 * 60 * 1000, // 5 minutes
-    gcTime: /*0//*/5 * 60 * 1000,
+    gcTime: /*0//*/ 5 * 60 * 1000,
   });
 }
 export function useQueryPost(uri: string): UseQueryResult<
···
   },
   Error
 >;
-export function useQueryPost(): UseQueryResult<
-      undefined,
-      Error
-    >
-export function useQueryPost(uri?: string):
-  UseQueryResult<
-      {
-        uri: string;
-        cid: string;
-        value: ATPAPI.AppBskyFeedPost.Record;
-      } | undefined,
-      Error
-    >
+export function useQueryPost(): UseQueryResult<undefined, Error>;
+export function useQueryPost(uri?: string): UseQueryResult<
+  | {
+      uri: string;
+      cid: string;
+      value: ATPAPI.AppBskyFeedPost.Record;
+    }
+  | undefined,
+  Error
+>;
 export function useQueryPost(uri?: string) {
-  const [slingshoturl] = useAtom(slingshotURLAtom)
+  const [slingshoturl] = useAtom(slingshotURLAtom);
   return useQuery(constructPostQuery(uri, slingshoturl));
 }
 
···
   return queryOptions({
     queryKey: ["profile", uri],
     queryFn: async () => {
-      if (!uri) return undefined as undefined
+      if (!uri) return undefined as undefined;
       const res = await fetch(
         `https://${slingshoturl}/xrpc/com.bad-example.repo.getUriRecord?at_uri=${encodeURIComponent(uri)}`
       );
···
         return undefined;
       }
       if (res.status === 400) return undefined;
-      if (data?.error === "InvalidRequest" && data.message?.includes("Could not find repo")) {
+      if (
+        data?.error === "InvalidRequest" &&
+        data.message?.includes("Could not find repo")
+      ) {
         return undefined; // cache “not found”
       }
       try {
         if (!res.ok) throw new Error("Failed to fetch post");
-        return (data) as {
+        return data as {
           uri: string;
           cid: string;
           value: any;
···
       return failureCount < 2;
     },
     staleTime: /*0,//*/ 5 * 60 * 1000, // 5 minutes
-    gcTime: /*0//*/5 * 60 * 1000,
+    gcTime: /*0//*/ 5 * 60 * 1000,
   });
 }
 export function useQueryProfile(uri: string): UseQueryResult<
···
   },
   Error
 >;
-export function useQueryProfile(): UseQueryResult<
-  undefined,
-  Error
->;
-export function useQueryProfile(uri?: string):
-  UseQueryResult<
-    {
+export function useQueryProfile(): UseQueryResult<undefined, Error>;
+export function useQueryProfile(uri?: string): UseQueryResult<
+  | {
       uri: string;
       cid: string;
       value: ATPAPI.AppBskyActorProfile.Record;
-    } | undefined,
-    Error
-  >
+    }
+  | undefined,
+  Error
+>;
 export function useQueryProfile(uri?: string) {
-  const [slingshoturl] = useAtom(slingshotURLAtom)
+  const [slingshoturl] = useAtom(slingshotURLAtom);
   return useQuery(constructProfileQuery(uri, slingshoturl));
 }
 
···
 //   method: "/links/all",
 //   target: string
 // ): QueryOptions<linksAllResponse, Error>;
-export function constructConstellationQuery(query?:{
-  constellation: string,
+export function constructConstellationQuery(query?: {
+  constellation: string;
   method:
     | "/links"
     | "/links/distinct-dids"
     | "/links/count"
     | "/links/count/distinct-dids"
     | "/links/all"
-    | "undefined",
-  target: string,
-  collection?: string,
-  path?: string,
-  cursor?: string,
-  dids?: string[]
-}
-) {
+    | "undefined";
+  target: string;
+  collection?: string;
+  path?: string;
+  cursor?: string;
+  dids?: string[];
+}) {
   // : QueryOptions<
   //   | linksRecordsResponse
   //   | linksDidsResponse
···
   //   Error
   // >
   return queryOptions({
-    queryKey: ["constellation", query?.method, query?.target, query?.collection, query?.path, query?.cursor, query?.dids] as const,
+    queryKey: [
+      "constellation",
+      query?.method,
+      query?.target,
+      query?.collection,
+      query?.path,
+      query?.cursor,
+      query?.dids,
+    ] as const,
     queryFn: async () => {
-      if (!query || query.method === "undefined") return undefined as undefined
-      const method = query.method
-      const target = query.target
-      const collection = query?.collection
-      const path = query?.path
-      const cursor = query.cursor
-      const dids = query?.dids
+      if (!query || query.method === "undefined") return undefined as undefined;
+      const method = query.method;
+      const target = query.target;
+      const collection = query?.collection;
+      const path = query?.path;
+      const cursor = query.cursor;
+      const dids = query?.dids;
       const res = await fetch(
         `https://${query.constellation}${method}?target=${encodeURIComponent(target)}${collection ? `&collection=${encodeURIComponent(collection)}` : ""}${path ? `&path=${encodeURIComponent(path)}` : ""}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}${dids ? dids.map((did) => `&did=${encodeURIComponent(did)}`).join("") : ""}`
       );
···
     },
     // enforce short lifespan
     staleTime: /*0,//*/ 5 * 60 * 1000, // 5 minutes
-    gcTime: /*0//*/5 * 60 * 1000,
+    gcTime: /*0//*/ 5 * 60 * 1000,
   });
 }
 // todo do more of these instead of overloads since overloads sucks so much apparently
···
   cursor?: string;
 }): UseQueryResult<linksCountResponse, Error> | undefined {
   //if (!query) return;
-  const [constellationurl] = useAtom(constellationURLAtom)
+  const [constellationurl] = useAtom(constellationURLAtom);
   const queryres = useQuery(
-    constructConstellationQuery(query && {constellation: constellationurl, ...query})
+    constructConstellationQuery(
+      query && { constellation: constellationurl, ...query }
+    )
   ) as unknown as UseQueryResult<linksCountResponse, Error>;
   if (!query) {
-    return undefined as undefined; 
+    return undefined as undefined;
   }
   return queryres as UseQueryResult<linksCountResponse, Error>;
 }
···
     >
   | undefined {
   //if (!query) return;
-  const [constellationurl] = useAtom(constellationURLAtom)
+  const [constellationurl] = useAtom(constellationURLAtom);
   return useQuery(
-    constructConstellationQuery(query && {constellation: constellationurl, ...query})
+    constructConstellationQuery(
+      query && { constellation: constellationurl, ...query }
+    )
   );
 }
 
···
 }) {
   return queryOptions({
     // The query key includes all dependencies to ensure it refetches when they change
-    queryKey: ["feedSkeleton", options?.feedUri, { isAuthed: options?.isAuthed, did: options?.agent?.did }],
+    queryKey: [
+      "feedSkeleton",
+      options?.feedUri,
+      { isAuthed: options?.isAuthed, did: options?.agent?.did },
+    ],
     queryFn: async () => {
-      if (!options) return undefined as undefined
+      if (!options) return undefined as undefined;
       const { feedUri, agent, isAuthed, pdsUrl, feedServiceDid } = options;
       if (isAuthed) {
         // Authenticated flow
         if (!agent || !pdsUrl || !feedServiceDid) {
-          throw new Error("Missing required info for authenticated feed fetch.");
+          throw new Error(
+            "Missing required info for authenticated feed fetch."
+          );
         }
         const url = `${pdsUrl}/xrpc/app.bsky.feed.getFeedSkeleton?feed=${encodeURIComponent(feedUri)}`;
         const res = await agent.fetchHandler(url, {
···
             "Content-Type": "application/json",
           },
         });
-        if (!res.ok) throw new Error(`Authenticated feed fetch failed: ${res.statusText}`);
+        if (!res.ok)
+          throw new Error(`Authenticated feed fetch failed: ${res.statusText}`);
         return (await res.json()) as ATPAPI.AppBskyFeedGetFeedSkeleton.OutputSchema;
       } else {
         // Unauthenticated flow (using a public PDS/AppView)
         const url = `https://discover.bsky.app/xrpc/app.bsky.feed.getFeedSkeleton?feed=${encodeURIComponent(feedUri)}`;
         const res = await fetch(url);
-        if (!res.ok) throw new Error(`Public feed fetch failed: ${res.statusText}`);
+        if (!res.ok)
+          throw new Error(`Public feed fetch failed: ${res.statusText}`);
         return (await res.json()) as ATPAPI.AppBskyFeedGetFeedSkeleton.OutputSchema;
       }
     },
···
   return useQuery(constructFeedSkeletonQuery(options));
 }
 
-export function constructPreferencesQuery(agent?: ATPAPI.Agent | undefined, pdsUrl?: string | undefined) {
+export function constructPreferencesQuery(
+  agent?: ATPAPI.Agent | undefined,
+  pdsUrl?: string | undefined
+) {
   return queryOptions({
-    queryKey: ['preferences', agent?.did],
+    queryKey: ["preferences", agent?.did],
     queryFn: async () => {
       if (!agent || !pdsUrl) throw new Error("Agent or PDS URL not available");
       const url = `${pdsUrl}/xrpc/app.bsky.actor.getPreferences`;
···
   });
 }
 export function useQueryPreferences(options: {
-  agent?: ATPAPI.Agent | undefined, pdsUrl?: string | undefined
+  agent?: ATPAPI.Agent | undefined;
+  pdsUrl?: string | undefined;
 }) {
   return useQuery(constructPreferencesQuery(options.agent, options.pdsUrl));
 }
-
-
 
 export function constructArbitraryQuery(uri?: string, slingshoturl?: string) {
   return queryOptions({
     queryKey: ["arbitrary", uri],
     queryFn: async () => {
-      if (!uri) return undefined as undefined
+      if (!uri) return undefined as undefined;
       const res = await fetch(
         `https://${slingshoturl}/xrpc/com.bad-example.repo.getUriRecord?at_uri=${encodeURIComponent(uri)}`
       );
···
         return undefined;
       }
       if (res.status === 400) return undefined;
-      if (data?.error === "InvalidRequest" && data.message?.includes("Could not find repo")) {
+      if (
+        data?.error === "InvalidRequest" &&
+        data.message?.includes("Could not find repo")
+      ) {
         return undefined; // cache “not found”
       }
       try {
         if (!res.ok) throw new Error("Failed to fetch post");
-        return (data) as {
+        return data as {
           uri: string;
           cid: string;
           value: any;
···
       return failureCount < 2;
     },
     staleTime: /*0,//*/ 5 * 60 * 1000, // 5 minutes
-    gcTime: /*0//*/5 * 60 * 1000,
+    gcTime: /*0//*/ 5 * 60 * 1000,
   });
 }
 export function useQueryArbitrary(uri: string): UseQueryResult<
···
   },
   Error
 >;
-export function useQueryArbitrary(): UseQueryResult<
-  undefined,
-  Error
->;
+export function useQueryArbitrary(): UseQueryResult<undefined, Error>;
 export function useQueryArbitrary(uri?: string): UseQueryResult<
-  {
-    uri: string;
-    cid: string;
-    value: any;
-  } | undefined,
+  | {
+      uri: string;
+      cid: string;
+      value: any;
+    }
+  | undefined,
   Error
 >;
 export function useQueryArbitrary(uri?: string) {
-  const [slingshoturl] = useAtom(slingshotURLAtom)
+  const [slingshoturl] = useAtom(slingshotURLAtom);
   return useQuery(constructArbitraryQuery(uri, slingshoturl));
 }
 
-export function constructFallbackNothingQuery(){
+export function constructFallbackNothingQuery() {
   return queryOptions({
     queryKey: ["nothing"],
     queryFn: async () => {
-      return undefined
+      return undefined;
     },
   });
 }
···
   }[];
 };
 
-export function constructAuthorFeedQuery(did: string, pdsUrl: string, collection: string = "app.bsky.feed.post") {
+export function constructAuthorFeedQuery(
+  did: string,
+  pdsUrl: string,
+  collection: string = "app.bsky.feed.post"
+) {
   return queryOptions({
-    queryKey: ['authorFeed', did, collection],
+    queryKey: ["authorFeed", did, collection],
     queryFn: async ({ pageParam }: QueryFunctionContext) => {
       const limit = 25;
-      
+
       const cursor = pageParam as string | undefined;
-      const cursorParam = cursor ? `&cursor=${cursor}` : '';
-      
+      const cursorParam = cursor ? `&cursor=${cursor}` : "";
+
       const url = `${pdsUrl}/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=${collection}&limit=${limit}${cursorParam}`;
-      
+
       const res = await fetch(url);
       if (!res.ok) throw new Error("Failed to fetch author's posts");
-      
+
       return res.json() as Promise<ListRecordsResponse>;
     },
   });
 }
 
-export function useInfiniteQueryAuthorFeed(did: string | undefined, pdsUrl: string | undefined, collection?: string) {
-  const { queryKey, queryFn } = constructAuthorFeedQuery(did!, pdsUrl!, collection);
-  
+export function useInfiniteQueryAuthorFeed(
+  did: string | undefined,
+  pdsUrl: string | undefined,
+  collection?: string
+) {
+  const { queryKey, queryFn } = constructAuthorFeedQuery(
+    did!,
+    pdsUrl!,
+    collection
+  );
+
   return useInfiniteQuery({
     queryKey,
     queryFn,
···
   // todo the hell is a unauthedfeedurl
   unauthedfeedurl?: string;
 }) {
-  const { feedUri, agent, isAuthed, pdsUrl, feedServiceDid, unauthedfeedurl } = options;
-  
+  const { feedUri, agent, isAuthed, pdsUrl, feedServiceDid, unauthedfeedurl } =
+    options;
+
   return queryOptions({
     queryKey: ["feedSkeleton", feedUri, { isAuthed, did: agent?.did }],
-    
-    queryFn: async ({ pageParam }: QueryFunctionContext): Promise<FeedSkeletonPage> => {
+
+    queryFn: async ({
+      pageParam,
+    }: QueryFunctionContext): Promise<FeedSkeletonPage> => {
       const cursorParam = pageParam ? `&cursor=${pageParam}` : "";
-      
+
       if (isAuthed && !unauthedfeedurl) {
         if (!agent || !pdsUrl || !feedServiceDid) {
-          throw new Error("Missing required info for authenticated feed fetch.");
+          throw new Error(
+            "Missing required info for authenticated feed fetch."
+          );
         }
         const url = `${pdsUrl}/xrpc/app.bsky.feed.getFeedSkeleton?feed=${encodeURIComponent(feedUri)}${cursorParam}`;
         const res = await agent.fetchHandler(url, {
···
             "Content-Type": "application/json",
           },
         });
-        if (!res.ok) throw new Error(`Authenticated feed fetch failed: ${res.statusText}`);
+        if (!res.ok)
+          throw new Error(`Authenticated feed fetch failed: ${res.statusText}`);
         return (await res.json()) as FeedSkeletonPage;
       } else {
         const url = `https://${unauthedfeedurl ? unauthedfeedurl : "discover.bsky.app"}/xrpc/app.bsky.feed.getFeedSkeleton?feed=${encodeURIComponent(feedUri)}${cursorParam}`;
         const res = await fetch(url);
-        if (!res.ok) throw new Error(`Public feed fetch failed: ${res.statusText}`);
+        if (!res.ok)
+          throw new Error(`Public feed fetch failed: ${res.statusText}`);
         return (await res.json()) as FeedSkeletonPage;
       }
     },
···
   unauthedfeedurl?: string;
 }) {
   const { queryKey, queryFn } = constructInfiniteFeedSkeletonQuery(options);
-  
-  return {...useInfiniteQuery({
-    queryKey,
-    queryFn,
-    initialPageParam: undefined as never,
-    getNextPageParam: (lastPage) => lastPage.cursor as null | undefined,
-    staleTime: Infinity,
-    refetchOnWindowFocus: false,
-    enabled: !!options.feedUri && (options.isAuthed ? (!!options.agent && !!options.pdsUrl || !!options.unauthedfeedurl) && !!options.feedServiceDid : true),
-  }), queryKey: queryKey};
+
+  return {
+    ...useInfiniteQuery({
+      queryKey,
+      queryFn,
+      initialPageParam: undefined as never,
+      getNextPageParam: (lastPage) => lastPage.cursor as null | undefined,
+      staleTime: Infinity,
+      refetchOnWindowFocus: false,
+      enabled:
+        !!options.feedUri &&
+        (options.isAuthed
+          ? ((!!options.agent && !!options.pdsUrl) ||
+              !!options.unauthedfeedurl) &&
+            !!options.feedServiceDid
+          : true),
+    }),
+    queryKey: queryKey,
+  };
 }
-
 
 export function yknowIReallyHateThisButWhateverGuardedConstructConstellationInfiniteQueryLinks(query?: {
-  constellation: string,
-  method: '/links'
-  target?: string
-  collection: string
-  path: string,
-  staleMult?: number
+  constellation: string;
+  method: "/links";
+  target?: string;
+  collection: string;
+  path: string;
+  staleMult?: number;
 }) {
   const safemult = query?.staleMult ?? 1;
   // console.log(
···
   return infiniteQueryOptions({
     enabled: !!query?.target,
     queryKey: [
-      'reddwarf_constellation',
+      "reddwarf_constellation",
       query?.method,
       query?.target,
       query?.collection,
       query?.path,
     ] as const,
 
-    queryFn: async ({pageParam}: {pageParam?: string}) => {
-      if (!query || !query?.target) return undefined
+    queryFn: async ({ pageParam }: { pageParam?: string }) => {
+      if (!query || !query?.target) return undefined;
 
-      const method = query.method
-      const target = query.target
-      const collection = query.collection
-      const path = query.path
-      const cursor = pageParam
+      const method = query.method;
+      const target = query.target;
+      const collection = query.collection;
+      const path = query.path;
+      const cursor = pageParam;
 
       const res = await fetch(
         `https://${query.constellation}${method}?target=${encodeURIComponent(target)}${
-          collection ? `&collection=${encodeURIComponent(collection)}` : ''
-        }${path ? `&path=${encodeURIComponent(path)}` : ''}${
-          cursor ? `&cursor=${encodeURIComponent(cursor)}` : ''
-        }`,
-      )
+          collection ? `&collection=${encodeURIComponent(collection)}` : ""
+        }${path ? `&path=${encodeURIComponent(path)}` : ""}${
+          cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""
+        }`
+      );
 
-      if (!res.ok) throw new Error('Failed to fetch')
+      if (!res.ok) throw new Error("Failed to fetch");
 
-      return (await res.json()) as linksRecordsResponse
+      return (await res.json()) as linksRecordsResponse;
     },
 
-    getNextPageParam: lastPage => {
-      return (lastPage as any)?.cursor ?? undefined
+    getNextPageParam: (lastPage) => {
+      return (lastPage as any)?.cursor ?? undefined;
     },
     initialPageParam: undefined,
     staleTime: 5 * 60 * 1000 * safemult,
     gcTime: 5 * 60 * 1000 * safemult,
-  })
-}
+  });
+}
+
+export function useQueryLycanStatus() {
+  const [lycanurl] = useAtom(lycanURLAtom);
+  const { agent, status } = useAuth();
+  const { data: identity } = useQueryIdentity(agent?.did);
+  return useQuery(
+    constructLycanStatusCheckQuery({
+      agent: agent || undefined,
+      isAuthed: status === "signedIn",
+      pdsUrl: identity?.pds,
+      feedServiceDid: "did:web:"+lycanurl,
+    })
+  );
+}
+
+export function constructLycanStatusCheckQuery(options: {
+  agent?: ATPAPI.Agent;
+  isAuthed: boolean;
+  pdsUrl?: string;
+  feedServiceDid?: string;
+}) {
+  const { agent, isAuthed, pdsUrl, feedServiceDid } = options;
+
+  return queryOptions({
+    queryKey: ["lycanStatus", { isAuthed, did: agent?.did }],
+
+    queryFn: async () => {
+      if (isAuthed && agent && pdsUrl && feedServiceDid) {
+        const url = `${pdsUrl}/xrpc/blue.feeds.lycan.getImportStatus`;
+        const res = await agent.fetchHandler(url, {
+          method: "GET",
+          headers: {
+            "atproto-proxy": `${feedServiceDid}#lycan`,
+            "Content-Type": "application/json",
+          },
+        });
+        if (!res.ok)
+          throw new Error(
+            `Authenticated lycan status fetch failed: ${res.statusText}`
+          );
+        return (await res.json()) as statuschek;
+      }
+      return undefined;
+    },
+  });
+}
+
+type statuschek = {
+  [key: string]: unknown;
+  error?: "MethodNotImplemented";
+  message?: "Method Not Implemented";
+  status?: "finished";
+};
+
+type importtype = {
+  message?: "Import has already started" | "Import has been scheduled"
+}
+
+export function constructLycanRequestIndexQuery(options: {
+  agent?: ATPAPI.Agent;
+  isAuthed: boolean;
+  pdsUrl?: string;
+  feedServiceDid?: string;
+}) {
+  const { agent, isAuthed, pdsUrl, feedServiceDid } = options;
+
+  return queryOptions({
+    queryKey: ["lycanIndex", { isAuthed, did: agent?.did }],
+
+    queryFn: async () => {
+      if (isAuthed && agent && pdsUrl && feedServiceDid) {
+        const url = `${pdsUrl}/xrpc/blue.feeds.lycan.startImport`;
+        const res = await agent.fetchHandler(url, {
+          method: "POST",
+          headers: {
+            "atproto-proxy": `${feedServiceDid}#lycan`,
+            "Content-Type": "application/json",
+          },
+        });
+        if (!res.ok)
+          throw new Error(
+            `Authenticated lycan status fetch failed: ${res.statusText}`
+          );
+        return await res.json() as importtype;
+      }
+      return undefined;
+    },
+  });
+}
+
+type LycanSearchPage = {
+  terms: string[];
+  posts: string[];
+  cursor?: string;
+};
+
+
+export function useInfiniteQueryLycanSearch(options: { query: string, type: "likes" | "pins" | "reposts" | "quotes"}) {
+
+
+  const [lycanurl] = useAtom(lycanURLAtom);
+  const { agent, status } = useAuth();
+  const { data: identity } = useQueryIdentity(agent?.did);
+
+  const { queryKey, queryFn } = constructLycanSearchQuery({
+      agent: agent || undefined,
+      isAuthed: status === "signedIn",
+      pdsUrl: identity?.pds,
+      feedServiceDid: "did:web:"+lycanurl,
+      query: options.query,
+      type: options.type,
+    })
+
+  return {
+    ...useInfiniteQuery({
+      queryKey,
+      queryFn,
+      initialPageParam: undefined as never,
+      getNextPageParam: (lastPage) => lastPage?.cursor as null | undefined,
+      //staleTime: Infinity,
+      refetchOnWindowFocus: false,
+      // enabled:
+      //   !!options.feedUri &&
+      //   (options.isAuthed
+      //     ? ((!!options.agent && !!options.pdsUrl) ||
+      //         !!options.unauthedfeedurl) &&
+      //       !!options.feedServiceDid
+      //     : true),
+    }),
+    queryKey: queryKey,
+  };
+}
+
+
+export function constructLycanSearchQuery(options: {
+  agent?: ATPAPI.Agent;
+  isAuthed: boolean;
+  pdsUrl?: string;
+  feedServiceDid?: string;
+  type: "likes" | "pins" | "reposts" | "quotes";
+  query: string;
+}) {
+  const { agent, isAuthed, pdsUrl, feedServiceDid, type, query } = options;
+
+  return infiniteQueryOptions({
+    queryKey: ["lycanSearch", query, type, { isAuthed, did: agent?.did }],
+
+    queryFn: async ({
+      pageParam,
+    }: QueryFunctionContext): Promise<LycanSearchPage | undefined> => {
+      if (isAuthed && agent && pdsUrl && feedServiceDid) {
+        const url = `${pdsUrl}/xrpc/blue.feeds.lycan.searchPosts?query=${query}&collection=${type}${pageParam ? `&cursor=${pageParam}` : ""}`;
+        const res = await agent.fetchHandler(url, {
+          method: "GET",
+          headers: {
+            "atproto-proxy": `${feedServiceDid}#lycan`,
+            "Content-Type": "application/json",
+          },
+        });
+        if (!res.ok)
+          throw new Error(
+            `Authenticated lycan status fetch failed: ${res.statusText}`
+          );
+        return (await res.json()) as LycanSearchPage;
+      }
+      return undefined;
+    },
+    initialPageParam: undefined as never,
+    getNextPageParam: (lastPage) => lastPage?.cursor as null | undefined,
+  });
+}