@codingfactory/socialkit-vue 0.5.2 → 0.6.0

package/src/stores/content.ts

@@ -0,0 +1,1477 @@
+/**
+ * Generic content/feed store factory for SocialKit-powered frontends.
+ */
+
+import { isAxiosError } from 'axios'
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { FeedResponse } from '../types/content-api.js'
+import type {
+  Comment,
+  ContentActiveRecipeMeta,
+  ContentStoreConfig,
+  FeedEntry,
+  PendingPost,
+  PendingVideoRender,
+  Post,
+  PostAuthor,
+  PostFeeling,
+  PostMedia,
+  PostMeta,
+  PostShareType,
+  ProcessPendingPostResult,
+  RecoverablePendingDraft,
+  ScheduledPostsPage,
+} from '../types/content.js'
+import type { LocalMediaItem } from '../types/media.js'
+
+type FeedMode = 'following' | 'for_you' | 'discover'
+
+type RecentCreatedPostRecord = {
+  post: Post
+  rememberedAt: string
+}
+
+type FeedHomeResponse = {
+  data?: FeedEntry[] | { entries?: FeedEntry[] }
+  entries?: FeedEntry[]
+  next_cursor?: string | null
+  meta?: {
+    next_cursor?: string | null
+    has_more?: boolean
+    active_recipe?: ContentActiveRecipeMeta | null
+  }
+}
+
+export type ContentStoreReturn = ReturnType<ReturnType<typeof createContentStoreDefinition>>
+
+const PENDING_POSTS_STORAGE_KEY = 'socialkit_pending_posts'
+const RECENT_CREATED_POSTS_STORAGE_KEY = 'socialkit_recent_created_posts'
+const MAX_RETRY_ATTEMPTS = 5
+const MAX_PENDING_AGE_MS = 24 * 60 * 60 * 1000
+const MAX_RECENT_CREATED_POST_AGE_MS = 6 * 60 * 60 * 1000
+const MAX_RECENT_CREATED_POSTS = 8
+const FEED_IN_FLIGHT_REQUEST_STALE_MS = 12_000
+const LOST_MEDIA_ERROR_MESSAGE = 'Attached media was lost after page reload. Please cancel and re-create this post with your photos/videos.'
+const LEGACY_CLIENT_RETRYABLE_ERROR_FRAGMENTS = [
+  'ensureCsrf is not a function',
+]
+
+function normalizePageSize(pageSize: number | undefined): number {
+  const parsed = Number(pageSize ?? 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return 10
+  }
+
+  return Math.trunc(parsed)
+}
+
+export function createContentStoreDefinition(config: ContentStoreConfig) {
+  const {
+    client,
+    mediaUploadService,
+    getCurrentUser,
+    syncActiveRecipe,
+    storage = null,
+    pageSize,
+    logger = console,
+    storeId = 'content',
+  } = config
+
+  const resolvedPageSize = normalizePageSize(pageSize)
+
+  return defineStore(storeId, () => {
+    const entries = ref<FeedEntry[]>([])
+    const nextCursor = ref<string | null>(null)
+    const loading = ref(false)
+    const error = ref<string | null>(null)
+    const feedMode = ref<FeedMode>('for_you')
+    let feedRequestSequence = 0
+    let latestFreshFeedRequestToken = 0
+    let activeFeedRequests = 0
+    const inFlightFeedRequests = new Map<string, { promise: Promise<FeedResponse>; startedAt: number }>()
+
+    const pendingPosts = ref<PendingPost[]>([])
+    const recentCreatedPosts = ref<RecentCreatedPostRecord[]>([])
+    const composerFeeling = ref<PostFeeling | null>(null)
+
+    const hasPendingPosts = computed(() => pendingPosts.value.length > 0)
+    const PAGE_SIZE = resolvedPageSize
+
+    const isPostEntryType = (type: string | undefined | null): boolean => {
+      if (!type) {
+        return false
+      }
+
+      const normalized = type.toLowerCase()
+      return normalized === 'post'
+        || normalized.endsWith('\\post')
+        || normalized.endsWith('.post')
+        || normalized.includes('content.post')
+    }
+
+    const entryKey = (entry: FeedEntry): string => `${(entry.entity_type || '').toLowerCase()}|${entry.entity_id}`
+    const feedRequestKey = (mode: FeedMode, cursor?: string): string => `${mode}|${cursor ?? '__fresh__'}`
+
+    const removeDuplicateEntriesForKey = (keepIndex: number): void => {
+      const keepEntry = entries.value[keepIndex]
+      if (!keepEntry) {
+        return
+      }
+
+      const keepKey = entryKey(keepEntry)
+      entries.value = entries.value.filter((entry, index) => (
+        index === keepIndex || entryKey(entry) !== keepKey
+      ))
+    }
+
+    const DISCIPLINE_ERROR_CODES = new Set([
+      'ACCOUNT_WRITE_TIMEOUT',
+      'ACCOUNT_BANNED',
+    ])
+
+    const DISCIPLINE_ERROR_MESSAGES: Record<string, string> = {
+      ACCOUNT_WRITE_TIMEOUT: 'Your account is temporarily suspended. You cannot post at this time.',
+      ACCOUNT_BANNED: 'Your account has been suspended. You cannot post.',
+    }
+
+    const DISCIPLINE_ERROR_STRINGS = new Set([
+      ...Object.values(DISCIPLINE_ERROR_MESSAGES),
+      'account write-timeout active',
+      'account banned',
+    ])
+
+    const isDisciplineError = (errorMessage: string): boolean => {
+      const lower = errorMessage.toLowerCase()
+      for (const known of DISCIPLINE_ERROR_STRINGS) {
+        if (lower === known.toLowerCase()) {
+          return true
+        }
+      }
+
+      return false
+    }
+
+    const isLegacyClientRetryableError = (errorMessage: string): boolean => {
+      const lower = errorMessage.toLowerCase()
+      return LEGACY_CLIENT_RETRYABLE_ERROR_FRAGMENTS.some((fragment) => lower.includes(fragment.toLowerCase()))
+    }
+
+    const isDisciplineAxiosError = (err: unknown): boolean => {
+      const status = (err as { response?: { status?: number } }).response?.status
+      if (status === 423) {
+        return true
+      }
+
+      const code = (err as { response?: { data?: { code?: string } } }).response?.data?.code
+      return typeof code === 'string' && DISCIPLINE_ERROR_CODES.has(code)
+    }
+
+    const resolvePendingPostErrorMessage = (err: unknown): string => {
+      const responseData = (err as {
+        response?: {
+          data?: {
+            message?: string
+            code?: string
+            errors?: Record<string, string[] | string>
+          }
+        }
+      }).response?.data
+
+      if (typeof responseData?.code === 'string' && responseData.code in DISCIPLINE_ERROR_MESSAGES) {
+        return DISCIPLINE_ERROR_MESSAGES[responseData.code] ?? 'Failed to create post'
+      }
+
+      const fieldErrors = responseData?.errors
+        ? Object.values(responseData.errors).flatMap((fieldError) => (
+          Array.isArray(fieldError) ? fieldError : [fieldError]
+        ))
+        : []
+
+      const firstFieldError = fieldErrors.find((message): message is string => (
+        typeof message === 'string' && message.trim() !== ''
+      ))
+      if (firstFieldError) {
+        return firstFieldError
+      }
+
+      if (typeof responseData?.message === 'string' && responseData.message.trim() !== '') {
+        return responseData.message
+      }
+
+      if (err instanceof Error && err.message.trim() !== '') {
+        return err.message
+      }
+
+      return 'Failed to create post'
+    }
+
+    function setFeedMode(mode: FeedMode): void {
+      if (feedMode.value === mode) {
+        return
+      }
+
+      feedMode.value = mode
+      entries.value = []
+      nextCursor.value = null
+    }
+
+    function generateTempId(): string {
+      return `pending-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`
+    }
+
+    function persistPendingPosts(): void {
+      if (storage === null) {
+        return
+      }
+
+      try {
+        const serializable = pendingPosts.value.map((pending) => ({
+          tempId: pending.tempId,
+          body: pending.body,
+          share_type: pending.share_type,
+          quoted_post_id: pending.quoted_post_id,
+          visibility: pending.visibility,
+          content_warning: pending.content_warning,
+          meta: pending.meta,
+          media_ids: pending.media_ids,
+          hadUnuploadedMedia: pending.hadUnuploadedMedia || (pending.mediaItems != null && pending.mediaItems.length > 0) || undefined,
+          container_type: pending.container_type,
+          container_id: pending.container_id,
+          status: pending.status,
+          createdAt: pending.createdAt,
+          retryCount: pending.retryCount,
+          error: pending.error,
+        }))
+        storage.setItem(PENDING_POSTS_STORAGE_KEY, JSON.stringify(serializable))
+      } catch (storageError) {
+        logger.error('[ContentStore] Failed to persist pending posts:', storageError)
+      }
+    }
+
+    const normalizeStoredRecentCreatedPosts = (stored: unknown): RecentCreatedPostRecord[] => {
+      if (!Array.isArray(stored)) {
+        return []
+      }
+
+      const normalized: RecentCreatedPostRecord[] = []
+      for (const candidate of stored) {
+        if (candidate === null || typeof candidate !== 'object') {
+          continue
+        }
+
+        const rememberedAtRaw = Reflect.get(candidate, 'remembered_at')
+        const postRaw = Reflect.get(candidate, 'post')
+
+        if (typeof rememberedAtRaw !== 'string') {
+          continue
+        }
+
+        const rememberedAtMs = Date.parse(rememberedAtRaw)
+        if (!Number.isFinite(rememberedAtMs)) {
+          continue
+        }
+
+        if (postRaw === null || typeof postRaw !== 'object') {
+          continue
+        }
+
+        const postIdRaw = Reflect.get(postRaw, 'id')
+        if (typeof postIdRaw !== 'string' || postIdRaw.trim() === '') {
+          continue
+        }
+
+        normalized.push({
+          post: postRaw as Post,
+          rememberedAt: rememberedAtRaw,
+        })
+      }
+
+      return normalized
+    }
+
+    const isRecentCreatedPostExpired = (rememberedAt: string): boolean => {
+      const rememberedAtMs = Date.parse(rememberedAt)
+      if (!Number.isFinite(rememberedAtMs)) {
+        return true
+      }
+
+      return Date.now() - rememberedAtMs > MAX_RECENT_CREATED_POST_AGE_MS
+    }
+
+    const isRecentCreatedPostOwnedByCurrentActor = (post: Post): boolean => {
+      const actorIdRaw = getCurrentUser()?.id
+      if (typeof actorIdRaw !== 'string' || actorIdRaw.trim() === '') {
+        return true
+      }
+
+      const postAuthorId = typeof post.author_id === 'string' ? post.author_id.trim() : ''
+      if (postAuthorId === '') {
+        return true
+      }
+
+      return postAuthorId === actorIdRaw.trim()
+    }
+
+    const pruneRecentCreatedPosts = (): void => {
+      const next = recentCreatedPosts.value
+        .filter((entry) => !isRecentCreatedPostExpired(entry.rememberedAt))
+        .filter((entry) => isRecentCreatedPostOwnedByCurrentActor(entry.post))
+        .slice(0, MAX_RECENT_CREATED_POSTS)
+
+      if (next.length === recentCreatedPosts.value.length) {
+        return
+      }
+
+      recentCreatedPosts.value = next
+      persistRecentCreatedPosts()
+    }
+
+    function persistRecentCreatedPosts(): void {
+      if (storage === null) {
+        return
+      }
+
+      try {
+        const serializable = recentCreatedPosts.value
+          .slice(0, MAX_RECENT_CREATED_POSTS)
+          .map((entry) => ({
+            post: entry.post,
+            remembered_at: entry.rememberedAt,
+          }))
+        storage.setItem(RECENT_CREATED_POSTS_STORAGE_KEY, JSON.stringify(serializable))
+      } catch (storageError) {
+        logger.error('[ContentStore] Failed to persist recent created posts:', storageError)
+      }
+    }
+
+    function restoreRecentCreatedPosts(): void {
+      if (storage === null) {
+        return
+      }
+
+      try {
+        const stored = storage.getItem(RECENT_CREATED_POSTS_STORAGE_KEY)
+        if (!stored) {
+          recentCreatedPosts.value = []
+          return
+        }
+
+        const parsed = JSON.parse(stored) as unknown
+        recentCreatedPosts.value = normalizeStoredRecentCreatedPosts(parsed)
+        pruneRecentCreatedPosts()
+      } catch (storageError) {
+        logger.error('[ContentStore] Failed to restore recent created posts:', storageError)
+        recentCreatedPosts.value = []
+      }
+    }
+
+    function rememberRecentCreatedPost(post: Post): void {
+      const postId = typeof post.id === 'string' ? post.id.trim() : ''
+      if (postId === '') {
+        return
+      }
+
+      if (!isRecentCreatedPostOwnedByCurrentActor(post)) {
+        return
+      }
+
+      const next = recentCreatedPosts.value.filter((entry) => entry.post.id !== postId)
+      next.unshift({
+        post,
+        rememberedAt: new Date().toISOString(),
+      })
+
+      recentCreatedPosts.value = next.slice(0, MAX_RECENT_CREATED_POSTS)
+      pruneRecentCreatedPosts()
+      persistRecentCreatedPosts()
+    }
+
+    const buildRecentCreatedFeedEntries = (existingKeys: Set<string>): FeedEntry[] => {
+      pruneRecentCreatedPosts()
+
+      if (recentCreatedPosts.value.length === 0) {
+        return []
+      }
+
+      const remainingRecentPosts: RecentCreatedPostRecord[] = []
+      const recentEntries: FeedEntry[] = []
+
+      for (const entry of recentCreatedPosts.value) {
+        const postId = typeof entry.post.id === 'string' ? entry.post.id.trim() : ''
+        if (postId === '') {
+          continue
+        }
+
+        const key = `post|${postId}`
+        if (existingKeys.has(key)) {
+          continue
+        }
+
+        existingKeys.add(key)
+        remainingRecentPosts.push(entry)
+        recentEntries.push({
+          id: `entry-${postId}`,
+          entity_id: postId,
+          entity_type: 'post',
+          created_at: entry.post.created_at,
+          post: entry.post,
+        })
+      }
+
+      if (remainingRecentPosts.length !== recentCreatedPosts.value.length) {
+        recentCreatedPosts.value = remainingRecentPosts
+        persistRecentCreatedPosts()
+      }
+
+      return recentEntries
+    }
+
+    const refreshRecentCreatedPostsFromApi = async (): Promise<void> => {
+      pruneRecentCreatedPosts()
+
+      if (recentCreatedPosts.value.length === 0) {
+        return
+      }
+
+      const refreshedRecentPosts = await Promise.all(
+        recentCreatedPosts.value.map(async (entry): Promise<RecentCreatedPostRecord | null> => {
+          const postId = typeof entry.post.id === 'string' ? entry.post.id.trim() : ''
+          if (postId === '') {
+            return null
+          }
+
+          try {
+            const response = await client.get<Post>(`/v1/content/posts/${postId}`)
+            const refreshedPost = (response as { data?: Post }).data
+
+            if (refreshedPost && typeof refreshedPost.id === 'string' && refreshedPost.id.trim() !== '') {
+              return {
+                post: refreshedPost,
+                rememberedAt: entry.rememberedAt,
+              }
+            }
+          } catch (refreshError) {
+            if (isAxiosError(refreshError)) {
+              const statusCode = refreshError.response?.status
+              if (statusCode === 403 || statusCode === 404) {
+                return null
+              }
+            }
+
+            logger.error(`[ContentStore] Failed to refresh recent post ${postId}:`, refreshError)
+          }
+
+          return entry
+        }),
+      )
+
+      const nextRecentPosts = refreshedRecentPosts.filter((entry): entry is RecentCreatedPostRecord => entry !== null)
+      const hasChanges = nextRecentPosts.length !== recentCreatedPosts.value.length
+        || nextRecentPosts.some((entry, index) => {
+          const previousEntry = recentCreatedPosts.value[index]
+          if (!previousEntry) {
+            return true
+          }
+
+          return previousEntry.post.id !== entry.post.id
+            || previousEntry.post.updated_at !== entry.post.updated_at
+            || previousEntry.post.visibility !== entry.post.visibility
+            || previousEntry.post.is_quarantined !== entry.post.is_quarantined
+        })
+
+      if (!hasChanges) {
+        return
+      }
+
+      recentCreatedPosts.value = nextRecentPosts
+      persistRecentCreatedPosts()
+    }
+
+    function restorePendingPosts(): void {
+      if (storage === null) {
+        return
+      }
+
+      try {
+        const stored = storage.getItem(PENDING_POSTS_STORAGE_KEY)
+        if (!stored) {
+          return
+        }
+
+        const parsed = JSON.parse(stored) as PendingPost[]
+        const now = Date.now()
+
+        const freshPosts = parsed.filter((pending) => {
+          const age = now - new Date(pending.createdAt).getTime()
+          return age < MAX_PENDING_AGE_MS
+        })
+
+        const nonDisciplinePosts = freshPosts.filter((pending) => {
+          if (pending.status === 'failed' && typeof pending.error === 'string' && isDisciplineError(pending.error)) {
+            logger.info('[ContentStore] Removing non-retryable discipline-failed post from storage:', pending.tempId)
+            return false
+          }
+
+          return true
+        })
+
+        const autoRetryLegacyFailedPostIds: string[] = []
+        const restoredPosts = nonDisciplinePosts.map((pending) => {
+          const lostMedia = pending.hadUnuploadedMedia === true
+            && (pending.mediaItems == null || pending.mediaItems.length === 0)
+            && (pending.media_ids == null || pending.media_ids.length === 0)
+          if (lostMedia) {
+            return { ...pending, status: 'failed' as const, error: LOST_MEDIA_ERROR_MESSAGE }
+          }
+
+          if (
+            pending.status === 'failed'
+            && typeof pending.error === 'string'
+            && isLegacyClientRetryableError(pending.error)
+            && pending.retryCount < MAX_RETRY_ATTEMPTS
+          ) {
+            autoRetryLegacyFailedPostIds.push(pending.tempId)
+            return {
+              ...pending,
+              status: 'pending' as const,
+              error: undefined,
+            }
+          }
+
+          return pending
+        })
+
+        pendingPosts.value = restoredPosts
+
+        restoredPosts.forEach((pending) => {
+          const existingEntry = entries.value.find((entry) => entry.post?._tempId === pending.tempId)
+          if (!existingEntry) {
+            addOptimisticEntry(pending)
+          }
+        })
+
+        const removedDiscipline = nonDisciplinePosts.length !== freshPosts.length
+        if (
+          freshPosts.length !== parsed.length
+          || removedDiscipline
+          || autoRetryLegacyFailedPostIds.length > 0
+          || restoredPosts.some((pending) => pending.status === 'failed' && pending.error === LOST_MEDIA_ERROR_MESSAGE)
+        ) {
+          persistPendingPosts()
+        }
+
+        for (const tempId of autoRetryLegacyFailedPostIds) {
+          void retryPendingPost(tempId)
+        }
+      } catch (storageError) {
+        logger.error('[ContentStore] Failed to restore pending posts:', storageError)
+        pendingPosts.value = []
+      }
+    }
+
+    function addOptimisticEntry(pending: PendingPost): void {
+      const currentUser = getCurrentUser()
+      const optimisticAuthor: PostAuthor = {
+        id: currentUser?.id ?? '',
+        name: currentUser?.name ?? '',
+        username: currentUser?.handle ?? currentUser?.name ?? '',
+      }
+
+      if (currentUser?.avatar) {
+        optimisticAuthor.avatar = currentUser.avatar
+      }
+
+      const optimisticPost: Post & { _isPending?: boolean; _tempId?: string } = {
+        id: pending.tempId,
+        body: pending.body,
+        ...(pending.share_type && { share_type: pending.share_type }),
+        ...(pending.quoted_post_id && { quoted_post_id: pending.quoted_post_id }),
+        author: optimisticAuthor,
+        author_id: currentUser?.id ?? '',
+        reactions_count: 0,
+        comments_count: 0,
+        user_has_reacted: false,
+        visibility: pending.visibility as 'public' | 'private' | 'friends',
+        created_at: pending.createdAt,
+        _isPending: true,
+        _tempId: pending.tempId,
+      }
+
+      if (pending.meta !== undefined) {
+        optimisticPost.meta = pending.meta
+      }
+
+      if (pending.content_warning !== undefined) {
+        optimisticPost.content_warning = pending.content_warning
+      }
+
+      const entry: FeedEntry = {
+        id: `entry-${pending.tempId}`,
+        entity_id: pending.tempId,
+        entity_type: 'post',
+        created_at: pending.createdAt,
+        post: optimisticPost,
+      }
+
+      entries.value.unshift(entry)
+    }
+
+    function enqueuePost(input: {
+      body: string
+      share_type?: PostShareType
+      quoted_post_id?: string
+      visibility?: string
+      content_warning?: string
+      meta?: PostMeta
+      media_ids?: string[]
+      mediaItems?: LocalMediaItem[]
+      container_type?: string
+      container_id?: string
+      pendingVideoRenders?: PendingVideoRender[]
+    }): PendingPost {
+      const hasUnuploadedMedia = input.mediaItems != null && input.mediaItems.length > 0
+      const pending: PendingPost = {
+        tempId: generateTempId(),
+        body: input.body,
+        share_type: input.share_type,
+        quoted_post_id: input.quoted_post_id,
+        visibility: input.visibility || 'public',
+        content_warning: input.content_warning,
+        ...(input.meta && { meta: input.meta }),
+        media_ids: input.media_ids ?? undefined,
+        mediaItems: input.mediaItems ?? undefined,
+        hadUnuploadedMedia: hasUnuploadedMedia || undefined,
+        container_type: input.container_type,
+        container_id: input.container_id,
+        pendingVideoRenders: input.pendingVideoRenders,
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+        retryCount: 0,
+        error: undefined,
+      }
+
+      pendingPosts.value.push(pending)
+      persistPendingPosts()
+      addOptimisticEntry(pending)
+
+      return pending
+    }
+
+    async function processPendingPost(tempId: string): Promise<ProcessPendingPostResult> {
+      const pendingIndex = pendingPosts.value.findIndex((pending) => pending.tempId === tempId)
+      if (pendingIndex === -1) {
+        return {
+          ok: false,
+          retryable: true,
+          error: 'Post draft no longer exists. Please try again.',
+        }
+      }
+
+      if (pendingPosts.value[pendingIndex]) {
+        pendingPosts.value[pendingIndex].status = 'uploading'
+        pendingPosts.value[pendingIndex].error = undefined
+        persistPendingPosts()
+      } else {
+        return {
+          ok: false,
+          retryable: true,
+          error: 'Post draft no longer exists. Please try again.',
+        }
+      }
+
+      const pending = pendingPosts.value[pendingIndex]
+
+      try {
+        let finalMediaIds: string[] = pending.media_ids || []
+
+        if (pending.mediaItems && pending.mediaItems.length > 0) {
+          const uploadedIds = await mediaUploadService.uploadLocalMediaItems(pending.mediaItems)
+          finalMediaIds = [...finalMediaIds, ...uploadedIds]
+        }
+
+        const response = await client.post('/v1/content/posts', {
+          body: pending.body,
+          ...(pending.share_type && { share_type: pending.share_type }),
+          ...(pending.quoted_post_id && { quoted_post_id: pending.quoted_post_id }),
+          visibility: pending.visibility,
+          ...(pending.content_warning && { content_warning: pending.content_warning }),
+          ...(pending.meta && { meta: pending.meta }),
+          ...(finalMediaIds.length > 0 && { media_ids: finalMediaIds }),
+          ...(pending.container_type && { container_type: pending.container_type }),
+          ...(pending.container_id && { container_id: pending.container_id }),
+        })
+
+        const serverPost: Post | undefined = (response as { data?: Post })?.data
+        if (!serverPost || typeof serverPost.id !== 'string' || serverPost.id.trim() === '') {
+          throw new Error('Server did not confirm post creation. Please try again.')
+        }
+
+        const entryIndex = entries.value.findIndex((entry) => entry.post?._tempId === tempId)
+        if (entryIndex !== -1) {
+          const optimisticEntry = entries.value[entryIndex]
+          const optimisticPost = optimisticEntry?.post
+
+          if (optimisticEntry && optimisticPost) {
+            const reconciledPost: Post & { _isPending?: boolean; _tempId?: string } = optimisticPost
+            Object.assign(reconciledPost, serverPost)
+            delete reconciledPost._isPending
+            delete reconciledPost._tempId
+
+            optimisticEntry.id = `entry-${serverPost.id}`
+            optimisticEntry.entity_id = serverPost.id
+            optimisticEntry.entity_type = 'post'
+            optimisticEntry.created_at = serverPost.created_at
+            optimisticEntry.post = reconciledPost
+          } else {
+            entries.value[entryIndex] = {
+              id: `entry-${serverPost.id}`,
+              entity_id: serverPost.id,
+              entity_type: 'post',
+              created_at: serverPost.created_at,
+              post: serverPost,
+            }
+          }
+
+          removeDuplicateEntriesForKey(entryIndex)
+        } else {
+          entries.value.unshift({
+            id: `entry-${serverPost.id}`,
+            entity_id: serverPost.id,
+            entity_type: 'post',
+            created_at: serverPost.created_at,
+            post: serverPost,
+          })
+        }
+
+        pendingPosts.value = pendingPosts.value.filter((currentPending) => currentPending.tempId !== tempId)
+        persistPendingPosts()
+        rememberRecentCreatedPost(serverPost)
+
+        return {
+          ok: true,
+          postId: serverPost.id,
+          isQuarantined: serverPost.is_quarantined === true,
+        }
+      } catch (err) {
+        const errorMessage = resolvePendingPostErrorMessage(err)
+
+        if (isDisciplineAxiosError(err)) {
+          const currentIndex = pendingPosts.value.findIndex((pendingItem) => pendingItem.tempId === tempId)
+          if (currentIndex !== -1 && pendingPosts.value[currentIndex]) {
+            pendingPosts.value[currentIndex] = {
+              ...pendingPosts.value[currentIndex],
+              status: 'failed',
+              error: errorMessage,
+            }
+            persistPendingPosts()
+          }
+
+          logger.warn('[ContentStore] Post blocked by discipline enforcement:', errorMessage)
+          return {
+            ok: false,
+            retryable: false,
+            error: errorMessage,
+          }
+        }
+
+        const currentIndex = pendingPosts.value.findIndex((pendingItem) => pendingItem.tempId === tempId)
+        if (currentIndex !== -1 && pendingPosts.value[currentIndex]) {
+          pendingPosts.value[currentIndex] = {
+            ...pendingPosts.value[currentIndex],
+            status: 'failed',
+            retryCount: pendingPosts.value[currentIndex].retryCount + 1,
+            error: errorMessage,
+          }
+          persistPendingPosts()
+        }
+
+        logger.error('[ContentStore] Failed to process pending post:', err)
+        return {
+          ok: false,
+          retryable: true,
+          error: errorMessage,
+        }
+      }
+    }
+
+    async function retryPendingPost(tempId: string): Promise<void> {
+      const pendingIndex = pendingPosts.value.findIndex((pending) => pending.tempId === tempId)
+      if (pendingIndex === -1) {
+        return
+      }
+
+      const pending = pendingPosts.value[pendingIndex]
+      if (!pending) {
+        return
+      }
+
+      if (pending.retryCount >= MAX_RETRY_ATTEMPTS) {
+        if (pendingPosts.value[pendingIndex]) {
+          pendingPosts.value[pendingIndex] = {
+            ...pending,
+            status: 'failed',
+            error: 'Maximum retry attempts reached. Please cancel and try again.',
+          }
+          persistPendingPosts()
+        }
+
+        return
+      }
+
+      if (pendingPosts.value[pendingIndex]) {
+        pendingPosts.value[pendingIndex] = {
+          ...pending,
+          status: 'pending',
+          error: undefined,
+        }
+        persistPendingPosts()
+      }
+
+      await processPendingPost(tempId)
+    }
+
+    function cancelPendingPost(tempId: string): void {
+      pendingPosts.value = pendingPosts.value.filter((pending) => pending.tempId !== tempId)
+      persistPendingPosts()
+      entries.value = entries.value.filter((entry) => entry.post?._tempId !== tempId)
+    }
+
+    function claimLostMediaDraft(): RecoverablePendingDraft | null {
+      const recoverablePending = pendingPosts.value.find((pending) => (
+        pending.status === 'failed'
+        && pending.error === LOST_MEDIA_ERROR_MESSAGE
+      ))
+      if (!recoverablePending) {
+        return null
+      }
+
+      const recoveredDraft: RecoverablePendingDraft = {
+        tempId: recoverablePending.tempId,
+        body: recoverablePending.body,
+        visibility: recoverablePending.visibility,
+        ...(recoverablePending.content_warning && { contentWarning: recoverablePending.content_warning }),
+      }
+
+      cancelPendingPost(recoverablePending.tempId)
+      return recoveredDraft
+    }
+
+    function setComposerFeeling(feeling: PostFeeling | null): void {
+      composerFeeling.value = feeling
+    }
+
+    function claimComposerFeeling(): PostFeeling | null {
+      const selectedFeeling = composerFeeling.value
+      composerFeeling.value = null
+      return selectedFeeling
+    }
+
+    async function loadUserPosts(userId: string, cursor?: string): Promise<FeedResponse> {
+      loading.value = true
+      error.value = null
+
+      try {
+        const params = new URLSearchParams()
+        params.set('limit', String(PAGE_SIZE))
+        params.set('author_id', userId)
+        if (cursor) {
+          params.set('after', cursor)
+        }
+
+        const url = `/v1/content/posts?${params.toString()}`
+        const response = await client.get(url)
+
+        const postsData = ((response as { data?: Post[] })?.data) || []
+        const cursorValue = ((response as { meta?: { next_cursor?: string } })?.meta?.next_cursor) || null
+        const feedEntries: FeedEntry[] = postsData.map((post) => ({
+          id: `entry-${post.id}`,
+          entity_type: 'post',
+          entity_id: post.id,
+          activity_type: 'post_published',
+          actor_id: post.author_id || post.author?.id,
+          owner_user_id: post.author_id || post.author?.id,
+          created_at: post.created_at,
+          visibility: post.visibility || 'public',
+          is_hidden: false,
+        }))
+
+        return {
+          data: {
+            entries: feedEntries,
+            meta: {
+              next_cursor: cursorValue,
+            },
+            next_cursor: cursorValue,
+          },
+          entries: feedEntries,
+          posts: postsData,
+          hasMore: ((response as { meta?: { has_more?: boolean } })?.meta?.has_more) || false,
+          nextCursor: cursorValue,
+        }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to load user posts:', err)
+        const requestError = err as { response?: { data?: { message?: string } } }
+        error.value = requestError.response?.data?.message || 'Failed to load posts'
+        throw err
+      } finally {
+        loading.value = false
+      }
+    }
+
+    async function loadFeed(cursor?: string): Promise<FeedResponse> {
+      const requestedMode = feedMode.value
+      const requestKey = feedRequestKey(requestedMode, cursor)
+      const existingRequest = inFlightFeedRequests.get(requestKey)
+      if (existingRequest) {
+        const requestAgeMs = Date.now() - existingRequest.startedAt
+        if (requestAgeMs < FEED_IN_FLIGHT_REQUEST_STALE_MS) {
+          return existingRequest.promise
+        }
+
+        inFlightFeedRequests.delete(requestKey)
+      }
+
+      const requestToken = ++feedRequestSequence
+      const isFreshLoad = !cursor
+      if (isFreshLoad) {
+        latestFreshFeedRequestToken = requestToken
+      }
+      const requestedCursor = cursor
+
+      const wasFeedRequestSuperseded = (): boolean => {
+        const modeChangedSinceRequest = requestedMode !== feedMode.value
+        const supersededByNewerFreshRequest = requestToken < latestFreshFeedRequestToken
+        const cursorLineageChanged = requestedCursor !== undefined && requestedCursor !== nextCursor.value
+
+        return modeChangedSinceRequest || supersededByNewerFreshRequest || cursorLineageChanged
+      }
+
+      const requestPromise = (async (): Promise<FeedResponse> => {
+        activeFeedRequests += 1
+        loading.value = true
+        error.value = null
+
+        try {
+          const params = new URLSearchParams()
+          params.set('limit', String(PAGE_SIZE))
+          params.set('mode', requestedMode)
+          if (cursor) {
+            params.set('cursor', cursor)
+          }
+
+          const url = `/v1/feed/home?${params.toString()}`
+          const response = await client.get(url)
+          const responseData = response as FeedHomeResponse
+          const serverEntriesRaw: FeedEntry[] = Array.isArray(responseData?.data)
+            ? responseData.data
+            : responseData?.data?.entries ?? responseData?.entries ?? []
+
+          let pageEntries: FeedEntry[] = serverEntriesRaw
+          if (pageEntries.length > 0) {
+            pageEntries = pageEntries.map((entry) => {
+              if (!isPostEntryType(entry.entity_type)) {
+                return entry
+              }
+
+              return {
+                ...entry,
+                entity_type: 'post',
+                post: entry.post ?? null,
+              }
+            })
+          }
+
+          if (wasFeedRequestSuperseded()) {
+            return {
+              data: {
+                entries: entries.value,
+                meta: {
+                  next_cursor: nextCursor.value,
+                  has_more: nextCursor.value !== null,
+                },
+                next_cursor: nextCursor.value,
+              },
+              page_entries: [],
+              next_cursor: nextCursor.value,
+            }
+          }
+
+          if (isFreshLoad && requestedMode === 'for_you') {
+            await refreshRecentCreatedPostsFromApi()
+          }
+
+          const rawNextCursor = responseData?.next_cursor ?? responseData?.meta?.next_cursor ?? null
+          const explicitHasMore = responseData?.meta?.has_more
+          const hasMorePages = explicitHasMore === true
+          const resolvedNextCursor = explicitHasMore === false ? null : rawNextCursor
+          const normalizedHasMore = explicitHasMore ?? (resolvedNextCursor !== null)
+          const hasActiveRecipe = responseData?.meta?.active_recipe !== null
+            && responseData?.meta?.active_recipe !== undefined
+
+          if (
+            requestedMode === 'for_you'
+            && !cursor
+            && pageEntries.length === 0
+            && resolvedNextCursor === null
+            && !hasMorePages
+            && !hasActiveRecipe
+          ) {
+            setFeedMode('following')
+            return loadFeed()
+          }
+
+          nextCursor.value = resolvedNextCursor
+
+          if (cursor) {
+            const existing = new Set(entries.value.map(entryKey))
+            for (const entry of pageEntries) {
+              if (!existing.has(entryKey(entry))) {
+                entries.value.push(entry)
+              }
+            }
+          } else {
+            const pendingEntries = entries.value.filter((entry) => entry.post?._isPending)
+            const seen = new Set<string>(pendingEntries.map(entryKey))
+            const freshEntries = pageEntries.filter((entry) => {
+              const key = entryKey(entry)
+              if (seen.has(key)) {
+                return false
+              }
+
+              seen.add(key)
+              return true
+            })
+            const recentCreatedEntries = requestedMode === 'for_you'
+              ? buildRecentCreatedFeedEntries(seen)
+              : []
+            entries.value = [...pendingEntries, ...recentCreatedEntries, ...freshEntries]
+          }
+
+          if (requestedMode === 'for_you' && syncActiveRecipe) {
+            const recipeMeta = responseData?.meta?.active_recipe ?? null
+            syncActiveRecipe(recipeMeta)
+          }
+
+          return {
+            data: {
+              entries: entries.value,
+              meta: {
+                next_cursor: nextCursor.value,
+                has_more: normalizedHasMore,
+              },
+              next_cursor: nextCursor.value,
+            },
+            page_entries: pageEntries,
+            next_cursor: nextCursor.value,
+          }
+        } catch (err) {
+          if (wasFeedRequestSuperseded()) {
+            return {
+              data: {
+                entries: entries.value,
+                meta: {
+                  next_cursor: nextCursor.value,
+                  has_more: nextCursor.value !== null,
+                },
+                next_cursor: nextCursor.value,
+              },
+              page_entries: [],
+              next_cursor: nextCursor.value,
+            }
+          }
+
+          logger.error('[ContentStore] Failed to load feed:', err)
+          const requestError = err as { response?: { data?: { message?: string } } }
+          error.value = requestError.response?.data?.message || 'Failed to load feed'
+
+          return {
+            data: {
+              entries: [],
+              meta: {},
+              next_cursor: null,
+            },
+            page_entries: [],
+            next_cursor: null,
+          }
+        } finally {
+          activeFeedRequests = Math.max(0, activeFeedRequests - 1)
+          loading.value = activeFeedRequests > 0
+        }
+      })()
+
+      inFlightFeedRequests.set(requestKey, {
+        promise: requestPromise,
+        startedAt: Date.now(),
+      })
+
+      return requestPromise.finally(() => {
+        const requestStillTracked = inFlightFeedRequests.get(requestKey)
+        if (requestStillTracked?.promise === requestPromise) {
+          inFlightFeedRequests.delete(requestKey)
+        }
+      })
+    }
+
+    async function loadMore(): Promise<FeedResponse> {
+      if (!nextCursor.value) {
+        return {
+          data: {
+            entries: entries.value,
+            next_cursor: null,
+          },
+          page_entries: [],
+          next_cursor: null,
+        }
+      }
+
+      return loadFeed(nextCursor.value)
+    }
+
+    async function createPost(input: {
+      body: string
+      share_type?: PostShareType
+      quoted_post_id?: string
+      visibility?: string
+      content_warning?: string
+      meta?: PostMeta
+      media_ids?: string[]
+      media_urls?: string[]
+    }): Promise<{ data: Post }> {
+      loading.value = true
+      error.value = null
+
+      try {
+        const response = await client.post('/v1/content/posts', {
+          body: input.body,
+          ...(input.share_type && { share_type: input.share_type }),
+          ...(input.quoted_post_id && { quoted_post_id: input.quoted_post_id }),
+          visibility: input.visibility || 'public',
+          ...(input.content_warning && { content_warning: input.content_warning }),
+          ...(input.meta && { meta: input.meta }),
+          ...(input.media_ids && { media_ids: input.media_ids }),
+          ...(input.media_urls && { media_urls: input.media_urls }),
+        })
+
+        const created: Post | undefined = (response as { data?: Post })?.data
+        if (created) {
+          rememberRecentCreatedPost(created)
+          entries.value.unshift({
+            entity_id: created.id,
+            entity_type: 'post',
+            created_at: created.created_at,
+            post: created,
+          })
+        } else {
+          await loadFeed()
+        }
+
+        return response as { data: Post }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to create post:', err)
+        const requestError = err as { response?: { data?: { message?: string } } }
+        error.value = requestError.response?.data?.message || 'Failed to create post'
+        throw err
+      } finally {
+        loading.value = false
+      }
+    }
+
+    async function updatePost(postId: string, input: {
+      body?: string
+      visibility?: string
+      content_warning?: string | null
+    }): Promise<{ data: Post }> {
+      loading.value = true
+      error.value = null
+
+      try {
+        const response = await client.patch(`/v1/content/posts/${postId}`, input)
+        const entry = entries.value.find((candidate) => candidate.post?.id === postId)
+        const updated = (response as { data?: Post })?.data
+        if (entry?.post && updated) {
+          Object.assign(entry.post, updated)
+        }
+
+        return response as { data: Post }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to update post:', err)
+        const requestError = err as { response?: { data?: { message?: string } } }
+        error.value = requestError.response?.data?.message || 'Failed to update post'
+        throw err
+      } finally {
+        loading.value = false
+      }
+    }
+
+    async function deletePost(postId: string): Promise<boolean> {
+      loading.value = true
+      error.value = null
+
+      try {
+        await client.delete(`/v1/content/posts/${postId}`)
+        entries.value = entries.value.filter((entry) => entry.post?.id !== postId)
+        return true
+      } catch (err) {
+        logger.error('[ContentStore] Failed to delete post:', err)
+        const requestError = err as { response?: { data?: { message?: string } } }
+        error.value = requestError.response?.data?.message || 'Failed to delete post'
+        throw err
+      } finally {
+        loading.value = false
+      }
+    }
+
+    async function toggleReaction(postId: string, _action: 'like' | 'unlike'): Promise<{ data: { added: boolean } }> {
+      try {
+        const response = await client.post('/v1/reactions/toggle', {
+          target_type: 'post',
+          target_id: postId,
+          kind: 'like',
+        })
+
+        const entry = entries.value.find((candidate) => candidate.post?.id === postId)
+        const responseData = (response as { data?: { added?: boolean } })?.data
+        const added = responseData?.added ?? false
+        if (entry?.post) {
+          const wasReacted = entry.post.user_has_reacted
+          entry.post.user_has_reacted = added
+
+          if (added && !wasReacted) {
+            entry.post.reactions_count = (entry.post.reactions_count || 0) + 1
+          } else if (!added && wasReacted) {
+            entry.post.reactions_count = Math.max(0, (entry.post.reactions_count || 0) - 1)
+          }
+        }
+
+        return response as { data: { added: boolean } }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to toggle reaction:', err)
+        throw err
+      }
+    }
+
+    const shouldFallback = (requestError: unknown): boolean => {
+      const status = (requestError as { response?: { status?: number } }).response?.status
+      return status === 404 || status === 405 || status === 410
+    }
+
+    async function loadComments(postId: string, cursor?: string): Promise<{ data: Comment[] }> {
+      try {
+        const params = new URLSearchParams()
+        if (cursor) {
+          params.set('after', cursor)
+        }
+        const query = params.toString()
+
+        const primaryUrl = query === ''
+          ? `/v1/content/posts/${postId}/comments`
+          : `/v1/content/posts/${postId}/comments?${query}`
+        const legacyUrl = query === ''
+          ? `/v1/posts/${postId}/comments`
+          : `/v1/posts/${postId}/comments?${query}`
+
+        let response
+        try {
+          response = await client.get(primaryUrl)
+        } catch (requestError) {
+          if (shouldFallback(requestError)) {
+            response = await client.get(legacyUrl)
+          } else {
+            throw requestError
+          }
+        }
+
+        return response as { data: Comment[] }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to load comments:', err)
+        return { data: [] }
+      }
+    }
+
+    async function addComment(postId: string, input: { body: string }): Promise<{ data: Comment }> {
+      try {
+        const response = await client.post('/v1/comments', {
+          ...input,
+          post_id: postId,
+        })
+
+        const entry = entries.value.find((candidate) => candidate.post?.id === postId)
+        if (entry?.post) {
+          entry.post.comments_count = (entry.post.comments_count || 0) + 1
+        }
+
+        return response as { data: Comment }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to add comment:', err)
+        throw err
+      }
+    }
+
+    async function loadScheduledPosts(cursor?: string): Promise<ScheduledPostsPage> {
+      try {
+        const params = new URLSearchParams()
+        if (cursor) {
+          params.set('cursor', cursor)
+        }
+
+        const query = params.toString()
+        const url = query === '' ? '/v1/schedule/mine' : `/v1/schedule/mine?${query}`
+        const response = await client.get(url)
+        const responseData = response as {
+          data?: {
+            items?: ScheduledPostsPage['data']
+            next_cursor?: string | null
+          }
+        }
+
+        return {
+          data: responseData.data?.items ?? [],
+          meta: {
+            next_cursor: responseData.data?.next_cursor ?? null,
+          },
+        }
+      } catch (err) {
+        logger.error('[ContentStore] Failed to load scheduled posts:', err)
+        throw err
+      }
+    }
+
+    async function cancelScheduledPost(id: string): Promise<void> {
+      try {
+        await client.delete(`/v1/schedule/${id}`)
+      } catch (err) {
+        logger.error('[ContentStore] Failed to cancel scheduled post:', err)
+        throw err
+      }
+    }
+
+    function resetForLogout(): void {
+      entries.value = []
+      nextCursor.value = null
+      loading.value = false
+      error.value = null
+      feedMode.value = 'for_you'
+      pendingPosts.value = []
+      recentCreatedPosts.value = []
+      composerFeeling.value = null
+
+      if (storage === null) {
+        return
+      }
+
+      try {
+        storage.removeItem(PENDING_POSTS_STORAGE_KEY)
+      } catch (storageError) {
+        logger.warn('[ContentStore] Failed to clear pending posts on logout', storageError)
+      }
+
+      try {
+        storage.removeItem(RECENT_CREATED_POSTS_STORAGE_KEY)
+      } catch (storageError) {
+        logger.warn('[ContentStore] Failed to clear recent created posts on logout', storageError)
+      }
+    }
+
+    function updatePostMediaProcessingStatus(input: {
+      postId: string
+      sourceMediaUuid: string
+      status: 'ready' | 'failed'
+      outputMediaId?: string | null
+      playbackUrl?: string | null
+      thumbnailUrl?: string | null
+      errorMessage?: string | null
+    }): void {
+      const entry = entries.value.find((candidate) => candidate.entity_id === input.postId || candidate.post?.id === input.postId)
+      if (!entry?.post?.media || !Array.isArray(entry.post.media)) {
+        return
+      }
+
+      const mediaIndex = entry.post.media.findIndex((media) => (
+        media.id === input.sourceMediaUuid
+        || media.uuid === input.sourceMediaUuid
+        || media.source_media_id === input.sourceMediaUuid
+      ))
+      if (mediaIndex === -1) {
+        return
+      }
+
+      const mediaItem = entry.post.media[mediaIndex]
+      if (!mediaItem) {
+        return
+      }
+
+      const updatedMedia: PostMedia = { ...mediaItem }
+      if (input.status === 'ready') {
+        if (input.outputMediaId) {
+          updatedMedia.id = input.outputMediaId
+          updatedMedia.uuid = input.outputMediaId
+          updatedMedia.output_media_id = input.outputMediaId
+        }
+        if (input.playbackUrl) {
+          updatedMedia.playback_url = input.playbackUrl
+        }
+        if (input.thumbnailUrl) {
+          updatedMedia.thumbnail_url = input.thumbnailUrl
+        }
+        updatedMedia.processing_status = 'ready'
+        updatedMedia.video_render_status = 'ready'
+        updatedMedia.video_render_progress = 100
+        updatedMedia.video_render_error = null
+      } else {
+        updatedMedia.processing_status = 'failed'
+        updatedMedia.video_render_status = 'failed'
+        updatedMedia.video_render_error = input.errorMessage ?? 'Video rendering failed.'
+      }
+
+      const newMedia = [...entry.post.media]
+      newMedia[mediaIndex] = updatedMedia
+      entry.post.media = newMedia
+    }
+
+    if (storage !== null) {
+      restoreRecentCreatedPosts()
+      restorePendingPosts()
+    }
+
+    return {
+      entries,
+      nextCursor,
+      loading,
+      error,
+      pendingPosts,
+      composerFeeling,
+      feedMode,
+
+      hasPendingPosts,
+      PAGE_SIZE,
+
+      loadFeed,
+      loadUserPosts,
+      loadMore,
+      setFeedMode,
+
+      createPost,
+      updatePost,
+      deletePost,
+
+      loadScheduledPosts,
+      cancelScheduledPost,
+
+      enqueuePost,
+      processPendingPost,
+      retryPendingPost,
+      cancelPendingPost,
+      claimLostMediaDraft,
+      setComposerFeeling,
+      claimComposerFeeling,
+      restorePendingPosts,
+      resetForLogout,
+      updatePostMediaProcessingStatus,
+
+      toggleReaction,
+      loadComments,
+      addComment,
+    }
+  })
+}