@fabriktor/fx 0.0.152 → 0.0.153

package/dist/src/feed/media.d.ts

@@ -0,0 +1,53 @@
+import { type FeedOperator, type StorageUploadFile } from "@fabriktor/client";
+import { type FeedPost, type InFeedPost, type FeedObject, type Object as StorageObject } from "@fabriktor/schema";
+import type { MultiCreateAttempt } from "../core/multi-create.js";
+import { type StorageFXOperator, type StoragePersonalBoxUploadResult, type StorageUploadResult } from "../storage/storage.js";
+export type FeedPostDraft = {
+    in: InFeedPost;
+    files: StorageUploadFile[];
+    full_quality: boolean;
+    save_to_personal_box: boolean;
+    retained_urls: string[];
+};
+export type FeedSaveStage = "create" | "upload" | "resolve" | "publish" | "cleanup";
+export type FeedPostSaveResult = {
+    post: FeedPost | null;
+    upload?: StoragePersonalBoxUploadResult;
+};
+export type FeedPostSaveState = {
+    post_id?: string;
+    create_attempted?: boolean;
+    upload_attempted?: boolean;
+    original?: FeedPost;
+    baseline?: StorageObject[];
+    primary?: StorageUploadResult;
+    upload?: StoragePersonalBoxUploadResult;
+    input?: InFeedPost & {
+        objects: FeedObject[];
+    };
+    patch_attempted?: boolean;
+    patched?: boolean;
+    rejected?: boolean;
+    removed?: StorageObject[];
+    readonly create_key: string;
+    readonly upload_key: string;
+    readonly personal_key: string;
+    readonly patch_key: string;
+};
+export declare function newFeedPostSaveState(): FeedPostSaveState;
+export type SaveFeedPostOptions = MultiCreateAttempt & {
+    draft: FeedPostDraft;
+    state: FeedPostSaveState;
+    owner_id?: string;
+    expected?: FeedPost;
+    on_stage?: (stage: FeedSaveStage) => void;
+};
+type SaveDependencies = {
+    feed: FeedOperator;
+    storage: StorageFXOperator;
+    read: (id: string, signal: AbortSignal) => Promise<FeedPost>;
+    changed: (id: string) => void;
+};
+export declare function saveFeedPost(deps: SaveDependencies, opts: SaveFeedPostOptions): Promise<FeedPostSaveResult>;
+export declare function feedObjects(objects: StorageObject[]): FeedObject[];
+export {};

package/dist/src/feed/media.js

@@ -0,0 +1,354 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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 { newIdempotencyKey, isClientErr, } from "@fabriktor/client";
+import { All, ColStorageFeed, ZeroID, } from "@fabriktor/schema";
+import { errResolveFailed, errValidation, errUnconfirmedMutation, } from "../core/err.js";
+import { notifyObserver } from "../core/events.js";
+import { requiredOperationID, resolvedID } from "../core/id.js";
+import { validateStorageUploadFiles, } from "../storage/storage.js";
+import { feedPostInput, validateFeedVisibility } from "./validation.js";
+export function newFeedPostSaveState() {
+    return {
+        create_key: newIdempotencyKey(),
+        upload_key: newIdempotencyKey(),
+        personal_key: newIdempotencyKey(),
+        patch_key: newIdempotencyKey(),
+    };
+}
+export async function saveFeedPost(deps, opts) {
+    const { signal, state, draft, expected } = opts;
+    const stage = (value) => notifyObserver(() => opts.on_stage?.(value));
+    const own = async (id) => {
+        signal.throwIfAborted();
+        const post = (await deps.feed.findOneFeedPost({ id, signal })).value;
+        signal.throwIfAborted();
+        if (!post)
+            throw errResolveFailed({
+                resource: "feed_post",
+                msg: "Feed post could not be resolved.",
+            });
+        if (opts.owner_id && post.owner_id !== opts.owner_id)
+            throw errValidation({
+                field: "owner_id",
+                msg: "This post belongs to another owner.",
+            });
+        return post;
+    };
+    const stored = async (id) => {
+        const out = await deps.storage.downloadObjects({
+            col: ColStorageFeed,
+            owner_id: id,
+            signal,
+        });
+        signal.throwIfAborted();
+        return out.value ?? [];
+    };
+    signal.throwIfAborted();
+    if (state.original &&
+        opts.owner_id &&
+        state.original.owner_id !== opts.owner_id)
+        throw errValidation({ field: "owner_id", msg: "Account context changed." });
+    if (state.rejected)
+        return { post: null, upload: state.upload };
+    if (draft.files.length)
+        validateStorageUploadFiles(draft.files);
+    if (draft.files.length &&
+        draft.save_to_personal_box &&
+        !opts.owner_id?.trim())
+        throw errValidation({
+            field: "owner_id",
+            msg: "A personal copy requires the current user.",
+        });
+    let input = draft.in;
+    if (!state.post_id) {
+        if (expected) {
+            const current = await own(expected.id);
+            checkRevision(current, expected);
+            state.original = current;
+            state.post_id = current.id;
+        }
+        else {
+            input = prepareDraft(draft);
+            if (resolvedID(opts.created_id))
+                state.post_id = opts.created_id;
+            else {
+                if (state.create_attempted)
+                    throw errUnconfirmedMutation();
+                const parent_id = resolvedID(input.reply_to_post_id) ??
+                    resolvedID(input.referenced_post_id);
+                if (parent_id) {
+                    const parent = await deps.read(parent_id, signal);
+                    const existing = resolvedID(input.reply_to_post_id)
+                        ? parent.self.reply_id
+                        : parent.self.reference_id;
+                    if (resolvedID(existing))
+                        throw errValidation({
+                            field: "text",
+                            msg: "A reply or reference already exists.",
+                        });
+                }
+                stage("create");
+                opts.before_request?.();
+                state.create_attempted = true;
+                let out;
+                try {
+                    out = await deps.feed.insertOneFeedPost({
+                        in: input,
+                        signal,
+                        idempotency_key: opts.idempotency_key,
+                    });
+                }
+                catch (error) {
+                    if (isClientErr(error) &&
+                        (error.status === 400 || error.status === 422)) {
+                        state.create_attempted = false;
+                        notifyObserver(() => opts.on_rejected?.());
+                    }
+                    throw error;
+                }
+                // Acknowledgements survive an abort or a failure of the next request.
+                state.post_id = requiredOperationID(out, "Created feed post response did not contain an ID.");
+                notifyObserver(() => opts.on_created?.(state.post_id));
+                if (!draft.files.length)
+                    state.patched = true;
+            }
+        }
+    }
+    const id = state.post_id;
+    if (!id)
+        throw errResolveFailed({
+            resource: "feed_post",
+            msg: "Feed post ID is missing.",
+        });
+    signal.throwIfAborted();
+    const rejectUpload = async () => {
+        if (!expected) {
+            stage("cleanup");
+            try {
+                await deps.feed.deleteOneFeedPost({ id, signal });
+            }
+            catch (error) {
+                if (!isClientErr(error) || error.status !== 404)
+                    throw error;
+            }
+        }
+        signal.throwIfAborted();
+        state.rejected = true;
+        if (!expected) {
+            deps.changed(id);
+            if (resolvedID(state.original?.reply_to_post_id))
+                deps.changed(state.original.reply_to_post_id);
+            if (resolvedID(state.original?.referenced_post_id))
+                deps.changed(state.original.referenced_post_id);
+        }
+        return { post: null, upload: state.upload };
+    };
+    if (state.upload?.primary.all_forbidden)
+        return rejectUpload();
+    state.original ??= await own(id);
+    const original = state.original;
+    if (opts.owner_id && original.owner_id !== opts.owner_id)
+        throw errValidation({ field: "owner_id", msg: "Account context changed." });
+    if (!state.patched) {
+        if (!state.input) {
+            const current = await own(id);
+            checkRevision(current, original);
+            const base = feedPostInput(original);
+            const retained = original.objects.filter((object) => draft.retained_urls.includes(object.public_url));
+            let attachments = retained;
+            if (draft.retained_urls.some((url) => !original.objects.some((object) => object.public_url === url)))
+                throw errValidation({
+                    field: "objects",
+                    msg: "An attachment is no longer available.",
+                });
+            input = prepareDraft({
+                ...draft,
+                in: {
+                    ...base,
+                    text: draft.in.text,
+                    visibility: expected ? draft.in.visibility : original.visibility,
+                    objects: retained,
+                },
+            }, true);
+            const removed = original.objects.filter((object) => !draft.retained_urls.includes(object.public_url));
+            if (draft.files.length || removed.length)
+                state.baseline ??= await stored(id);
+            state.removed ??= (state.baseline ?? []).filter((object) => removed.some((old) => old.public_url === object.public_url));
+            if (draft.files.length) {
+                stage("upload");
+                if (state.upload_attempted && !state.primary)
+                    throw errUnconfirmedMutation();
+                opts.before_request?.();
+                state.upload_attempted = true;
+                state.upload ??= await deps.storage.uploadObjectsWithPersonalBox({
+                    col: ColStorageFeed,
+                    owner_id: id,
+                    uploader_id: original.owner_id,
+                    user_id: original.owner_id,
+                    public_url: true,
+                    full_quality: draft.full_quality,
+                    files: draft.files,
+                    save_to_personal_box: draft.save_to_personal_box,
+                    signal,
+                    idempotency_key: state.upload_key,
+                    personal_box_idempotency_key: state.personal_key,
+                    primary: state.primary,
+                    on_primary: (result) => {
+                        state.primary = result;
+                    },
+                });
+                signal.throwIfAborted();
+                if (state.upload.primary.all_forbidden) {
+                    return rejectUpload();
+                }
+                stage("resolve");
+                const objects = await stored(id);
+                const uploaded = objects.filter((object) => !state.baseline?.some((before) => before.id === object.id));
+                if (uploaded.some((object) => object.owner_id !== id ||
+                    object.uploader_id !== original.owner_id))
+                    throw errResolveFailed({
+                        resource: "feed_object",
+                        msg: "Upload ownership could not be resolved.",
+                    });
+                // Do not finalize a partial download as a completed, unmoderated upload.
+                if (!state.upload.primary.contains_forbidden &&
+                    uploaded.length !== draft.files.length)
+                    throw errResolveFailed({
+                        resource: "feed_object",
+                        msg: "Uploaded attachments are not yet resolved.",
+                    });
+                attachments = [...retained, ...feedObjects(uploaded)];
+            }
+            state.input = {
+                ...input,
+                objects: attachments,
+                is_uploading: false,
+                has_media: attachments.length > 0,
+            };
+        }
+        const current = await own(id);
+        // Only an attempted PATCH may be recognized as already committed. An unchanged
+        // first Save still runs the real PATCH and the backend's computation.
+        if (state.patch_attempted && matchesInput(current, state.input))
+            state.patched = true;
+        else {
+            checkRevision(current, original);
+            stage("publish");
+            opts.before_request?.();
+            state.patch_attempted = true;
+            await deps.feed.replaceOneFeedPost({
+                id,
+                in: state.input,
+                signal,
+                idempotency_key: state.patch_key,
+            });
+            state.patched = true;
+        }
+    }
+    signal.throwIfAborted();
+    deps.changed(id);
+    if (resolvedID(original.reply_to_post_id))
+        deps.changed(original.reply_to_post_id);
+    if (resolvedID(original.referenced_post_id))
+        deps.changed(original.referenced_post_id);
+    if (state.removed?.length) {
+        stage("cleanup");
+        const current = await own(id);
+        for (const object of [...state.removed]) {
+            if (current.objects.some((attached) => attached.public_url === object.public_url))
+                throw errValidation({
+                    field: "updated_at",
+                    msg: "This attachment is in use again.",
+                });
+            await deps.storage.deleteOwnedObject({
+                col: ColStorageFeed,
+                id: object.id,
+                owner_id: id,
+                uploader_id: original.owner_id,
+                signal,
+            });
+            state.removed = state.removed.filter((value) => value.id !== object.id);
+        }
+    }
+    stage("resolve");
+    return { post: await deps.read(id, signal), upload: state.upload };
+}
+function prepareDraft(draft, editing = false) {
+    const input = draft.in;
+    validateFeedVisibility(input.visibility);
+    const reply = resolvedID(input.reply_to_post_id);
+    const reference = resolvedID(input.referenced_post_id);
+    if (reply && reference)
+        throw errValidation({
+            field: "text",
+            msg: "A post cannot be both a reply and a reference.",
+        });
+    const objects = editing ? input.objects : [];
+    if (!input.text.text.trim() &&
+        !reference &&
+        !objects.length &&
+        !draft.files.length)
+        throw errValidation({
+            field: "text",
+            msg: "Post text or media is required.",
+        });
+    return {
+        ...input,
+        text: { text: input.text.text.trim(), file: "", file_url: "", mime: "" },
+        objects,
+        visibility: !editing && (reply || reference) ? All : input.visibility,
+        referenced_post_id: reference ?? ZeroID,
+        reply_to_post_id: reply ?? ZeroID,
+        has_media: !!(objects.length || draft.files.length),
+        is_uploading: !editing && !!draft.files.length,
+    };
+}
+function checkRevision(current, original) {
+    if (current.owner_id !== original.owner_id ||
+        current.updated_at !== original.updated_at)
+        throw errValidation({
+            field: "updated_at",
+            msg: "This post has changed. Open it again before editing.",
+        });
+}
+function matchesInput(post, input) {
+    return (post.text.text === input.text.text &&
+        post.visibility === input.visibility &&
+        post.has_media === input.has_media &&
+        post.is_uploading === input.is_uploading &&
+        post.reply_to_post_id === input.reply_to_post_id &&
+        post.referenced_post_id === input.referenced_post_id &&
+        post.objects.length === input.objects.length &&
+        post.objects.every((object, index) => object.public_url === input.objects[index].public_url &&
+            object.mime_prefix === input.objects[index].mime_prefix));
+}
+export function feedObjects(objects) {
+    if (!objects.length)
+        throw errResolveFailed({
+            resource: "feed_object",
+            msg: "Storage did not return any feed objects.",
+        });
+    return objects.map((object) => {
+        const embedding = object.caption;
+        if (!object.public_url?.trim() ||
+            !object.mime_prefix ||
+            !embedding?.plot_embedding?.length ||
+            embedding.dim !== embedding.plot_embedding.length ||
+            !embedding.plot_embedding.every(Number.isFinite))
+            throw errResolveFailed({
+                resource: "feed_object",
+                msg: "Storage did not return a public URL and complete caption embedding.",
+            });
+        return {
+            public_url: object.public_url,
+            mime_prefix: object.mime_prefix,
+            embedding: {
+                ...embedding,
+                plot_embedding: [...embedding.plot_embedding],
+            },
+        };
+    });
+}

package/dist/src/feed/validation.d.ts

@@ -0,0 +1,4 @@
+import { type FeedPost, type InFeedPost } from "@fabriktor/schema";
+export declare function validateFeedVisibility(value: number): void;
+export declare function feedPostInput(post: FeedPost): InFeedPost;
+export declare function prepareFeedTextPost(input: InFeedPost): InFeedPost;

package/dist/src/feed/validation.js

@@ -0,0 +1,59 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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, Contacts, Private, ZeroID, } from "@fabriktor/schema";
+import { errValidation } from "../core/err.js";
+import { resolvedID } from "../core/id.js";
+export function validateFeedVisibility(value) {
+    if (![All, Contacts, Private].includes(value))
+        throw errValidation({
+            field: "visibility",
+            msg: "Select a valid visibility.",
+        });
+}
+export function feedPostInput(post) {
+    return {
+        text: { text: post.text.text, file: "", file_url: "", mime: "" },
+        objects: post.objects.map((object) => ({
+            public_url: object.public_url,
+            mime_prefix: object.mime_prefix,
+            embedding: {
+                ...object.embedding,
+                plot_embedding: [...object.embedding.plot_embedding],
+            },
+        })),
+        is_uploading: post.is_uploading,
+        has_media: post.has_media,
+        visibility: post.visibility,
+        referenced_post_id: post.referenced_post_id,
+        reply_to_post_id: post.reply_to_post_id,
+    };
+}
+// Text publishing uses generated inputs; media creation has its own storage workflow.
+export function prepareFeedTextPost(input) {
+    validateFeedVisibility(input.visibility);
+    const reply = resolvedID(input.reply_to_post_id);
+    const reference = resolvedID(input.referenced_post_id);
+    if (reply && reference)
+        throw errValidation({
+            field: "text",
+            msg: "A post cannot be both a reply and a reference.",
+        });
+    if (input.objects.length || input.has_media || input.is_uploading)
+        throw errValidation({
+            field: "text",
+            msg: "Use the media workflow for media posts.",
+        });
+    if (!input.text.text.trim() && !reference)
+        throw errValidation({ field: "text", msg: "Post text is required." });
+    return {
+        ...input,
+        objects: [],
+        text: { text: input.text.text.trim(), file: "", file_url: "", mime: "" },
+        visibility: reply || reference ? All : input.visibility,
+        referenced_post_id: reference ?? ZeroID,
+        reply_to_post_id: reply ?? ZeroID,
+    };
+}

package/dist/src/fx.js

@@ -108,12 +108,14 @@ export class FX {
             storage: opts.storage,
         });
         this.feed = newFeedFX({
+            events: this.events,
             feed: opts.feed,
             storage_fx: this.storage,
             keep_alive_interval_ms: opts.feed_keep_alive_interval_ms,
         });
         this.marketplace = newMarketplaceFX({
             marketplace: opts.marketplace,
+            events: this.events,
             keep_alive_interval_ms: opts.marketplace_keep_alive_interval_ms,
         });
         this.timesheets = newTimesheetsFX({

package/dist/src/index.d.ts

@@ -25,10 +25,13 @@ export * from "./core/search-controller.js";
 export * from "./core/search.js";
 export * from "./core/server-clock.js";
 export * from "./feed/feed.js";
+export * from "./feed/media.js";
+export * from "./feed/validation.js";
 export * from "./fulfillments/fulfillments.js";
 export * from "./fx.js";
 export * from "./jobs/jobs.js";
 export * from "./marketplace/marketplace.js";
+export * from "./marketplace/validation.js";
 export * from "./memos/memos.js";
 export * from "./notifications/notifications.js";
 export * from "./payments/payments.js";

package/dist/src/index.js

@@ -25,10 +25,13 @@ export * from "./core/search-controller.js";
 export * from "./core/search.js";
 export * from "./core/server-clock.js";
 export * from "./feed/feed.js";
+export * from "./feed/media.js";
+export * from "./feed/validation.js";
 export * from "./fulfillments/fulfillments.js";
 export * from "./fx.js";
 export * from "./jobs/jobs.js";
 export * from "./marketplace/marketplace.js";
+export * from "./marketplace/validation.js";
 export * from "./memos/memos.js";
 export * from "./notifications/notifications.js";
 export * from "./payments/payments.js";

package/dist/src/marketplace/marketplace.d.ts

@@ -1,17 +1,44 @@
-import type { MarketplaceOperator, OperationResultOf } from "@fabriktor/client";
+import { type MarketplaceOperator, type OperationResultOf } from "@fabriktor/client";
 import { type MarketplaceFavorite, type MarketplacePost, type RPMarketplacePull } from "@fabriktor/schema";
 import { type PullSession, type PullSessionErrorHandler } from "../core/pull.js";
 import { type OwnerSearchOptions, type SearchPage } from "../core/search.js";
+import type { MultiCreateCheckpoint } from "../core/multi-create.js";
+import { EventBus } from "../core/events.js";
+export * from "./validation.js";
+export declare const MarketplaceEvents: {
+    Changed: import("../index.js").EventKey<{
+        owner_id: string;
+        resource: "posts" | "favorites";
+        post_id: string;
+    }>;
+};
 type MarketplacePostInsertOptions = Parameters<MarketplaceOperator["insertOneMarketplacePost"]>[0];
 type MarketplacePostReplaceOptions = Parameters<MarketplaceOperator["replaceOneMarketplacePost"]>[0];
 type MarketplaceFavoriteInsertOptions = Parameters<MarketplaceOperator["insertOneMarketplaceFavorite"]>[0];
 type MarketplaceFavoriteReplaceOptions = Parameters<MarketplaceOperator["replaceOneMarketplaceFavorite"]>[0];
 type MarketplacePullOptions = Parameters<MarketplaceOperator["pull"]>[0];
-export type CreateMarketplacePostOptions = MarketplacePostInsertOptions;
-export type ReplaceMarketplacePostOptions = MarketplacePostReplaceOptions;
+export type CreateMarketplacePostOptions = MarketplacePostInsertOptions & MultiCreateCheckpoint;
+export type ReplaceMarketplacePostOptions = MarketplacePostReplaceOptions & MultiCreateCheckpoint & {
+    expected?: Pick<MarketplacePost, "owner_id" | "updated_at">;
+};
 export type CreateMarketplaceFavoriteOptions = MarketplaceFavoriteInsertOptions;
 export type ReplaceMarketplaceFavoriteOptions = MarketplaceFavoriteReplaceOptions;
-export type SearchMarketplacePostsOptions = OwnerSearchOptions;
+export type SearchMarketplacePostsOptions = OwnerSearchOptions & {
+    post_type?: MarketplacePost["post_type"];
+    user_type?: MarketplacePost["user_type"];
+};
+export type SavedMarketplacePost = MarketplaceFavorite & {
+    post: MarketplacePost | null;
+};
+export type MarketplaceFavoriteOptions = {
+    owner_id: string;
+    post_id?: string;
+    signal?: AbortSignal;
+};
+export type SetMarketplaceFavoriteOptions = MarketplaceFavoriteOptions & {
+    post_id: string;
+    saved: boolean;
+};
 export type SearchMarketplacePostsPage = SearchPage<MarketplacePost>;
 export type MarketplacePullContext = Pick<MarketplacePullOptions, "pull_type" | "entity_id" | "research" | "research_user_type">;
 export type MarketplacePullResult = OperationResultOf<RPMarketplacePull>;
@@ -19,19 +46,34 @@ export type MarketplaceResearchUserType = MarketplacePullOptions["research_user_
 export type MarketplaceSession = PullSession<MarketplacePullResult>;
 export type MarketplaceSessionErrorHandler = PullSessionErrorHandler;
 export type MarketplaceFXOptions = {
+    events?: EventBus;
     marketplace: MarketplaceOperator;
     keep_alive_interval_ms: number;
 };
 export type StartMarketplaceSessionOptions = MarketplacePullContext & {
+    signal?: AbortSignal;
     on_error?: MarketplaceSessionErrorHandler;
 };
 export type StartMarketplaceWelcomeSessionOptions = {
+    signal?: AbortSignal;
     country: string;
     state?: string;
     research_user_type: MarketplaceResearchUserType;
     on_error?: MarketplaceSessionErrorHandler;
 };
 export interface MarketplaceFXOperator {
+    reset(): void;
+    readMarketplacePost(opts: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<MarketplacePost | null>;
+    listMarketplaceFavorites(opts: MarketplaceFavoriteOptions): Promise<MarketplaceFavorite[]>;
+    listSavedMarketplacePosts(opts: MarketplaceFavoriteOptions): Promise<SavedMarketplacePost[]>;
+    setMarketplaceFavorite(opts: SetMarketplaceFavoriteOptions): Promise<MarketplaceFavorite | null>;
+    deleteMarketplacePost(opts: {
+        record: MarketplacePost;
+        owner_id: string;
+    }): Promise<void>;
     createMarketplacePost(opts: CreateMarketplacePostOptions): Promise<MarketplacePost>;
     replaceMarketplacePost(opts: ReplaceMarketplacePostOptions): Promise<MarketplacePost>;
     searchMarketplacePosts(opts: SearchMarketplacePostsOptions): Promise<SearchMarketplacePostsPage>;
@@ -41,9 +83,13 @@ export interface MarketplaceFXOperator {
     startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
 }
 export declare class MarketplaceFX implements MarketplaceFXOperator {
+    private readonly sessions;
+    private readonly events;
+    private mutating;
     private marketplace;
     private keep_alive_interval_ms;
     constructor(opts: MarketplaceFXOptions);
+    reset(): void;
     createMarketplacePost(opts: CreateMarketplacePostOptions): Promise<MarketplacePost>;
     replaceMarketplacePost(opts: ReplaceMarketplacePostOptions): Promise<MarketplacePost>;
     searchMarketplacePosts(opts: SearchMarketplacePostsOptions): Promise<SearchMarketplacePostsPage>;
@@ -51,8 +97,21 @@ export declare class MarketplaceFX implements MarketplaceFXOperator {
     replaceMarketplaceFavorite(opts: ReplaceMarketplaceFavoriteOptions): Promise<MarketplaceFavorite>;
     startSession(opts: StartMarketplaceSessionOptions): Promise<MarketplaceSession>;
     startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
+    readMarketplacePost(opts: {
+        id: string;
+        signal?: AbortSignal;
+    }): Promise<MarketplacePost | null>;
+    listMarketplaceFavorites(opts: MarketplaceFavoriteOptions): Promise<MarketplaceFavorite[]>;
+    listSavedMarketplacePosts(opts: MarketplaceFavoriteOptions): Promise<SavedMarketplacePost[]>;
+    setMarketplaceFavorite(opts: SetMarketplaceFavoriteOptions): Promise<MarketplaceFavorite | null>;
+    deleteMarketplacePost(opts: {
+        record: MarketplacePost;
+        owner_id: string;
+    }): Promise<void>;
+    private mutate;
+    private requireID;
+    private changed;
     private findMarketplacePost;
     private findMarketplaceFavorite;
 }
 export declare function newMarketplaceFX(opts: MarketplaceFXOptions): MarketplaceFX;
-export {};