@fabriktor/fx 0.0.151 → 0.0.153

package/dist/src/feed/feed.js

@@ -3,19 +3,24 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
-import { All, ColStorageFeed, PullTypeKeepAlive, ZeroID, } from "@fabriktor/schema";
-import { errResolveFailed, errValidation } from "../core/err.js";
+import { All, PullTypeBatch, PullTypeSingle, PullTypeResearch, PullTypeReplies, PullTypeReferences, PullTypeReactions, PullTypeProfilePosts, PullTypeProfileReplies, PullTypeProfileMedias, FeedLike, FeedDislike, FeedReport, PullTypeKeepAlive, ZeroID, } from "@fabriktor/schema";
+import { isClientErr, queryParams, } from "@fabriktor/client";
+import { errResolveFailed, errValidation, errUnconfirmedMutation, } from "../core/err.js";
 import { requiredOperationID, resolvedID } from "../core/id.js";
-import { newPullSession, } from "../core/pull.js";
-import { runSearch, } from "../core/search.js";
-import { StorageUploadModeration, } from "../storage/storage.js";
+import { startPullSession, PullSessionScope, } from "../core/pull.js";
+import { runOwnerSearch, } from "../core/search.js";
+import { validateStorageUploadFiles, } from "../storage/storage.js";
+import { createEvent, EventBus } from "../core/events.js";
+import { prepareFeedTextPost, validateFeedVisibility, feedPostInput, } from "./validation.js";
+export * from "./validation.js";
+export * from "./media.js";
+import { saveFeedPost, newFeedPostSaveState, } from "./media.js";
+export const FeedEvents = { Changed: createEvent() };
 const newFeedSessionToken = "";
 const resourceFeedSessionToken = "feed_session_token";
-const resourceFeedPostID = "feed_post_id";
 const resourceFeedPost = "feed_post";
 const resourceFeedReaction = "feed_reaction";
 const resourceFeedFavorite = "feed_favorite";
-const resourceFeedObject = "feed_object";
 const msgKeepAliveIntervalInvalid = "Keep-alive interval must be a finite number greater than zero.";
 const msgFeedSessionClosed = "Feed session is closed.";
 const msgFeedPullInProgress = "A feed pull is already in progress.";
@@ -36,10 +41,6 @@ const msgFeedReplyAlreadyExists = "A reply already exists for this post.";
 const msgFeedReplyMissing = "No reply exists for this post.";
 const msgFeedReferenceAlreadyExists = "A reference already exists for this post.";
 const msgFeedReferenceMissing = "No reference exists for this post.";
-const msgFeedObjectsMissing = "Storage download did not return any feed objects.";
-const msgFeedObjectURLMissing = "Storage object does not contain a public URL.";
-const msgFeedObjectMIMEMissing = "Storage object does not contain a MIME prefix.";
-const msgFeedObjectCaptionMissing = "Storage object does not contain a caption embedding.";
 export const FeedAction = {
     Reaction: "reaction",
     Favorite: "favorite",
@@ -56,6 +57,9 @@ export const FeedMediaPostStatus = {
     PatchFailed: "patch_failed",
 };
 export class FeedFX {
+    sessions = new PullSessionScope();
+    events;
+    mutating = false;
     feed;
     storage_fx;
     keep_alive_interval_ms;
@@ -66,6 +70,7 @@ export class FeedFX {
     constructor(opts) {
         validateFeedFXOptions(opts);
         this.feed = opts.feed;
+        this.events = opts.events ?? new EventBus();
         this.storage_fx = opts.storage_fx;
         this.keep_alive_interval_ms = opts.keep_alive_interval_ms;
         this.running_actions = new Map();
@@ -73,24 +78,231 @@ export class FeedFX {
         this.removed_actions = new Map();
         this.action_ids = new Map();
     }
+    reset() {
+        this.sessions.reset();
+        this.running_actions.clear();
+        this.completed_actions.clear();
+        this.removed_actions.clear();
+        this.action_ids.clear();
+    }
     async createFeedPost(opts) {
-        const out = await this.feed.insertOneFeedPost(opts);
-        const id = requiredOperationID(out, msgFeedCreatedPostIDMissing);
-        return await this.findFeedPost(id);
+        return this.mutate(async (signal) => {
+            let id = resolvedID(opts.created_id);
+            if (!id) {
+                const input = prepareFeedTextPost(opts.in);
+                const parent_id = resolvedID(input.reply_to_post_id) ??
+                    resolvedID(input.referenced_post_id);
+                if (parent_id) {
+                    const parent = await this.requireFeedPost(parent_id, signal);
+                    const existing = resolvedID(input.reply_to_post_id)
+                        ? parent.self.reply_id
+                        : parent.self.reference_id;
+                    // A previous uncertain attempt may already have created the only child.
+                    if (resolvedID(existing)) {
+                        const child = await this.findFeedPost(existing, signal);
+                        if (child.text.text !== input.text.text ||
+                            child.visibility !== input.visibility ||
+                            child.reply_to_post_id !== input.reply_to_post_id ||
+                            child.referenced_post_id !== input.referenced_post_id ||
+                            child.has_media ||
+                            child.is_uploading ||
+                            child.objects.length)
+                            throw errValidation({
+                                field: "text",
+                                msg: "A reply or reference already exists.",
+                            });
+                        id = existing;
+                        opts.on_created?.(id);
+                    }
+                }
+                if (!id) {
+                    if (opts.attempted)
+                        throw errUnconfirmedMutation();
+                    opts.before_request?.();
+                    let out;
+                    try {
+                        out = await this.feed.insertOneFeedPost({
+                            in: input,
+                            signal,
+                            idempotency_key: opts.idempotency_key,
+                        });
+                    }
+                    catch (error) {
+                        if (isClientErr(error) &&
+                            (error.status === 400 || error.status === 422))
+                            opts.on_rejected?.();
+                        throw error;
+                    }
+                    id = requiredOperationID(out, msgFeedCreatedPostIDMissing);
+                    opts.on_created?.(id);
+                }
+            }
+            signal.throwIfAborted();
+            const post = await this.requireFeedPost(id, signal);
+            this.changed(post.id);
+            if (resolvedID(post.reply_to_post_id))
+                this.changed(post.reply_to_post_id);
+            if (resolvedID(post.referenced_post_id))
+                this.changed(post.referenced_post_id);
+            return post;
+        }, opts.signal);
     }
     async replaceFeedPost(opts) {
-        await this.feed.replaceOneFeedPost(opts);
-        return await this.findFeedPost(opts.id);
+        return this.mutate(async (signal) => {
+            const current = await this.findFeedPost(opts.id, signal);
+            this.checkVersion(current, opts.expected);
+            // Text editing preserves link identity and cannot overwrite stored media.
+            const input = prepareFeedTextPost({
+                ...feedPostInput(current),
+                ...opts.in,
+                reply_to_post_id: current.reply_to_post_id,
+                referenced_post_id: current.referenced_post_id,
+            });
+            await this.feed.replaceOneFeedPost({ id: opts.id, in: input, signal });
+            signal.throwIfAborted();
+            this.changed(opts.id);
+            return this.requireFeedPost(opts.id, signal);
+        }, opts.signal);
     }
     async searchFeedPosts(opts) {
-        return await runSearch({
-            search: (searchOpts) => this.feed.searchManyFeedPosts(searchOpts),
-            query: {},
-            q: opts.q,
-            page: opts.page,
-            per_page: opts.per_page,
+        return runOwnerSearch({
+            ...opts,
+            search: (input) => this.feed.searchManyFeedPosts(input),
+        });
+    }
+    async readOwnReaction(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        signal.throwIfAborted();
+        const id = requireFeedID(opts.id);
+        try {
+            const out = await this.feed.findOneFeedReaction({ id, signal });
+            signal.throwIfAborted();
+            return out.value ?? null;
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            if (isClientErr(error) && (error.status === 403 || error.status === 404))
+                return null;
+            throw error;
+        }
+    }
+    async readFeedPost(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        signal.throwIfAborted();
+        const id = requireFeedID(opts.id);
+        try {
+            const out = await this.feed.pull({
+                contact_ids: [],
+                session_token: "",
+                is_new_session: true,
+                pull_type: PullTypeSingle,
+                entity_id: id,
+                research: "",
+                signal,
+            });
+            signal.throwIfAborted();
+            return out.value?.posts.find((post) => post.id === id) ?? null;
+        }
+        catch (error) {
+            signal.throwIfAborted();
+            if (isClientErr(error) && (error.status === 403 || error.status === 404))
+                return null;
+            throw error;
+        }
+    }
+    async listSavedFeedPosts(opts) {
+        const signal = this.sessions.signal(opts.signal);
+        signal.throwIfAborted();
+        const out = await this.feed.queryFeedFavorites({
+            query: queryParams({
+                owner_id: requireFeedID(opts.owner_id),
+            }),
+            signal,
+        });
+        signal.throwIfAborted();
+        const result = [];
+        // This backend collection exposes an unpaged query, not a search route.
+        for (const favorite of out.value ?? []) {
+            const post = await this.readFeedPost({ id: favorite.post_id, signal });
+            signal.throwIfAborted();
+            result.push({ ...favorite, post });
+        }
+        return result;
+    }
+    async removeSavedFeedPost(opts) {
+        return this.mutate(async (signal) => {
+            const out = await this.feed.findOneFeedFavorite({
+                id: requireFeedID(opts.id),
+                signal,
+            });
+            signal.throwIfAborted();
+            if (!out.value || out.value.owner_id !== requireFeedID(opts.owner_id))
+                throw errValidation({ msg: "Favorite is unavailable." });
+            await this.feed.deleteOneFeedFavorite({ id: opts.id, signal });
+            signal.throwIfAborted();
+            this.changed(out.value.post_id);
+        });
+    }
+    async deleteFeedPost(opts) {
+        return this.mutate(async (signal) => {
+            const current = await this.findFeedPost(requireFeedID(opts.record.id), signal);
+            this.checkVersion(current, {
+                ...opts.record,
+                owner_id: requireFeedID(opts.owner_id),
+            });
+            await this.feed.deleteOneFeedPost({ id: current.id, signal });
+            signal.throwIfAborted();
+            this.changed(current.id);
+            if (resolvedID(current.reply_to_post_id))
+                this.changed(current.reply_to_post_id);
+            if (resolvedID(current.referenced_post_id))
+                this.changed(current.referenced_post_id);
         });
     }
+    async restrictFeed(opts) {
+        validateFeedVisibility(opts.new_visibility);
+        return this.mutate(async (signal) => {
+            await this.feed.restrict({ ...opts, signal });
+            signal.throwIfAborted();
+            this.changed("");
+        });
+    }
+    checkVersion(current, expected) {
+        if (expected &&
+            (current.owner_id !== expected.owner_id ||
+                current.updated_at !== expected.updated_at))
+            throw errValidation({
+                field: "updated_at",
+                msg: "Reload the post before changing it.",
+            });
+    }
+    async requireFeedPost(id, signal) {
+        const post = await this.readFeedPost({ id, signal });
+        if (!post)
+            throw errResolveFailed({
+                resource: resourceFeedPost,
+                msg: msgFeedPostMissing,
+            });
+        return post;
+    }
+    changed(post_id) {
+        this.events.publish(FeedEvents.Changed, { post_id });
+    }
+    async mutate(fn, parent) {
+        if (this.mutating)
+            throw errValidation({ msg: msgFeedActionInProgress });
+        const signal = this.sessions.signal(parent);
+        signal.throwIfAborted();
+        this.mutating = true;
+        try {
+            const result = await fn(signal);
+            signal.throwIfAborted();
+            return result;
+        }
+        finally {
+            this.mutating = false;
+        }
+    }
     async createFeedReaction(opts) {
         const out = await this.feed.insertOneFeedReaction(opts);
         const id = requiredOperationID(out, msgCreatedFeedReactionIDMissing);
@@ -110,28 +322,54 @@ export class FeedFX {
         return await this.findFeedFavorite(opts.id);
     }
     async startSession(opts) {
-        const { on_error, ...context } = opts;
-        const initial = await this.feed.pull({
-            ...context,
-            session_token: newFeedSessionToken,
-            is_new_session: true,
-        });
-        const session_token = feedSessionToken(initial);
-        return newPullSession({
-            initial,
-            session_token,
+        const { on_error, signal: parentSignal, ...input } = opts;
+        const supported = [
+            PullTypeBatch,
+            PullTypeResearch,
+            PullTypeReactions,
+            PullTypeReferences,
+            PullTypeReplies,
+            PullTypeProfilePosts,
+            PullTypeProfileReplies,
+            PullTypeProfileMedias,
+        ];
+        if (!supported.includes(input.pull_type))
+            throw errValidation({
+                field: "pull_type",
+                msg: "Unsupported Feed session.",
+            });
+        if (input.pull_type === PullTypeResearch && !input.research.trim())
+            throw errValidation({ field: "research", msg: "Research is required." });
+        if (![PullTypeBatch, PullTypeResearch].includes(input.pull_type))
+            requireFeedID(input.entity_id);
+        const context = {
+            ...input,
+            research: input.research.trim(),
+            contact_ids: [...input.contact_ids],
+        };
+        const signal = this.sessions.signal(parentSignal);
+        return await startPullSession({
+            signal,
+            pull_initial: (signal) => this.feed.pull({
+                ...context,
+                session_token: newFeedSessionToken,
+                is_new_session: true,
+                signal,
+            }),
             keep_alive_interval_ms: this.keep_alive_interval_ms,
-            pull_next: async (token) => {
+            pull_next: async (token, signal) => {
                 return await this.feed.pull({
                     ...context,
                     session_token: token,
+                    signal,
                     is_new_session: false,
                 });
             },
-            keep_alive: async (token) => {
+            keep_alive: async (token, signal) => {
                 return await this.feed.pull({
                     contact_ids: [],
                     session_token: token,
+                    signal,
                     is_new_session: false,
                     pull_type: PullTypeKeepAlive,
                     entity_id: "",
@@ -150,85 +388,90 @@ export class FeedFX {
     }
     async addReaction(opts) {
         const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Reaction)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReactionAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reaction, async () => {
+        return await this.runAction(post_id, FeedAction.Reaction, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            if (resolvedID(fresh.self.reaction_id))
+                throw errValidation({
+                    msg: "An action already exists for this post.",
+                });
+            if (![FeedLike, FeedDislike, FeedReport].includes(opts.reaction_type))
+                throw errValidation({
+                    field: "reaction_type",
+                    msg: "Unsupported reaction.",
+                });
             const out = await this.feed.insertOneFeedReaction({
+                signal,
                 in: {
                     post_id,
                     reaction_type: opts.reaction_type,
                 },
             });
+            signal.throwIfAborted();
             this.markAction(post_id, FeedAction.Reaction, operationID(out));
             return out;
         });
     }
     async removeReaction(opts) {
         const post_id = feedPostID(opts.post);
-        const id = this.actionID(opts.post, FeedAction.Reaction);
-        if (id === undefined) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReactionMissing,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reaction, async () => {
+        return await this.runAction(post_id, FeedAction.Reaction, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            const id = resolvedID(fresh.self.reaction_id);
+            if (!id)
+                throw errValidation({ msg: "This action is no longer present." });
             const out = await this.feed.deleteOneFeedReaction({
+                signal,
                 id,
             });
+            signal.throwIfAborted();
             this.markActionRemoved(post_id, FeedAction.Reaction);
             return out;
         });
     }
     async addFavorite(opts) {
         const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Favorite)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedFavoriteAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Favorite, async () => {
+        return await this.runAction(post_id, FeedAction.Favorite, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            if (resolvedID(fresh.self.favorite_id))
+                throw errValidation({
+                    msg: "An action already exists for this post.",
+                });
             const out = await this.feed.insertOneFeedFavorite({
+                signal,
                 in: {
                     post_id,
                 },
             });
+            signal.throwIfAborted();
             this.markAction(post_id, FeedAction.Favorite, operationID(out));
             return out;
         });
     }
     async removeFavorite(opts) {
         const post_id = feedPostID(opts.post);
-        const id = this.actionID(opts.post, FeedAction.Favorite);
-        if (id === undefined) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedFavoriteMissing,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Favorite, async () => {
+        return await this.runAction(post_id, FeedAction.Favorite, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            const id = resolvedID(fresh.self.favorite_id);
+            if (!id)
+                throw errValidation({ msg: "This action is no longer present." });
             const out = await this.feed.deleteOneFeedFavorite({
+                signal,
                 id,
             });
+            signal.throwIfAborted();
             this.markActionRemoved(post_id, FeedAction.Favorite);
             return out;
         });
     }
     async createReply(opts) {
         const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Reply)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReplyAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reply, async () => {
+        return await this.runAction(post_id, FeedAction.Reply, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            if (resolvedID(fresh.self.reply_id))
+                throw errValidation({ msg: "An action already exists for this post." });
+            if (!opts.in.text.text.trim())
+                throw errValidation({ field: "text", msg: "Reply text is required." });
             const out = await this.feed.insertOneFeedPost({
+                signal,
                 in: {
                     objects: [],
                     text: opts.in.text,
@@ -239,37 +482,37 @@ export class FeedFX {
                     reply_to_post_id: post_id,
                 },
             });
+            signal.throwIfAborted();
             this.markAction(post_id, FeedAction.Reply, operationID(out));
             return out;
         });
     }
     async removeReply(opts) {
         const post_id = feedPostID(opts.post);
-        const id = this.actionID(opts.post, FeedAction.Reply);
-        if (id === undefined) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReplyMissing,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reply, async () => {
+        return await this.runAction(post_id, FeedAction.Reply, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            const id = resolvedID(fresh.self.reply_id);
+            if (!id)
+                throw errValidation({ msg: "This action is no longer present." });
             const out = await this.feed.deleteOneFeedPost({
+                signal,
                 id,
             });
+            signal.throwIfAborted();
             this.markActionRemoved(post_id, FeedAction.Reply);
             return out;
         });
     }
     async createReference(opts) {
         const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Reference)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReferenceAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reference, async () => {
+        return await this.runAction(post_id, FeedAction.Reference, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            if (resolvedID(fresh.self.reference_id))
+                throw errValidation({
+                    msg: "An action already exists for this post.",
+                });
             const out = await this.feed.insertOneFeedPost({
+                signal,
                 in: {
                     objects: [],
                     text: opts.in.text,
@@ -280,208 +523,151 @@ export class FeedFX {
                     reply_to_post_id: ZeroID,
                 },
             });
+            signal.throwIfAborted();
             this.markAction(post_id, FeedAction.Reference, operationID(out));
             return out;
         });
     }
     async removeReference(opts) {
         const post_id = feedPostID(opts.post);
-        const id = this.actionID(opts.post, FeedAction.Reference);
-        if (id === undefined) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReferenceMissing,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reference, async () => {
+        return await this.runAction(post_id, FeedAction.Reference, async (signal) => {
+            const fresh = await this.requireFeedPost(post_id, signal);
+            const id = resolvedID(fresh.self.reference_id);
+            if (!id)
+                throw errValidation({ msg: "This action is no longer present." });
             const out = await this.feed.deleteOneFeedPost({
+                signal,
                 id,
             });
+            signal.throwIfAborted();
             this.markActionRemoved(post_id, FeedAction.Reference);
             return out;
         });
     }
+    async saveFeedPost(opts) {
+        return this.mutate((signal) => saveFeedPost({
+            feed: this.feed,
+            storage: this.storage_fx,
+            read: (id, signal) => this.requireFeedPost(id, signal),
+            changed: (id) => this.changed(id),
+        }, { ...opts, signal }), opts.signal);
+    }
     async createPostWithMedia(opts) {
-        return await this.createMediaPost({
+        return this.createMediaPost({
+            ...opts,
             in: {
+                ...opts.in,
                 objects: [],
-                text: opts.in.text,
-                is_uploading: true,
                 has_media: true,
-                visibility: opts.in.visibility,
-                referenced_post_id: ZeroID,
+                is_uploading: true,
                 reply_to_post_id: ZeroID,
+                referenced_post_id: ZeroID,
             },
-            user_id: opts.user_id,
-            uploader_id: opts.uploader_id,
-            full_quality: opts.full_quality,
-            files: opts.files,
-            save_to_personal_box: opts.save_to_personal_box,
         });
     }
     async createReplyWithMedia(opts) {
-        const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Reply)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReplyAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reply, async () => {
-            const out = await this.createMediaPost({
-                in: {
-                    objects: [],
-                    text: opts.in.text,
-                    is_uploading: true,
-                    has_media: true,
-                    visibility: All,
-                    referenced_post_id: ZeroID,
-                    reply_to_post_id: post_id,
-                },
-                user_id: opts.user_id,
-                uploader_id: opts.uploader_id,
-                full_quality: opts.full_quality,
-                files: opts.files,
-                save_to_personal_box: opts.save_to_personal_box,
-            });
-            const id = completedMediaPostID(out);
-            if (id !== undefined) {
-                this.markAction(post_id, FeedAction.Reply, id);
-            }
-            return out;
+        return this.createMediaPost({
+            ...opts,
+            in: {
+                ...opts.in,
+                visibility: All,
+                objects: [],
+                has_media: true,
+                is_uploading: true,
+                reply_to_post_id: feedPostID(opts.post),
+                referenced_post_id: ZeroID,
+            },
         });
     }
     async createReferenceWithMedia(opts) {
-        const post_id = feedPostID(opts.post);
-        if (this.hasAction(opts.post, FeedAction.Reference)) {
-            throw errValidation({
-                field: "post",
-                msg: msgFeedReferenceAlreadyExists,
-            });
-        }
-        return await this.runAction(post_id, FeedAction.Reference, async () => {
-            const out = await this.createMediaPost({
-                in: {
-                    objects: [],
-                    text: opts.in.text,
-                    is_uploading: true,
-                    has_media: true,
-                    visibility: All,
-                    referenced_post_id: post_id,
-                    reply_to_post_id: ZeroID,
-                },
-                user_id: opts.user_id,
-                uploader_id: opts.uploader_id,
-                full_quality: opts.full_quality,
-                files: opts.files,
-                save_to_personal_box: opts.save_to_personal_box,
-            });
-            const id = completedMediaPostID(out);
-            if (id !== undefined) {
-                this.markAction(post_id, FeedAction.Reference, id);
-            }
-            return out;
+        return this.createMediaPost({
+            ...opts,
+            in: {
+                ...opts.in,
+                visibility: All,
+                objects: [],
+                has_media: true,
+                is_uploading: true,
+                reply_to_post_id: ZeroID,
+                referenced_post_id: feedPostID(opts.post),
+            },
         });
     }
     async createMediaPost(opts) {
-        const create = await this.feed.insertOneFeedPost({
-            in: opts.in,
-        });
-        const post_id = operationID(create);
-        if (post_id === undefined) {
-            return {
-                status: FeedMediaPostStatus.CreateUnresolved,
-                create,
-                error: errResolveFailed({
-                    resource: resourceFeedPostID,
-                    msg: msgFeedCreatedPostIDMissing,
-                }),
-            };
-        }
-        let upload;
-        try {
-            upload = await this.storage_fx.uploadObjectsWithPersonalBox({
-                col: ColStorageFeed,
-                owner_id: post_id,
-                user_id: opts.user_id,
-                uploader_id: opts.uploader_id,
-                full_quality: opts.full_quality,
-                public_url: true,
-                files: opts.files,
-                save_to_personal_box: opts.save_to_personal_box,
-            });
-        }
-        catch (err) {
-            return {
-                status: FeedMediaPostStatus.UploadFailed,
-                post_id,
-                error: err,
-            };
-        }
-        if (upload.primary.moderation === StorageUploadModeration.AllForbidden) {
-            return {
-                status: FeedMediaPostStatus.AllForbidden,
-                post_id,
-                upload,
-            };
-        }
-        let stored;
+        validateStorageUploadFiles(opts.files);
+        const state = opts.state ?? newFeedPostSaveState();
+        const progress = { stage: "create" };
         try {
-            stored = await this.storage_fx.downloadObjects({
-                col: ColStorageFeed,
-                owner_id: post_id,
+            const result = await this.saveFeedPost({
+                ...opts,
+                state,
+                owner_id: opts.user_id ?? opts.uploader_id,
+                signal: this.sessions.signal(opts.signal),
+                idempotency_key: opts.idempotency_key ?? state.create_key,
+                on_stage: (value) => {
+                    progress.stage = value;
+                },
+                draft: {
+                    in: opts.in,
+                    retained_urls: [],
+                    files: opts.files,
+                    full_quality: opts.full_quality ?? false,
+                    save_to_personal_box: opts.save_to_personal_box ?? false,
+                },
             });
-        }
-        catch (err) {
-            return {
-                status: FeedMediaPostStatus.DownloadFailed,
-                post_id,
-                upload,
-                error: err,
-            };
-        }
-        let objects;
-        try {
-            objects = feedObjects(stored.value ?? []);
-        }
-        catch (err) {
+            if (!state.post_id || !result.upload)
+                throw errResolveFailed({
+                    resource: resourceFeedPost,
+                    msg: msgFeedPostMissing,
+                });
+            if (!result.post)
+                return {
+                    status: FeedMediaPostStatus.AllForbidden,
+                    post_id: state.post_id,
+                    upload: result.upload,
+                };
             return {
-                status: FeedMediaPostStatus.ResolveFailed,
-                post_id,
-                upload,
-                error: err,
+                status: FeedMediaPostStatus.Complete,
+                post_id: result.post.id,
+                objects: result.post.objects,
+                upload: result.upload,
             };
         }
-        try {
-            await this.feed.replaceOneFeedPost({
-                id: post_id,
-                in: {
-                    ...opts.in,
-                    objects,
-                    is_uploading: false,
-                },
-            });
-        }
-        catch (err) {
+        catch (error) {
+            opts.signal?.throwIfAborted();
+            if (!state.post_id)
+                throw error;
+            if (!state.upload)
+                return {
+                    status: FeedMediaPostStatus.UploadFailed,
+                    post_id: state.post_id,
+                    error,
+                };
+            if (state.input)
+                return {
+                    status: FeedMediaPostStatus.PatchFailed,
+                    post_id: state.post_id,
+                    upload: state.upload,
+                    objects: state.input.objects,
+                    error,
+                };
             return {
-                status: FeedMediaPostStatus.PatchFailed,
-                post_id,
-                upload,
-                objects,
-                error: err,
+                status: progress.stage === "resolve"
+                    ? FeedMediaPostStatus.ResolveFailed
+                    : FeedMediaPostStatus.DownloadFailed,
+                post_id: state.post_id,
+                upload: state.upload,
+                error,
             };
         }
-        return {
-            status: FeedMediaPostStatus.Complete,
-            post_id,
-            upload,
-            objects,
-        };
     }
-    async findFeedPost(id) {
+    async findFeedPost(id, signal) {
+        signal?.throwIfAborted();
         const out = await this.feed.findOneFeedPost({
             id,
+            signal,
         });
+        signal?.throwIfAborted();
         const post = out.value;
         if (post === undefined) {
             throw errResolveFailed({
@@ -518,18 +704,19 @@ export class FeedFX {
         return favorite;
     }
     async runAction(post_id, action, fn) {
-        if (this.isActionRunning(post_id, action)) {
-            throw errValidation({
-                msg: msgFeedActionInProgress,
-            });
-        }
-        this.setActionRunning(post_id, action, true);
-        try {
-            return await fn();
-        }
-        finally {
-            this.setActionRunning(post_id, action, false);
-        }
+        return this.mutate(async (signal) => {
+            this.setActionRunning(post_id, action, true);
+            try {
+                const result = await fn(signal);
+                signal.throwIfAborted();
+                this.changed(post_id);
+                return result;
+            }
+            finally {
+                if (!signal.aborted)
+                    this.setActionRunning(post_id, action, false);
+            }
+        });
     }
     hasAction(post, action) {
         const post_id = feedPostID(post);
@@ -674,47 +861,12 @@ function resolvedValue(v) {
     }
     return out;
 }
-function completedMediaPostID(out) {
-    if (out.status !== FeedMediaPostStatus.Complete) {
-        return undefined;
-    }
-    return out.post_id;
-}
-function feedObjects(objects) {
-    if (objects.length === 0) {
-        throw errResolveFailed({
-            resource: resourceFeedObject,
-            msg: msgFeedObjectsMissing,
-        });
-    }
-    const out = [];
-    for (const object of objects) {
-        const public_url = resolvedValue(object.public_url);
-        if (public_url === undefined) {
-            throw errResolveFailed({
-                resource: resourceFeedObject,
-                msg: msgFeedObjectURLMissing,
-            });
-        }
-        const mime_prefix = resolvedValue(object.mime_prefix);
-        if (mime_prefix === undefined) {
-            throw errResolveFailed({
-                resource: resourceFeedObject,
-                msg: msgFeedObjectMIMEMissing,
-            });
-        }
-        const embedding = object.caption;
-        if (embedding === undefined) {
-            throw errResolveFailed({
-                resource: resourceFeedObject,
-                msg: msgFeedObjectCaptionMissing,
-            });
-        }
-        out.push({
-            public_url,
-            mime_prefix,
-            embedding,
+function requireFeedID(value) {
+    const id = resolvedID(value);
+    if (!id)
+        throw errValidation({
+            field: "id",
+            msg: "A Feed record or owner ID is required.",
         });
-    }
-    return out;
+    return id;
 }