feat(feed): fix pagination, auth error handling, and empty states

Thread loadFeed callback through PostListShell and VirtualFeed to
restore infinite scroll pagination on home and community pages. Add
auth error detection (401/403) that shows session-expired message
with login button. Improve feed robustness with null-safe responses,
cursor-based hasMore logic, and proper error re-throwing.

Changes:
- Add loadFeed prop to PostListShell and pass to VirtualFeed
- Create loadFeed functions in home and community page loaders
- Detect XrpcError 401/403 and show login prompt instead of retry
- Move loading=false to finally block in VirtualFeed
- Guard against null feed responses with ?? []
- Add empty state placeholder on home page
- Fix /communities link to /explore/communities
- Update empty feed description copy

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

src/lib/app/i18n/en.json

···
             "endFeed": "You have reached the end of {{community_name; undefined:the feed.; default:{{community_name}}.}}",
             "empty": {
                 "title": "No posts",
-                "description": "There are no posts that match this filter."
+                "description": "There are no posts in this feed."
             }
         },
         "modlog": {

src/lib/feature/feeds/feed.svelte.ts

···
       } catch (err) {
         console.error('[Feed] fetch failed:', err)
         this.error = err
+        throw err
       }
     }
 

src/lib/feature/post/feed/VirtualFeed.svelte

···
 <script lang="ts">
   import { browser } from '$app/environment'
+  import { XrpcError } from '$lib/api/coves/xrpc'
   import type { FeedViewPost, FeedPaginationParams } from '$lib/api/coves/types'
   import { errorMessage } from '$lib/app/error'
   import { t } from '$lib/app/i18n'
···
     scrollToIndex: (index: number, window?: boolean) => void
   }>()
 
-  let error = $state()
+  let error = $state<unknown>()
+  let isAuthError = $derived(
+    error instanceof XrpcError &&
+      (error.status === 401 || error.status === 403),
+  )
   let loading = $state(false)
-  let hasMore = $state(true)
+  let hasMore = $state(!!loadFeed)
 
-  let seenUris = new SvelteSet<string>(posts.map((fp) => fp.post.uri as string))
+  let seenUris = new SvelteSet<string>(
+    (posts ?? []).map((fp) => fp.post.uri as string),
+  )
 
   async function loadMore(): Promise<void> {
     if (!hasMore || loading || !loadFeed) return
···
 
       error = null
 
-      hasMore = response.feed.length !== 0
+      hasMore = response.feed.length !== 0 && !!response.cursor
 
       if (response.cursor) {
         params = { ...params, cursor: response.cursor }
···
           return true
         }),
       )
-
-      loading = false
     } catch (e) {
       console.error('Failed to load more posts:', e)
       error = e
+    } finally {
       loading = false
     }
   }
···
           description={$t('routes.frontpage.empty.description')}
         >
           <Button
-            href="/communities"
+            href="/explore/communities"
             rounding="pill"
             color="primary"
             icon={ArrowTopRightOnSquare}
···
             micro
             class="inline-block rounded-lg clear-both float-left mr-2"
           />
-          {errorMessage(error)}
+          {#if isAuthError}
+            {$t('toast.sessionExpired')}
+          {:else}
+            {errorMessage(error)}
+          {/if}
         </div>
-        <Button
-          color="primary"
-          {loading}
-          disabled={loading}
-          onclick={() => loadMore()}
-        >
-          {$t('message.retry')}
-        </Button>
+        {#if isAuthError}
+          <Button color="primary" href="/login">
+            {$t('account.login')}
+          </Button>
+        {:else}
+          <Button
+            color="primary"
+            {loading}
+            disabled={loading}
+            onclick={() => loadMore()}
+          >
+            {$t('message.retry')}
+          </Button>
+        {/if}
       </Material>
     {:else if hasMore}
       <div class="w-full h-32 grid place-items-center">

src/lib/ui/layout/pages/PostListShell.svelte

···
     extended?: Snippet
     getParams: FeedPaginationParams | Record<string, unknown>
     header?: boolean
+    loadFeed?: (
+      params: FeedPaginationParams,
+    ) => Promise<{ feed: FeedViewPost[]; cursor?: string }>
   }
 
   let {
···
     extended: passedExtended,
     getParams,
     header = true,
+    loadFeed,
   }: Props = $props()
 
   $effect(() => {
···
     </Header>
   {/if}
 
-  <FeedComponent bind:posts bind:params={getParams} />
+  <FeedComponent bind:posts bind:params={getParams} {loadFeed} />
   <svelte:element
     this={settings.infiniteScroll && !settings.posts.noVirtualize
       ? 'noscript'

src/routes/+page.svelte

···
   import ViewSelect from '$lib/feature/filter/ViewSelect.svelte'
   import PostFeed from '$lib/feature/post/feed/PostFeed.svelte'
   import VirtualFeed from '$lib/feature/post/feed/VirtualFeed.svelte'
+  import Placeholder from '$lib/ui/info/Placeholder.svelte'
   import Skeleton from '$lib/ui/generic/Skeleton.svelte'
   import { Header, Pageination } from '$lib/ui/layout'
   import { Button } from 'mono-svelte'
+  import { ArchiveBox, ArrowTopRightOnSquare } from 'svelte-hero-icons/dist'
 
   let { data = $bindable() } = $props()
 
···
 
 {#await data.feed.value}
   <div class="space-y-4">
-    {#each new Array(5) as _, index}{_}
+    {#each new Array(5) as _, index}
       <div
         class="animate-pop-in"
         style="animation-delay: {index * 50}ms; opacity: 0; width: {(1 /
···
   </div>
 {:then feed}
   {#if feed}
-    <FeedComponent bind:posts={feed.feed} bind:params={feed.params} />
+    <FeedComponent
+      bind:posts={feed.feed}
+      bind:params={feed.params}
+      loadFeed={data.loadFeed}
+    />
     <svelte:element
       this={settings.infiniteScroll && !settings.posts.noVirtualize
         ? 'noscript'
···
         back={false}
       />
     </svelte:element>
+  {:else}
+    <div class="h-full grid place-items-center my-8">
+      <Placeholder
+        icon={ArchiveBox}
+        title={$t('routes.frontpage.empty.title')}
+        description={$t('routes.frontpage.empty.description')}
+      >
+        <Button
+          href="/explore/communities"
+          rounding="pill"
+          color="primary"
+          icon={ArrowTopRightOnSquare}
+        >
+          {$t('nav.communities')}
+        </Button>
+      </Placeholder>
+    </div>
   {/if}
 {:catch error}
   <div class="flex flex-col items-center gap-4 py-8 text-center">

src/routes/+page.ts

···
+import type { FeedPaginationParams } from '$lib/api/coves/types'
 import { coves } from '$lib/api/client.svelte'
 import { profile } from '$lib/app/auth.svelte'
 import { t } from '$lib/app/i18n'
···
   const listing = mapListing(listingType, profile.isAuthenticated)
 
   const feedData = feed(route.id, async (params) => {
-    const isTimeline = params.listing === 'timeline'
+    const { listing, ...rest } = params
+    const isTimeline = listing === 'timeline'
     const response = isTimeline
-      ? await coves({ func: fetch }).getTimeline({
-          sort: params.sort,
-          timeframe: params.timeframe,
-          limit: params.limit,
-          cursor: params.cursor,
-        })
-      : await coves({ func: fetch }).getDiscover({
-          sort: params.sort,
-          timeframe: params.timeframe,
-          limit: params.limit,
-          cursor: params.cursor,
-        })
+      ? await coves({ func: fetch }).getTimeline(rest)
+      : await coves({ func: fetch }).getDiscover(rest)
 
     return {
-      feed: response.feed,
+      feed: response.feed ?? [],
       cursor: response.cursor,
       params: { ...params, cursor: response.cursor },
     }
···
     limit: 20,
   })
 
+  const filters = new ReactiveState({
+    sort: mapped.sort,
+    timeframe: mapped.timeframe,
+    type_: listing,
+  })
+
   return {
     feed: new ReactiveState((await awaitIfServer(feedData)).data),
-    filters: new ReactiveState({
-      sort: mapped.sort,
-      timeframe: mapped.timeframe,
-      type_: listing,
-    }),
+    filters,
+    loadFeed: async (params: FeedPaginationParams) => {
+      const isTimeline = filters.value.type_ === 'timeline'
+      const response = isTimeline
+        ? await coves({ func: fetch }).getTimeline(params)
+        : await coves({ func: fetch }).getDiscover(params)
+      return { feed: response.feed ?? [], cursor: response.cursor }
+    },
     contextual: {
       actions: [
         {

src/routes/c/[handle]/+page.svelte

···
     params={{
       sort: data.params.sort,
     }}
+    loadFeed={data.loadFeed}
   >
     {#snippet extended()}
       {#if data.community}

src/routes/c/[handle]/+page.ts

···
+import type { FeedPaginationParams } from '$lib/api/coves/types'
 import { coves } from '$lib/api/client.svelte'
 import { settings } from '$lib/app/settings.svelte'
 import { mapSort } from '$lib/app/sort'
···
     ])
 
     return {
-      feed: feedResponse.feed,
+      feed: feedResponse.feed ?? [],
       community: communityData,
       cursor: feedResponse.cursor,
       params: { ...p, cursor: feedResponse.cursor },
···
 
   return {
     ...feedData,
+    loadFeed: async (params: FeedPaginationParams) => {
+      const response = await coves({ func: fetch }).getCommunityFeed({
+        ...params,
+        community: communityHandle,
+      })
+      return { feed: response.feed ?? [], cursor: response.cursor }
+    },
     slots: {
       sidebar: {
         component: CommunityCard,