@codingfactory/socialkit-vue 0.5.2 → 0.6.0

package/dist/stores/content.js

@@ -0,0 +1,1195 @@
+/**
+ * Generic content/feed store factory for SocialKit-powered frontends.
+ */
+import { isAxiosError } from 'axios';
+import { defineStore } from 'pinia';
+import { computed, ref } from 'vue';
+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) {
+    const parsed = Number(pageSize ?? 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return 10;
+    }
+    return Math.trunc(parsed);
+}
+export function createContentStoreDefinition(config) {
+    const { client, mediaUploadService, getCurrentUser, syncActiveRecipe, storage = null, pageSize, logger = console, storeId = 'content', } = config;
+    const resolvedPageSize = normalizePageSize(pageSize);
+    return defineStore(storeId, () => {
+        const entries = ref([]);
+        const nextCursor = ref(null);
+        const loading = ref(false);
+        const error = ref(null);
+        const feedMode = ref('for_you');
+        let feedRequestSequence = 0;
+        let latestFreshFeedRequestToken = 0;
+        let activeFeedRequests = 0;
+        const inFlightFeedRequests = new Map();
+        const pendingPosts = ref([]);
+        const recentCreatedPosts = ref([]);
+        const composerFeeling = ref(null);
+        const hasPendingPosts = computed(() => pendingPosts.value.length > 0);
+        const PAGE_SIZE = resolvedPageSize;
+        const isPostEntryType = (type) => {
+            if (!type) {
+                return false;
+            }
+            const normalized = type.toLowerCase();
+            return normalized === 'post'
+                || normalized.endsWith('\\post')
+                || normalized.endsWith('.post')
+                || normalized.includes('content.post');
+        };
+        const entryKey = (entry) => `${(entry.entity_type || '').toLowerCase()}|${entry.entity_id}`;
+        const feedRequestKey = (mode, cursor) => `${mode}|${cursor ?? '__fresh__'}`;
+        const removeDuplicateEntriesForKey = (keepIndex) => {
+            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 = {
+            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) => {
+            const lower = errorMessage.toLowerCase();
+            for (const known of DISCIPLINE_ERROR_STRINGS) {
+                if (lower === known.toLowerCase()) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const isLegacyClientRetryableError = (errorMessage) => {
+            const lower = errorMessage.toLowerCase();
+            return LEGACY_CLIENT_RETRYABLE_ERROR_FRAGMENTS.some((fragment) => lower.includes(fragment.toLowerCase()));
+        };
+        const isDisciplineAxiosError = (err) => {
+            const status = err.response?.status;
+            if (status === 423) {
+                return true;
+            }
+            const code = err.response?.data?.code;
+            return typeof code === 'string' && DISCIPLINE_ERROR_CODES.has(code);
+        };
+        const resolvePendingPostErrorMessage = (err) => {
+            const responseData = err.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) => (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) {
+            if (feedMode.value === mode) {
+                return;
+            }
+            feedMode.value = mode;
+            entries.value = [];
+            nextCursor.value = null;
+        }
+        function generateTempId() {
+            return `pending-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+        }
+        function persistPendingPosts() {
+            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) => {
+            if (!Array.isArray(stored)) {
+                return [];
+            }
+            const normalized = [];
+            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,
+                    rememberedAt: rememberedAtRaw,
+                });
+            }
+            return normalized;
+        };
+        const isRecentCreatedPostExpired = (rememberedAt) => {
+            const rememberedAtMs = Date.parse(rememberedAt);
+            if (!Number.isFinite(rememberedAtMs)) {
+                return true;
+            }
+            return Date.now() - rememberedAtMs > MAX_RECENT_CREATED_POST_AGE_MS;
+        };
+        const isRecentCreatedPostOwnedByCurrentActor = (post) => {
+            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 = () => {
+            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() {
+            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() {
+            if (storage === null) {
+                return;
+            }
+            try {
+                const stored = storage.getItem(RECENT_CREATED_POSTS_STORAGE_KEY);
+                if (!stored) {
+                    recentCreatedPosts.value = [];
+                    return;
+                }
+                const parsed = JSON.parse(stored);
+                recentCreatedPosts.value = normalizeStoredRecentCreatedPosts(parsed);
+                pruneRecentCreatedPosts();
+            }
+            catch (storageError) {
+                logger.error('[ContentStore] Failed to restore recent created posts:', storageError);
+                recentCreatedPosts.value = [];
+            }
+        }
+        function rememberRecentCreatedPost(post) {
+            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) => {
+            pruneRecentCreatedPosts();
+            if (recentCreatedPosts.value.length === 0) {
+                return [];
+            }
+            const remainingRecentPosts = [];
+            const recentEntries = [];
+            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 () => {
+            pruneRecentCreatedPosts();
+            if (recentCreatedPosts.value.length === 0) {
+                return;
+            }
+            const refreshedRecentPosts = await Promise.all(recentCreatedPosts.value.map(async (entry) => {
+                const postId = typeof entry.post.id === 'string' ? entry.post.id.trim() : '';
+                if (postId === '') {
+                    return null;
+                }
+                try {
+                    const response = await client.get(`/v1/content/posts/${postId}`);
+                    const refreshedPost = response.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 !== 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() {
+            if (storage === null) {
+                return;
+            }
+            try {
+                const stored = storage.getItem(PENDING_POSTS_STORAGE_KEY);
+                if (!stored) {
+                    return;
+                }
+                const parsed = JSON.parse(stored);
+                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 = [];
+                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', 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',
+                            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) {
+            const currentUser = getCurrentUser();
+            const optimisticAuthor = {
+                id: currentUser?.id ?? '',
+                name: currentUser?.name ?? '',
+                username: currentUser?.handle ?? currentUser?.name ?? '',
+            };
+            if (currentUser?.avatar) {
+                optimisticAuthor.avatar = currentUser.avatar;
+            }
+            const optimisticPost = {
+                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,
+                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 = {
+                id: `entry-${pending.tempId}`,
+                entity_id: pending.tempId,
+                entity_type: 'post',
+                created_at: pending.createdAt,
+                post: optimisticPost,
+            };
+            entries.value.unshift(entry);
+        }
+        function enqueuePost(input) {
+            const hasUnuploadedMedia = input.mediaItems != null && input.mediaItems.length > 0;
+            const pending = {
+                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) {
+            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 = 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 = response?.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 = 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) {
+            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) {
+            pendingPosts.value = pendingPosts.value.filter((pending) => pending.tempId !== tempId);
+            persistPendingPosts();
+            entries.value = entries.value.filter((entry) => entry.post?._tempId !== tempId);
+        }
+        function claimLostMediaDraft() {
+            const recoverablePending = pendingPosts.value.find((pending) => (pending.status === 'failed'
+                && pending.error === LOST_MEDIA_ERROR_MESSAGE));
+            if (!recoverablePending) {
+                return null;
+            }
+            const recoveredDraft = {
+                tempId: recoverablePending.tempId,
+                body: recoverablePending.body,
+                visibility: recoverablePending.visibility,
+                ...(recoverablePending.content_warning && { contentWarning: recoverablePending.content_warning }),
+            };
+            cancelPendingPost(recoverablePending.tempId);
+            return recoveredDraft;
+        }
+        function setComposerFeeling(feeling) {
+            composerFeeling.value = feeling;
+        }
+        function claimComposerFeeling() {
+            const selectedFeeling = composerFeeling.value;
+            composerFeeling.value = null;
+            return selectedFeeling;
+        }
+        async function loadUserPosts(userId, cursor) {
+            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?.data) || [];
+                const cursorValue = (response?.meta?.next_cursor) || null;
+                const feedEntries = 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?.meta?.has_more) || false,
+                    nextCursor: cursorValue,
+                };
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to load user posts:', err);
+                const requestError = err;
+                error.value = requestError.response?.data?.message || 'Failed to load posts';
+                throw err;
+            }
+            finally {
+                loading.value = false;
+            }
+        }
+        async function loadFeed(cursor) {
+            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 = () => {
+                const modeChangedSinceRequest = requestedMode !== feedMode.value;
+                const supersededByNewerFreshRequest = requestToken < latestFreshFeedRequestToken;
+                const cursorLineageChanged = requestedCursor !== undefined && requestedCursor !== nextCursor.value;
+                return modeChangedSinceRequest || supersededByNewerFreshRequest || cursorLineageChanged;
+            };
+            const requestPromise = (async () => {
+                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;
+                    const serverEntriesRaw = Array.isArray(responseData?.data)
+                        ? responseData.data
+                        : responseData?.data?.entries ?? responseData?.entries ?? [];
+                    let pageEntries = 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(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;
+                    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() {
+            if (!nextCursor.value) {
+                return {
+                    data: {
+                        entries: entries.value,
+                        next_cursor: null,
+                    },
+                    page_entries: [],
+                    next_cursor: null,
+                };
+            }
+            return loadFeed(nextCursor.value);
+        }
+        async function createPost(input) {
+            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 = response?.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;
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to create post:', err);
+                const requestError = err;
+                error.value = requestError.response?.data?.message || 'Failed to create post';
+                throw err;
+            }
+            finally {
+                loading.value = false;
+            }
+        }
+        async function updatePost(postId, input) {
+            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?.data;
+                if (entry?.post && updated) {
+                    Object.assign(entry.post, updated);
+                }
+                return response;
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to update post:', err);
+                const requestError = err;
+                error.value = requestError.response?.data?.message || 'Failed to update post';
+                throw err;
+            }
+            finally {
+                loading.value = false;
+            }
+        }
+        async function deletePost(postId) {
+            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;
+                error.value = requestError.response?.data?.message || 'Failed to delete post';
+                throw err;
+            }
+            finally {
+                loading.value = false;
+            }
+        }
+        async function toggleReaction(postId, _action) {
+            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?.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;
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to toggle reaction:', err);
+                throw err;
+            }
+        }
+        const shouldFallback = (requestError) => {
+            const status = requestError.response?.status;
+            return status === 404 || status === 405 || status === 410;
+        };
+        async function loadComments(postId, cursor) {
+            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;
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to load comments:', err);
+                return { data: [] };
+            }
+        }
+        async function addComment(postId, input) {
+            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;
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to add comment:', err);
+                throw err;
+            }
+        }
+        async function loadScheduledPosts(cursor) {
+            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;
+                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) {
+            try {
+                await client.delete(`/v1/schedule/${id}`);
+            }
+            catch (err) {
+                logger.error('[ContentStore] Failed to cancel scheduled post:', err);
+                throw err;
+            }
+        }
+        function resetForLogout() {
+            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) {
+            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 = { ...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,
+        };
+    });
+}
+//# sourceMappingURL=content.js.map