diff --git a/src/lib/api/coves/client.test.ts b/src/lib/api/coves/client.test.ts
--- a/src/lib/api/coves/client.test.ts
+++ b/src/lib/api/coves/client.test.ts
@@ -275,11 +275,52 @@ uri: 'at://did:plc:abc/post/1',
     })
   })
 
-  it('getPost() calls query with correct NSID', async () => {
-    await client.getPost({ uri: 'at://did:plc:abc/post/1' as AtUri })
+  it('getPosts() calls query with a repeated uris array', async () => {
+    await client.getPosts({
+      uris: [
+        'at://did:plc:abc/post/1' as AtUri,
+        'at://did:plc:abc/post/2' as AtUri,
+      ],
+    })
 
     expect(querySpy).toHaveBeenCalledWith(NSID.getPost, {
-      uri: 'at://did:plc:abc/post/1',
+      uris: ['at://did:plc:abc/post/1', 'at://did:plc:abc/post/2'],
     })
+  })
+
+  it('getPost() wraps the batch endpoint with a single URI', async () => {
+    const post = { uri: 'at://did:plc:abc/post/1', cid: 'bafy1' }
+    querySpy.mockResolvedValueOnce({ posts: [post] })
+
+    const result = await client.getPost('at://did:plc:abc/post/1' as AtUri)
+
+    expect(querySpy).toHaveBeenCalledWith(NSID.getPost, {
+      uris: ['at://did:plc:abc/post/1'],
+    })
+    expect(result).toBe(post)
+  })
+
+  it('getPost() throws when the batch endpoint returns an empty array', async () => {
+    querySpy.mockResolvedValueOnce({ posts: [] })
+
+    await expect(
+      client.getPost('at://did:plc:abc/post/1' as AtUri),
+    ).rejects.toThrow(/0 posts, expected exactly 1/)
+  })
+
+  it('getPost() throws when posts is missing from the response', async () => {
+    querySpy.mockResolvedValueOnce({})
+
+    await expect(
+      client.getPost('at://did:plc:abc/post/1' as AtUri),
+    ).rejects.toThrow(/non-array posts field, expected exactly 1/)
+  })
+
+  it('getPost() throws when posts is not an array', async () => {
+    querySpy.mockResolvedValueOnce({ posts: null })
+
+    await expect(
+      client.getPost('at://did:plc:abc/post/1' as AtUri),
+    ).rejects.toThrow(/non-array posts field, expected exactly 1/)
   })
 })
diff --git a/src/lib/api/coves/client.ts b/src/lib/api/coves/client.ts
--- a/src/lib/api/coves/client.ts
+++ b/src/lib/api/coves/client.ts
@@ -21,13 +21,14 @@ GetCommentsParams,
   GetCommentsResponse,
   GetCommunityFeedParams,
   GetCommunityParams,
-  GetPostParams,
+  GetPostsParams,
+  GetPostsResponse,
   GetDiscoverParams,
   GetProfileParams,
   GetTimelineParams,
   ListCommunitiesParams,
   ListCommunitiesResponse,
-  PostView,
+  PostViewUnion,
   ProfileViewDetailed,
   SearchCommunitiesParams,
   SubscribeCommunityInput,
@@ -171,7 +172,27 @@ deletePost(input: { uri: AtUri }): Promise<void> {
     return this.xrpc.procedure(NSID.deletePost, input)
   }
 
-  getPost(params: GetPostParams): Promise<PostView> {
+  // The wired endpoint is batch (1–25 URIs); `posts` mirrors `uris` order 1:1.
+  getPosts(params: GetPostsParams): Promise<GetPostsResponse> {
     return this.xrpc.query(NSID.getPost, params)
+  }
+
+  // Single-URI convenience wrapper over the batch endpoint.
+  // Contract: 1 URI in ⇒ exactly 1 element out. A short/empty array (or a
+  // non-array `posts`) is a backend contract violation, not a "removed" post,
+  // so we throw rather than silently returning undefined.
+  async getPost(uri: AtUri): Promise<PostViewUnion> {
+    const { posts } = await this.getPosts({ uris: [uri] })
+    if (!Array.isArray(posts)) {
+      throw new Error(
+        `getPost(${uri}): batch endpoint returned a non-array posts field, expected exactly 1`,
+      )
+    }
+    if (posts.length === 0) {
+      throw new Error(
+        `getPost(${uri}): batch endpoint returned 0 posts, expected exactly 1`,
+      )
+    }
+    return posts[0]
   }
 }
diff --git a/src/lib/api/coves/types.test.ts b/src/lib/api/coves/types.test.ts
--- a/src/lib/api/coves/types.test.ts
+++ b/src/lib/api/coves/types.test.ts
@@ -7,8 +7,9 @@ parseAtUri,
   isValidCID,
   asCID,
   tryAsCID,
+  isHydratedPost,
 } from './types'
-import type { AtUri } from './types'
+import type { AtUri, CID, PostView, PostViewUnion } from './types'
 
 // ---------------------------------------------------------------------------
 // isValidAtUri
@@ -186,3 +187,50 @@ it('returns null for a string with invalid characters', () => {
     expect(tryAsCID('bafy!invalid')).toBeNull()
   })
 })
+
+// ---------------------------------------------------------------------------
+// isHydratedPost
+// ---------------------------------------------------------------------------
+
+describe('isHydratedPost', () => {
+  const postView = {
+    uri: 'at://did:plc:abc/social.coves.community.post/1' as AtUri,
+    cid: 'bafyreib2rxk3rybsftg4qpz' as CID,
+  } as PostView
+
+  it('accepts a hydrated post view', () => {
+    expect(isHydratedPost(postView)).toBe(true)
+  })
+
+  it('rejects a notFound sentinel', () => {
+    const el: PostViewUnion = {
+      uri: 'at://did:plc:abc/social.coves.community.post/2' as AtUri,
+      notFound: true,
+    }
+    expect(isHydratedPost(el)).toBe(false)
+  })
+
+  it('rejects a blocked sentinel', () => {
+    const el: PostViewUnion = {
+      uri: 'at://did:plc:abc/social.coves.community.post/3' as AtUri,
+      blocked: true,
+    }
+    expect(isHydratedPost(el)).toBe(false)
+  })
+
+  it('treats an element without a known unavailable flag as a post', () => {
+    // Flag-negative discrimination: only the documented sentinels
+    // (notFound/blocked) are unavailable. A real-but-malformed post that arrives
+    // missing `cid` is still a post — it must not be silently reclassified as
+    // removed (the failure mode of probing for a positive `cid` shape).
+    const el = {
+      uri: 'at://did:plc:abc/social.coves.community.post/4' as AtUri,
+    } as unknown as PostViewUnion
+    expect(isHydratedPost(el)).toBe(true)
+  })
+
+  it('rejects null and undefined', () => {
+    expect(isHydratedPost(null)).toBe(false)
+    expect(isHydratedPost(undefined)).toBe(false)
+  })
+})
diff --git a/src/lib/api/coves/types.ts b/src/lib/api/coves/types.ts
--- a/src/lib/api/coves/types.ts
+++ b/src/lib/api/coves/types.ts
@@ -145,6 +145,46 @@ viewer?: PostViewerState
   stats?: PostStats
 }
 
+/** A requested post that could not be hydrated (deleted/unindexed/unresolvable). */
+export interface NotFoundPost {
+  uri: AtUri
+  notFound: true
+}
+
+/**
+ * A requested post withheld because the viewer blocks its author. Emitted by the
+ * backend's blocked-by-author path. The response preserves the requested URI's
+ * position in the `posts` array.
+ */
+export interface BlockedPost {
+  uri: AtUri
+  blocked: true
+  blockedBy?: DID
+  author?: { did: DID }
+}
+
+/**
+ * One element of `getPosts` — either a hydrated post or an unavailable sentinel.
+ * The response preserves the order of the requested URIs.
+ */
+export type PostViewUnion = PostView | NotFoundPost | BlockedPost
+
+/**
+ * Discriminates a hydrated post from the unavailable sentinels. Mirrors the
+ * backend's flag-based contract: each sentinel carries a documented const
+ * discriminator (`notFound` / `blocked`) and a hydrated `PostView` carries
+ * neither. We therefore treat the *absence* of every known unavailable flag as
+ * "this is a post", which (a) narrows correctly via TS control flow and (b)
+ * keeps a real-but-malformed post (e.g. one momentarily missing `cid`) from
+ * being silently misclassified as removed. A future sentinel must register its
+ * flag here, matching how the backend would emit it.
+ */
+export function isHydratedPost(
+  el: PostViewUnion | null | undefined,
+): el is PostView {
+  return el != null && !('notFound' in el) && !('blocked' in el)
+}
+
 // ---------------------------------------------------------------------------
 // Feed wrapper types
 // ---------------------------------------------------------------------------
@@ -402,7 +442,9 @@ cursor?: string
 }
 
 export interface GetCommentsResponse {
-  post: PostRef
+  // The backend returns the full hydrated post here, not just a strong ref —
+  // so it could serve as a fallback source for the post on the permalink page.
+  post: PostView
   comments: ThreadViewComment[]
   cursor?: string
 }
@@ -494,8 +536,13 @@ // ---------------------------------------------------------------------------
 // Request / response types — post retrieval
 // ---------------------------------------------------------------------------
 
-export interface GetPostParams {
-  uri: AtUri
+/** 1–25 URIs; the response `posts` array mirrors this order 1:1. */
+export interface GetPostsParams {
+  uris: AtUri[]
+}
+
+export interface GetPostsResponse {
+  posts: PostViewUnion[]
 }
 
 // ---------------------------------------------------------------------------
diff --git a/src/lib/api/coves/xrpc.test.ts b/src/lib/api/coves/xrpc.test.ts
--- a/src/lib/api/coves/xrpc.test.ts
+++ b/src/lib/api/coves/xrpc.test.ts
@@ -79,6 +79,37 @@ expect(url.searchParams.get('limit')).toBe('10')
     expect(url.searchParams.get('sort')).toBe('hot')
   })
 
+  it('serializes array params as repeated keys', async () => {
+    const mockFetch = createMockFetch({ posts: [] })
+    client = new XrpcClient({ fetchFn: mockFetch, baseUrl: BASE_URL })
+
+    await client.query('social.coves.community.post.get', {
+      uris: ['at://did:plc:a/post/1', 'at://did:plc:b/post/2'],
+    })
+
+    const calledUrl = (mockFetch as ReturnType<typeof vi.fn>).mock
+      .calls[0][0] as string
+    const url = new URL(calledUrl)
+    expect(url.searchParams.getAll('uris')).toEqual([
+      'at://did:plc:a/post/1',
+      'at://did:plc:b/post/2',
+    ])
+  })
+
+  it('throws when an array param contains a nullish element', async () => {
+    // A hole in an array param would silently send a shorter list and desync
+    // any positional 1:1 response array (e.g. getPosts' `posts`). Fail fast.
+    const mockFetch = createMockFetch({ posts: [] })
+    client = new XrpcClient({ fetchFn: mockFetch, baseUrl: BASE_URL })
+
+    await expect(
+      client.query('social.coves.community.post.get', {
+        uris: ['at://did:plc:a/post/1', undefined, 'at://did:plc:b/post/2'],
+      }),
+    ).rejects.toThrow('nullish element')
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
   it('skips undefined and null params', async () => {
     const mockFetch = createMockFetch({ items: [] })
     client = new XrpcClient({ fetchFn: mockFetch, baseUrl: BASE_URL })
diff --git a/src/lib/api/coves/xrpc.ts b/src/lib/api/coves/xrpc.ts
--- a/src/lib/api/coves/xrpc.ts
+++ b/src/lib/api/coves/xrpc.ts
@@ -34,7 +34,26 @@ for (const [key, value] of Object.entries(
         params as Record<string, unknown>,
       )) {
         if (value === undefined || value === null) continue
-        searchParams.set(key, String(value))
+        // ATProto serializes array params as repeated keys (`uris=…&uris=…`),
+        // not a comma-joined string. Append each element under the same key.
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            if (item === undefined || item === null) {
+              // A hole in an array param (e.g. from a caller's `.map()` that
+              // yielded `undefined`) would silently send a shorter list,
+              // desyncing any positional 1:1 response array (such as
+              // getPosts' `posts`). Fail fast on the programming error rather
+              // than quietly truncating.
+              throw new Error(
+                `[XrpcClient] Array param "${key}" contains a nullish element; ` +
+                  `filter the array before calling so positional responses stay aligned.`,
+              )
+            }
+            searchParams.append(key, String(item))
+          }
+        } else {
+          searchParams.set(key, String(value))
+        }
       }
       url.search = searchParams.toString()
     }
diff --git a/src/lib/feature/community/CommunityCard.svelte b/src/lib/feature/community/CommunityCard.svelte
--- a/src/lib/feature/community/CommunityCard.svelte
+++ b/src/lib/feature/community/CommunityCard.svelte
@@ -81,19 +81,30 @@ </script>
 
 <script lang="ts">
   import type {
+    CommunityRef,
     CommunityView as CovesCommunityView,
     CommunityViewDetailed,
   } from '$lib/api/coves/types'
   import EntityHeader from '$lib/ui/generic/EntityHeader.svelte'
   import { communityDisplayName, communityIdentifier } from './helpers'
 
-  type CommunityType = CovesCommunityView | CommunityViewDetailed
+  type HydratedCommunity = CovesCommunityView | CommunityViewDetailed
+  type CommunityType = CommunityRef | HydratedCommunity
+
+  /**
+   * Narrows a community to a hydrated view. A bare `CommunityRef` (e.g. the
+   * post's embedded community) carries no counts or viewer state, so features
+   * that depend on them must be gated behind this guard.
+   */
+  function isHydratedCommunity(c: CommunityType): c is HydratedCommunity {
+    return 'subscriberCount' in c
+  }
 
   let loading = $state({
     subscribing: false,
   })
 
-  async function subscribe(community: CommunityType): Promise<void> {
+  async function subscribe(community: HydratedCommunity): Promise<void> {
     if (!profile.current?.jwt) return
     loading.subscribing = true
     const wasSubscribed = community.viewer?.subscribed === true
@@ -163,14 +174,15 @@
     <EndPlaceholder size="xs" margin="sm">
       {$t('form.post.community')}
     </EndPlaceholder>
-    {#if profile.current?.jwt}
-      {@const subscribed = community.viewer?.subscribed === true}
+    {#if profile.current?.jwt && isHydratedCommunity(community)}
+      {@const hydrated = community}
+      {@const subscribed = hydrated.viewer?.subscribed === true}
       <Button
         disabled={loading.subscribing}
         loading={loading.subscribing}
         size="md"
         color={subscribed ? 'secondary' : 'primary'}
-        onclick={() => subscribe(community)}
+        onclick={() => subscribe(hydrated)}
         class="px-4 relative z-[inherit]"
         alignment="left"
         icon={subscribed ? Check : Plus}
@@ -180,7 +192,7 @@ ? $t('cards.community.subscribed')
           : $t('cards.community.subscribe')}
       </Button>
     {/if}
-    {#if profile.isMod(community)}
+    {#if isHydratedCommunity(community) && profile.isMod(community)}
       <SidebarButton
         href="/c/{communityIdentifier(community)}/settings"
         icon={Cog6Tooth}
@@ -200,7 +212,7 @@ <Icon src={Newspaper} size="16" mini />
         {$t('cards.community.modlog')}
       </MenuButton>
       {#if profile.current?.jwt}
-        {#if profile.isMod(community)}
+        {#if isHydratedCommunity(community) && profile.isMod(community)}
           <MenuButton
             color="success-subtle"
             href="/moderation?community={community.did}"
@@ -239,22 +251,31 @@ </MenuButton>
         {/if}
       {/if}
     </Menu>
-    <EndPlaceholder size="xs" margin="sm">
-      {$t('cards.site.stats')}
-    </EndPlaceholder>
+    <!--
+      Stats are only present on a hydrated community view. The post permalink
+      sidebar passes the post's embedded `CommunityRef`, which carries no counts
+      — gate the whole block so the card degrades to its header instead of
+      throwing on `undefined.toString()`.
+    -->
+    {#if isHydratedCommunity(community)}
+      {@const hydrated = community}
+      <EndPlaceholder size="xs" margin="sm">
+        {$t('cards.site.stats')}
+      </EndPlaceholder>
 
-    <div class="flex flex-row gap-4 flex-wrap px-3">
-      <LabelStat
-        label={$t('cards.community.members')}
-        content={community.subscriberCount.toString()}
-        formatted
-      />
-      <LabelStat
-        label={$t('content.posts')}
-        content={community.postCount.toString()}
-        formatted
-      />
-    </div>
+      <div class="flex flex-row gap-4 flex-wrap px-3">
+        <LabelStat
+          label={$t('cards.community.members')}
+          content={hydrated.subscriberCount.toString()}
+          formatted
+        />
+        <LabelStat
+          label={$t('content.posts')}
+          content={hydrated.postCount.toString()}
+          formatted
+        />
+      </div>
+    {/if}
 
     <EndPlaceholder size="xs" margin="sm">
       {$t('common.info')}
diff --git a/src/lib/feature/feeds/feed.svelte.ts b/src/lib/feature/feeds/feed.svelte.ts
--- a/src/lib/feature/feeds/feed.svelte.ts
+++ b/src/lib/feature/feeds/feed.svelte.ts
@@ -103,8 +103,14 @@ singleThread?: boolean
         focus?: string
       }
     },
-    {
-      post: CovesPostView
+    // Discriminated on `unavailable`: present ('notFound' | 'blocked') ⇒ the post
+    // could not be hydrated and there is no `post`; absent ⇒ `post` is present.
+    // This makes the illegal { post, unavailable } state unrepresentable and lets
+    // consumers read `value.post` for free in the happy branch.
+    (
+      | { post: CovesPostView; unavailable?: never }
+      | { post?: never; unavailable: 'notFound' | 'blocked' }
+    ) & {
       comments: Promise<ThreadViewComment[]>
       params: {
         postUri: string
diff --git a/src/lib/feature/post/form/post-form.svelte.ts b/src/lib/feature/post/form/post-form.svelte.ts
--- a/src/lib/feature/post/form/post-form.svelte.ts
+++ b/src/lib/feature/post/form/post-form.svelte.ts
@@ -64,7 +64,13 @@ const result = await coves().createPost({
       community: community.did,
       title: this.title || undefined,
       content: this.body || undefined,
-      embed: this.url ? { uri: this.url } : undefined,
+      // social.coves.embed.external requires the $type discriminator and an
+      // `external` wrapper. A bare { uri } matches neither the backend's
+      // validate/unfurl gate nor the frontend's $type switch, so it's silently
+      // dropped end-to-end (no link card, no title-opens-url).
+      embed: this.url
+        ? { $type: 'social.coves.embed.external', external: { uri: this.url } }
+        : undefined,
     })
 
     // TODO(coves-api): The UI collects nsfw, altText, and thumbnail but
diff --git a/src/lib/server/session.test.ts b/src/lib/server/session.test.ts
--- a/src/lib/server/session.test.ts
+++ b/src/lib/server/session.test.ts
@@ -206,19 +206,19 @@ expect(parseApiMeResponse(true, testInstance, testToken)).toBeNull()
     expect(parseApiMeResponse(undefined, testInstance, testToken)).toBeNull()
   })
 
-  it('logs warning when did is missing', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('logs error when did is missing', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     parseApiMeResponse({ handle: 'user1.example.com' }, testInstance, testToken)
 
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Missing or non-string "did"'),
     )
-    warnSpy.mockRestore()
+    errorSpy.mockRestore()
   })
 
-  it('logs warning when DID format is invalid', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('logs error when DID format is invalid', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     parseApiMeResponse(
       { did: 'not-a-did', handle: 'user1.example.com' },
@@ -226,26 +226,26 @@ testInstance,
       testToken,
     )
 
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Invalid DID format'),
       'not-a-did',
     )
-    warnSpy.mockRestore()
+    errorSpy.mockRestore()
   })
 
-  it('logs warning when handle is missing', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('logs error when handle is missing', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     parseApiMeResponse({ did: 'did:plc:user1' }, testInstance, testToken)
 
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Missing or non-string "handle"'),
     )
-    warnSpy.mockRestore()
+    errorSpy.mockRestore()
   })
 
-  it('logs warning when handle format is invalid', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('logs error when handle format is invalid', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     parseApiMeResponse(
       { did: 'did:plc:user1', handle: 'invalid' },
@@ -253,23 +253,23 @@ testInstance,
       testToken,
     )
 
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Invalid handle format'),
       'invalid',
     )
-    warnSpy.mockRestore()
+    errorSpy.mockRestore()
   })
 
-  it('logs warning for non-object input', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  it('logs error for non-object input', () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     parseApiMeResponse('string', testInstance, testToken)
 
-    expect(warnSpy).toHaveBeenCalledWith(
+    expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('Invalid input: expected object'),
       'string',
     )
-    warnSpy.mockRestore()
+    errorSpy.mockRestore()
   })
 
   it('rejects javascript: avatar URLs and sets avatar to undefined', () => {
diff --git a/src/lib/server/session.ts b/src/lib/server/session.ts
--- a/src/lib/server/session.ts
+++ b/src/lib/server/session.ts
@@ -154,8 +154,13 @@
 /**
  * Parses and validates a /api/me response into an AccountSession.
  * Combines the API response with the instance URL and sealed token (from cookie).
- * Returns null if validation fails. Logs warnings for each specific validation failure
- * to aid debugging.
+ * Returns null if validation fails.
+ *
+ * Identity-level failures (non-object body, missing/invalid DID or handle) are
+ * logged at error level: they can only occur when /api/me returns HTTP 200 with
+ * a body that breaches the backend contract, which silently logs the user out
+ * and warrants investigation. Recoverable issues (e.g. an unsafe avatar URL,
+ * which is simply dropped) are logged at warn level.
  */
 export function parseApiMeResponse(
   data: unknown,
diff --git a/src/routes/c/[handle]/post/[rkey]/+page.svelte b/src/routes/c/[handle]/post/[rkey]/+page.svelte
--- a/src/routes/c/[handle]/post/[rkey]/+page.svelte
+++ b/src/routes/c/[handle]/post/[rkey]/+page.svelte
@@ -3,10 +3,16 @@ import type { ThreadViewComment } from '$lib/api/coves/types'
   import Markdown from '$lib/app/markdown/Markdown.svelte'
   import { Post } from '$lib/feature/post'
   import UserLink from '$lib/feature/user/UserLink.svelte'
+  import Placeholder from '$lib/ui/info/Placeholder.svelte'
   import { publishedToDate } from '$lib/ui/util/date'
   import { Material, Spinner } from 'mono-svelte'
   import { formatRelativeDate } from 'mono-svelte/util/RelativeDate.svelte'
-  import { ChatBubbleOvalLeft, ChevronDown, Icon } from 'svelte-hero-icons/dist'
+  import {
+    ChatBubbleOvalLeft,
+    ChevronDown,
+    Icon,
+    NoSymbol,
+  } from 'svelte-hero-icons/dist'
   import type { PageData } from './$types'
 
   interface Props {
@@ -33,6 +39,8 @@ <meta
       property="og:description"
       content={data.data.value.post.record?.content?.slice(0, 200) ?? ''}
     />
+  {:else if data.data.value?.unavailable}
+    <title>Post unavailable</title>
   {/if}
 </svelte:head>
 
@@ -84,6 +92,16 @@ Failed to load comments.
         </p>
       {/await}
     </section>
+  {:else if data.data.value?.unavailable}
+    <Material padding="lg" rounding="2xl" class="py-12">
+      <Placeholder
+        icon={NoSymbol}
+        title="Post unavailable"
+        description={data.data.value.unavailable === 'blocked'
+          ? "You've blocked this post's author."
+          : "This post may have been removed, or it isn't available yet."}
+      />
+    </Material>
   {:else}
     <div
       class="flex justify-center py-8"
diff --git a/src/routes/c/[handle]/post/[rkey]/+page.ts b/src/routes/c/[handle]/post/[rkey]/+page.ts
--- a/src/routes/c/[handle]/post/[rkey]/+page.ts
+++ b/src/routes/c/[handle]/post/[rkey]/+page.ts
@@ -1,5 +1,10 @@
 import { coves } from '$lib/api/client.svelte'
-import type { AtUri, PostView as CovesPostView } from '$lib/api/coves/types'
+import {
+  type AtUri,
+  type PostView as CovesPostView,
+  isHydratedPost,
+} from '$lib/api/coves/types'
+import type { Handle } from '$lib/types/atproto'
 import { settings } from '$lib/app/settings.svelte'
 import { mapSort } from '$lib/app/sort'
 import { communityHandleFromSlug, ReactiveState } from '$lib/app/util.svelte'
@@ -14,12 +19,14 @@
 const POST_COLLECTION = 'social.coves.community.post'
 
 /**
- * Constructs an AT-URI for a post from the community handle and record key.
- * Used as a fallback when navigating directly to a post URL without a cache hit.
- * The handle-based AT-URI is resolved by the backend to the canonical DID-based form.
+ * Constructs the canonical DID-based AT-URI for a post.
+ * Used as a fallback when navigating directly to a post URL without a cache hit
+ * or an explicit `?uri=` param. Building it from the community's DID (rather than
+ * its handle) keeps the hydration path stable across community renames — the one
+ * handle→DID hop is resolved up front via `getCommunity`.
  */
-function buildPostAtUri(communityHandle: string, rkey: string): AtUri {
-  return `at://${communityHandle}/${POST_COLLECTION}/${rkey}` as AtUri
+function buildPostAtUri(communityDid: string, rkey: string): AtUri {
+  return `at://${communityDid}/${POST_COLLECTION}/${rkey}` as AtUri
 }
 
 /**
@@ -72,9 +79,27 @@ findInFeed('/', params.rkey) ?? findInFeed('/c/[handle]', params.rkey)
 
   const feedData = feed(route.id, async (p) => {
     // If we have a preloaded post from cache, use it. Otherwise fetch from API.
-    const post: CovesPostView =
-      p.preload ??
-      (await coves({ func: fetch }).getPost({ uri: p.postUri as AtUri }))
+    const result =
+      p.preload ?? (await coves({ func: fetch }).getPost(p.postUri as AtUri))
+
+    // The batch endpoint returns a union: a hydrated post, or an unavailable
+    // sentinel (deleted/unindexed/unresolvable/blocked). Surface the latter as
+    // an "unavailable" state instead of throwing into the error page. We log
+    // which discriminator fired so that a real bug in buildPostAtUri (wrong
+    // DID/rkey) or indexing lag is discoverable rather than silently rendering
+    // as "this post was removed".
+    if (!isHydratedPost(result)) {
+      const reason: 'notFound' | 'blocked' =
+        result != null && 'blocked' in result ? 'blocked' : 'notFound'
+      console.warn(
+        `[post-loader] Post unavailable (${reason}) for ${p.postUri}`,
+      )
+      return {
+        unavailable: reason,
+        comments: Promise.resolve([]),
+        params: p,
+      }
+    }
 
     // Fetch comments in parallel (returned as a promise for streaming)
     const commentsPromise = coves({ func: fetch })
@@ -82,18 +107,23 @@ .getComments(p.comments)
       .then((r) => r.comments)
 
     return {
-      post,
+      post: result,
       comments: commentsPromise,
       params: p,
     }
   })
 
-  // Build the post URI. Prefer: explicit query param > feed cache > handle-based fallback.
-  // The query param is set when navigating from post creation with the canonical DID-based URI.
-  const postUri =
-    (url.searchParams.get('uri') as AtUri | null) ??
-    cachedPost?.uri ??
-    buildPostAtUri(communityHandle, params.rkey)
+  // Build the canonical DID-based post URI. Prefer sources that are already
+  // DID-based and rename-stable: the explicit `?uri=` param (set on post
+  // creation) and the feed-cache hit (the backend emits DID-based URIs).
+  // Otherwise resolve the community handle → DID once and build it ourselves.
+  let postUri = (url.searchParams.get('uri') as AtUri | null) ?? cachedPost?.uri
+  if (!postUri) {
+    const community = await coves({ func: fetch }).getCommunity({
+      community: communityHandle as Handle,
+    })
+    postUri = buildPostAtUri(community.did, params.rkey)
+  }
 
   const loaded = new ReactiveState(
     await feedData.load({
@@ -109,16 +139,21 @@ thread: { showContext, singleThread, focus },
     }),
   )
 
+  // The community ref rides along on the post. When the post is unavailable
+  // there's nothing to populate the card with, so fall back to the default
+  // sidebar (omitting the slot) rather than rendering a broken CommunityCard.
+  const community = loaded.value?.post?.community
+
   return {
     data: loaded,
     communityHandle,
-    slots: {
-      sidebar: {
-        component: CommunityCard,
-        props: {
-          community: loaded.value?.post?.community,
-        },
-      },
-    },
+    slots: community
+      ? {
+          sidebar: {
+            component: CommunityCard,
+            props: { community },
+          },
+        }
+      : undefined,
   }
 }
diff --git a/src/routes/c/[handle]/post/[rkey]/page.test.ts b/src/routes/c/[handle]/post/[rkey]/page.test.ts
new file mode 100644
--- /dev/null
+++ b/src/routes/c/[handle]/post/[rkey]/page.test.ts
@@ -0,0 +1,227 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// ---------------------------------------------------------------------------
+// Mocks
+//
+// The loader leans on three side-effecty modules: the Coves XRPC client, the
+// feed cache/`feed()` factory, and `ReactiveState` (a `$state` rune wrapper).
+// We replace all three with lightweight fakes so the load function can be
+// exercised in a plain node test environment and so each branch's API calls
+// can be asserted.
+// ---------------------------------------------------------------------------
+
+const mockCovesMethods = vi.hoisted(() => ({
+  getPost: vi.fn(),
+  getComments: vi.fn(),
+  getCommunity: vi.fn(),
+}))
+
+// The feed cache the loader's `findInFeed` reads via `feeds.get(id)?.peek()`.
+const mockFeeds = vi.hoisted(() => new Map<string, { peek: () => unknown }>())
+
+vi.mock('$lib/api/client.svelte', () => ({
+  coves: () => mockCovesMethods,
+}))
+
+// `feed(id, init)` returns an object whose `.load(params)` simply runs `init`.
+// This makes the loader's init callback the unit under test.
+vi.mock('$lib/feature/feeds/feed.svelte', () => ({
+  feed: (
+    _id: string,
+    init: (params: unknown) => Promise<unknown>,
+  ): { load: (params: unknown) => Promise<unknown> } => ({
+    load: async (params: unknown) => init(params),
+  }),
+  feeds: mockFeeds,
+}))
+
+// `ReactiveState` is a `$state`-backed wrapper; in a plain `.test.ts` (node env,
+// no runes transform) we stub it with a trivial value holder.
+vi.mock('$lib/app/util.svelte', async () => {
+  const actual = await vi.importActual<typeof import('$lib/app/util.svelte')>(
+    '$lib/app/util.svelte',
+  )
+  return {
+    ...actual,
+    ReactiveState: class<T> {
+      value: T
+      constructor(initialValue: T) {
+        this.value = initialValue
+      }
+    },
+  }
+})
+
+// `settings.svelte` and `sort` pull in env/runes side effects unrelated to the
+// branches under test; stub them to the minimum the loader touches.
+vi.mock('$lib/app/settings.svelte', () => ({
+  settings: { defaultSort: { comments: 'hot' } },
+}))
+
+vi.mock('$lib/app/sort', () => ({
+  mapSort: () => ({ sort: 'hot' }),
+}))
+
+import CommunityCard from '$lib/feature/community/CommunityCard.svelte'
+import { load } from './+page'
+
+const COMMUNITY_DID = 'did:plc:community123'
+const POST_COLLECTION = 'social.coves.community.post'
+
+// The loader only destructures { params, url, fetch, route }; supplying those
+// four is sufficient at runtime. Cast to the full LoadEvent for the type, the
+// same way the repo's other load tests do (see u/[handle]/page.test.ts).
+function makeArgs(overrides?: {
+  handle?: string
+  rkey?: string
+  url?: string
+}): Parameters<typeof load>[0] {
+  return {
+    params: {
+      handle: overrides?.handle ?? 'testcommunity',
+      rkey: overrides?.rkey ?? 'abc123',
+    },
+    url: new URL(
+      overrides?.url ??
+        `https://coves.test/c/${overrides?.handle ?? 'testcommunity'}/post/${overrides?.rkey ?? 'abc123'}`,
+    ),
+    fetch: globalThis.fetch,
+    route: { id: '/c/[handle]/post/[rkey]' },
+  } as unknown as Parameters<typeof load>[0]
+}
+
+function hydratedPost(rkey: string) {
+  const uri = `at://${COMMUNITY_DID}/${POST_COLLECTION}/${rkey}`
+  return {
+    uri,
+    cid: 'bafyreigh2akiscaildc',
+    rkey,
+    indexedAt: '2026-01-01T00:00:00.000Z',
+    createdAt: '2026-01-01T00:00:00.000Z',
+    author: { did: 'did:plc:author', handle: 'author.coves.test' },
+    community: {
+      did: COMMUNITY_DID,
+      handle: 'c-testcommunity',
+      name: 'testcommunity',
+    },
+    record: { title: 'Hello', content: 'World' },
+  }
+}
+
+// The loaded `ReactiveState` is mocked to a plain `{ value }` holder; this
+// narrows the unknown return for assertions.
+function loadedValue(
+  result: Awaited<ReturnType<typeof load>>,
+): Record<string, unknown> {
+  return (result.data as { value: Record<string, unknown> }).value
+}
+
+describe('post loader', () => {
+  beforeEach(() => {
+    mockCovesMethods.getPost.mockReset()
+    mockCovesMethods.getComments.mockReset()
+    mockCovesMethods.getCommunity.mockReset()
+    mockFeeds.clear()
+
+    // Sensible defaults; individual tests override as needed.
+    mockCovesMethods.getCommunity.mockResolvedValue({ did: COMMUNITY_DID })
+    mockCovesMethods.getComments.mockResolvedValue({ comments: [] })
+  })
+
+  it('returns unavailable=notFound and does NOT fetch comments for a notFound sentinel', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockCovesMethods.getPost.mockResolvedValue({
+      uri: `at://${COMMUNITY_DID}/${POST_COLLECTION}/abc123`,
+      notFound: true,
+    })
+
+    const result = await load(makeArgs())
+    const value = loadedValue(result)
+
+    expect(value.unavailable).toBe('notFound')
+    expect(value.post).toBeUndefined()
+    expect(mockCovesMethods.getComments).not.toHaveBeenCalled()
+    expect(result.slots).toBeUndefined()
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('notFound'))
+
+    warn.mockRestore()
+  })
+
+  it('returns unavailable=blocked and does NOT fetch comments for a blocked sentinel', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    mockCovesMethods.getPost.mockResolvedValue({
+      uri: `at://${COMMUNITY_DID}/${POST_COLLECTION}/abc123`,
+      blocked: true,
+    })
+
+    const result = await load(makeArgs())
+    const value = loadedValue(result)
+
+    expect(value.unavailable).toBe('blocked')
+    expect(value.post).toBeUndefined()
+    expect(mockCovesMethods.getComments).not.toHaveBeenCalled()
+    expect(result.slots).toBeUndefined()
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('blocked'))
+
+    warn.mockRestore()
+  })
+
+  it('returns the hydrated post, fetches comments, and builds a CommunityCard slot on the happy path', async () => {
+    const post = hydratedPost('abc123')
+    mockCovesMethods.getPost.mockResolvedValue(post)
+
+    const result = await load(makeArgs())
+    const value = loadedValue(result)
+
+    expect(value.post).toEqual(post)
+    expect(value.unavailable).toBeUndefined()
+    expect(mockCovesMethods.getComments).toHaveBeenCalledTimes(1)
+
+    expect(result.slots).toBeDefined()
+    const slots = result.slots as {
+      sidebar: { component: unknown; props: { community: unknown } }
+    }
+    expect(slots.sidebar.component).toBe(CommunityCard)
+    expect(slots.sidebar.props.community).toEqual(post.community)
+  })
+
+  it('URI precedence: uses ?uri= verbatim and does NOT call getCommunity', async () => {
+    const explicitUri = `at://${COMMUNITY_DID}/${POST_COLLECTION}/from-query`
+    mockCovesMethods.getPost.mockResolvedValue(hydratedPost('from-query'))
+
+    await load(
+      makeArgs({
+        url: `https://coves.test/c/testcommunity/post/abc123?uri=${encodeURIComponent(explicitUri)}`,
+      }),
+    )
+
+    expect(mockCovesMethods.getCommunity).not.toHaveBeenCalled()
+    expect(mockCovesMethods.getPost).toHaveBeenCalledWith(explicitUri)
+  })
+
+  it('URI precedence: uses a feed-cache hit as preload and calls neither getPost nor getCommunity', async () => {
+    const cachedPost = hydratedPost('abc123')
+    // `findInFeed` reads `feeds.get('/')?.peek()?.feed[].post`.
+    mockFeeds.set('/', {
+      peek: () => ({ feed: [{ post: cachedPost }] }),
+    })
+
+    const result = await load(makeArgs({ rkey: 'abc123' }))
+    const value = loadedValue(result)
+
+    expect(value.post).toEqual(cachedPost)
+    expect(mockCovesMethods.getPost).not.toHaveBeenCalled()
+    expect(mockCovesMethods.getCommunity).not.toHaveBeenCalled()
+  })
+
+  it('URI precedence: with neither ?uri= nor cache, resolves community DID and builds the post URI', async () => {
+    mockCovesMethods.getCommunity.mockResolvedValue({ did: COMMUNITY_DID })
+    mockCovesMethods.getPost.mockResolvedValue(hydratedPost('abc123'))
+
+    await load(makeArgs({ rkey: 'abc123' }))
+
+    expect(mockCovesMethods.getCommunity).toHaveBeenCalledTimes(1)
+    const builtUri = `at://${COMMUNITY_DID}/${POST_COLLECTION}/abc123`
+    expect(mockCovesMethods.getPost).toHaveBeenCalledWith(builtUri)
+  })
+})