atmosphereconf 2026 event for margin

web/astro.config.mjs

···
   adapter: node({ mode: "standalone" }),
   integrations: [react(), tailwind()],
   prefetch: {
-    prefetchAll: false,
-    defaultStrategy: "hover",
+    prefetchAll: true,
+    defaultStrategy: "viewport",
   },
   security: {
     checkOrigin: true,

web/src/components/feed/FeedItems.tsx

···
       setOffset(cached.offset);
       setLoading(false);
 
-      getFeed({ type, motivation, tag, creator, source, limit: LIMIT, offset: 0 })
+      getFeed({
+        type,
+        motivation,
+        tag,
+        creator,
+        source,
+        limit: LIMIT,
+        offset: 0,
+      })
         .then((data) => {
           if (cancelled) return;
           const fetched = data.items;
           setItems(fetched);
           setHasMore(data.hasMore);
           setOffset(data.fetchedCount);
-          feedCache.set(cacheKey, { items: fetched, hasMore: data.hasMore, offset: data.fetchedCount, timestamp: Date.now() });
+          feedCache.set(cacheKey, {
+            items: fetched,
+            hasMore: data.hasMore,
+            offset: data.fetchedCount,
+            timestamp: Date.now(),
+          });
         })
         .catch(console.error);
-        
-      return () => { cancelled = true; };
+
+      return () => {
+        cancelled = true;
+      };
     }
 
     setLoading(true);
···
         setHasMore(data.hasMore);
         setOffset(data.fetchedCount);
         setLoading(false);
-        feedCache.set(cacheKey, { items: fetched, hasMore: data.hasMore, offset: data.fetchedCount, timestamp: Date.now() });
+        feedCache.set(cacheKey, {
+          items: fetched,
+          hasMore: data.hasMore,
+          offset: data.fetchedCount,
+          timestamp: Date.now(),
+        });
       })
       .catch((e) => {
         if (cancelled) return;
···
   const loadMore = useCallback(async () => {
     setLoadingMore(true);
     try {
-      const cacheKey = JSON.stringify({ type, motivation, tag, creator, source });
+      const cacheKey = JSON.stringify({
+        type,
+        motivation,
+        tag,
+        creator,
+        source,
+      });
       const data = await getFeed({
         type,
         motivation,
···
       setHasMore(data.hasMore);
       const newOffset = offset + data.fetchedCount;
       setOffset(newOffset);
-      feedCache.set(cacheKey, { items: newItems, hasMore: data.hasMore, offset: newOffset, timestamp: Date.now() });
+      feedCache.set(cacheKey, {
+        items: newItems,
+        hasMore: data.hasMore,
+        offset: newOffset,
+        timestamp: Date.now(),
+      });
     } catch (e) {
       console.error(e);
     } finally {

web/src/layouts/AppLayout.astro

···
 ---
-import BaseLayout from './BaseLayout.astro';
-import Sidebar from '../components/navigation/Sidebar';
-import RightSidebar from '../components/navigation/RightSidebar';
-import MobileNav from '../components/navigation/MobileNav';
-import type { UserProfile } from '../types';
+import BaseLayout from "./BaseLayout.astro";
+import Sidebar from "../components/navigation/Sidebar";
+import RightSidebar from "../components/navigation/RightSidebar";
+import MobileNav from "../components/navigation/MobileNav";
+import { BlueskyIcon } from "../components/common/Icons";
+import type { UserProfile } from "../types";
 
 interface Props {
 	title?: string;
···
 ---
 
 <BaseLayout title={title} description={description} image={image}>
+	<div
+		class="bg-blue-600 dark:bg-blue-500 text-white font-medium text-sm flex items-center justify-center gap-x-3 gap-y-1 flex-wrap py-2 px-4 w-full z-50"
+	>
+		<div
+			class="w-12 h-9 overflow-hidden rounded flex items-start justify-center -my-1"
+		>
+			<img
+				src="https://atmosphereconf.org/_image?href=%2F_astro%2Fgoodstuff-goose.DKPXDrcQ.png&w=792&h=990&f=webp"
+				alt="Atmosphere Goose"
+				class="w-12 h-12 object-cover object-top drop-shadow-md"
+			/>
+		</div>
+		<span
+			>Welcome to <a
+				href="https://atmosphereconf.org/"
+				target="_blank"
+				rel="noopener noreferrer"
+				class="font-bold underline hover:text-blue-200 transition-colors"
+				>ATmosphereConf 2026</a
+			>!</span
+		>
+		<a
+			href="https://bsky.app/profile/atmosphereconf.org/feed/atmosphereconf"
+			target="_blank"
+			rel="noopener noreferrer"
+			class="hover:text-blue-200 transition-colors flex items-center gap-1.5 ml-1 bg-blue-700/50 hover:bg-blue-700 px-2 py-0.5 rounded-full"
+		>
+			<BlueskyIcon size={14} color="currentColor" />
+			<span>View feed</span>
+		</a>
+	</div>
 	<div class="min-h-screen bg-surface-100 dark:bg-surface-900 flex">
 		<div transition:persist="sidebar">
-			<Sidebar client:load initialUser={user} currentPath={Astro.url.pathname} />
+			<Sidebar
+				client:idle
+				initialUser={user}
+				currentPath={Astro.url.pathname}
+			/>
 		</div>
 
 		<div class="flex-1 min-w-0 transition-all duration-200">
 			<div class="flex w-full max-w-[1800px] mx-auto">
 				<main class="flex-1 w-full min-w-0 py-2 md:py-3">
-					<div class="bg-white dark:bg-surface-800 rounded-2xl min-h-[calc(100vh-16px)] md:min-h-[calc(100vh-24px)] py-6 px-4 md:px-6 lg:px-8 pb-20 md:pb-6">
+					<div
+						class="bg-white dark:bg-surface-800 rounded-2xl min-h-[calc(100vh-16px)] md:min-h-[calc(100vh-24px)] py-6 px-4 md:px-6 lg:px-8 pb-20 md:pb-6"
+					>
 						<slot />
 					</div>
 				</main>
···
 		</div>
 
 		<div transition:persist="mobile-nav">
-			<MobileNav client:load initialUser={user} currentPath={Astro.url.pathname} />
+			<MobileNav
+				client:media="(max-width: 768px)"
+				initialUser={user}
+				currentPath={Astro.url.pathname}
+			/>
 		</div>
 	</div>
 </BaseLayout>

web/src/views/collections/Collections.tsx

···
   const [creating, setCreating] = useState(false);
 
   const fetchCollections = async () => {
-    if (collectionsCache.data && Date.now() - collectionsCache.timestamp < 5 * 60 * 1000) {
+    if (
+      collectionsCache.data &&
+      Date.now() - collectionsCache.timestamp < 5 * 60 * 1000
+    ) {
       setCollections(collectionsCache.data);
       setLoading(false);
-      
-      getCollections().then(data => {
-        setCollections(data);
-        collectionsCache.data = data;
-        collectionsCache.timestamp = Date.now();
-      }).catch(console.error);
+
+      getCollections()
+        .then((data) => {
+          setCollections(data);
+          collectionsCache.data = data;
+          collectionsCache.timestamp = Date.now();
+        })
+        .catch(console.error);
       return;
     }
 

web/src/views/core/Feed.tsx

···
   const tabs = [
     { id: "all", label: "Recent" },
     { id: "popular", label: "Popular" },
+    { id: "atmosphereconf", label: "ATmosphereConf" },
     { id: "shelved", label: "Shelved" },
     { id: "margin", label: "Margin" },
     { id: "semble", label: "Semble" },
···
 
       <FeedItems
         key={`${activeTab}-${activeFilter || "all"}-${tag || ""}`}
-        type={activeTab}
+        type={activeTab === "atmosphereconf" ? "all" : activeTab}
         motivation={activeFilter}
         emptyMessage={emptyMessage}
         layout={layout}
-        tag={tag}
+        tag={
+          activeTab === "atmosphereconf" ||
+          tag?.toLowerCase() === "atmosphereconf"
+            ? "ATmosphereConf"
+            : tag
+        }
       />
     </div>
   );

web/src/views/core/Notifications.tsx

···
 
   useEffect(() => {
     const load = async () => {
-      if (notificationsCache.data && Date.now() - notificationsCache.timestamp < 5 * 60 * 1000) {
+      if (
+        notificationsCache.data &&
+        Date.now() - notificationsCache.timestamp < 5 * 60 * 1000
+      ) {
         setNotifications(notificationsCache.data);
         setLoading(false);
-        
-        getNotifications().then(data => {
-          setNotifications(data);
-          notificationsCache.data = data;
-          notificationsCache.timestamp = Date.now();
-        }).catch(console.error);
-        
+
+        getNotifications()
+          .then((data) => {
+            setNotifications(data);
+            notificationsCache.data = data;
+            notificationsCache.timestamp = Date.now();
+          })
+          .catch(console.error);
+
         markNotificationsRead();
         return;
       }

web/src/views/core/Search.tsx

···
         setResults([]);
         return;
       }
-      
-      const cacheKey = JSON.stringify({ q: q.trim(), myItemsOnly: myItemsRef.current });
-      
+
+      const cacheKey = JSON.stringify({
+        q: q.trim(),
+        myItemsOnly: myItemsRef.current,
+      });
+
       if (!append && newOffset === 0) {
         const cached = searchCache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < 5 * 60 * 1000) {
···
           setHasMore(cached.hasMore);
           setOffset(cached.offset);
           setLoading(false);
-          
+
           const id = ++fetchIdRef.current;
           searchItems(q.trim(), {
             creator: myItemsRef.current && user ? user.did : undefined,
             limit: 30,
             offset: newOffset,
-          }).then(data => {
-            if (id !== fetchIdRef.current) return;
-            setResults(data.items);
-            setHasMore(data.hasMore);
-            setOffset(newOffset + data.items.length);
-            searchCache.set(cacheKey, { results: data.items, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
-          }).catch(console.error);
-          
+          })
+            .then((data) => {
+              if (id !== fetchIdRef.current) return;
+              setResults(data.items);
+              setHasMore(data.hasMore);
+              setOffset(newOffset + data.items.length);
+              searchCache.set(cacheKey, {
+                results: data.items,
+                hasMore: data.hasMore,
+                offset: newOffset + data.items.length,
+                timestamp: Date.now(),
+              });
+            })
+            .catch(console.error);
+
           return;
         }
       }
···
       if (append) {
         setResults((prev) => {
           const newResults = [...prev, ...data.items];
-          searchCache.set(cacheKey, { results: newResults, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
+          searchCache.set(cacheKey, {
+            results: newResults,
+            hasMore: data.hasMore,
+            offset: newOffset + data.items.length,
+            timestamp: Date.now(),
+          });
           return newResults;
         });
       } else {
         setResults(data.items);
-        searchCache.set(cacheKey, { results: data.items, hasMore: data.hasMore, offset: newOffset + data.items.length, timestamp: Date.now() });
+        searchCache.set(cacheKey, {
+          results: data.items,
+          hasMore: data.hasMore,
+          offset: newOffset + data.items.length,
+          timestamp: Date.now(),
+        });
       }
       setHasMore(data.hasMore);
       setOffset(newOffset + data.items.length);

web/src/views/profile/Profile.tsx

···
           try {
             const rel = await getModerationRelationship(did);
             setModRelation(rel);
-            profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: rel, timestamp: Date.now() });
+            profileCache.set(did, {
+              profile: merged,
+              labels: marginData?.labels || [],
+              relation: rel,
+              timestamp: Date.now(),
+            });
           } catch {
-            profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: modRelation, timestamp: Date.now() });
+            profileCache.set(did, {
+              profile: merged,
+              labels: marginData?.labels || [],
+              relation: modRelation,
+              timestamp: Date.now(),
+            });
           }
         } else {
-          profileCache.set(did, { profile: merged, labels: marginData?.labels || [], relation: modRelation, timestamp: Date.now() });
+          profileCache.set(did, {
+            profile: merged,
+            labels: marginData?.labels || [],
+            relation: modRelation,
+            timestamp: Date.now(),
+          });
         }
       } catch (e) {
         console.error("Profile load failed", e);
···
           }
           const res = await getCollections(resolvedDid);
           setCollections(res);
-          profileCollectionsCache.set(resolvedDid, { collections: res, timestamp: Date.now() });
+          profileCollectionsCache.set(resolvedDid, {
+            collections: res,
+            timestamp: Date.now(),
+          });
         }
       } catch (e) {
         console.error(e);